`
fengchao
  • 浏览: 136805 次
  • 性别: Icon_minigender_1
  • 来自: 大连
社区版块
存档分类
最新评论

权限组件学习 转载于fswan的文章

WorkflowXML配置管理J#Eclipse 
阅读更多
转载于http://blog.csdn.net/fswan/archive/2004/11/02/164063.aspx
学习使用
首先,设置三种要素：用户、群组、角色。用户为登录用，对应到人。群组对应为用户的集合，是一种特殊的用户。角色为一组权限项的集合，用户（群组）都有各自的角色。 权限的实现通过Permission类和Rule类来实现。Permission供外部调用，Rule为一个接口，为权限判断规则。
      Permission是一个抽象类，有以下方法 
	public boolean hasPermission(User user,HashMap oldData,Input input);
	public String getPermissionName();
	public abstract Rule[] getDenyRule();
	public abstract Rule[] getAcceptRule();

hasPermission方法供外部调用，已实现，实现方法为先根据getDenyRule()得到的规则判断权限是否被阻拦，再根据getAcceptRule来判断是否有权限。
而Rule接口的接品则由用户自行定义，随包附带了一个已实现的Rule，实现的功能如下：
先寻找User的所有角色，然后判断角色是否有权限，如果无权限则寻找其父级群组，再取父级群组的所有角色进行判断是否有权限，如果无权限则再往上级群组找，直到找最上一级还是无权限才判断为无权限。
现实现判断权限有无权限的方式已可以达成的有以下三种：
1、  是否有操作的权限。
2、  是否有操作的子操作的权限。
3、  在数据为某条件时有操作（子操作）的权限。

在进行程序开发时，第一步，编写User,Group,Role的实现类，已提供了一套XML的实现类。
第二步，写配置文件，进行权限项的配置。
第三步，在程序中要进行权限判断的地方调用Permission.hasPermission方法即可. 首先,我定义了一个用户接口,可以从其中取出其的各种属性.代码如后面所示.用户除了各种不同的属性以外还必须设置其角色以及所属的群组.
然后定义一个AbstractUser把User共性的东西进行处理.所有的取属性的方法都已实现.用户只要根据实现情况继承AbstractUser把自己要定义的属性进行处理即可.(因为每个系统的用户都会有不同的属性,所以留成抽象类供使用者自己扩展). 只要初始化变量description, name ,group ,id, prop,role,propMap即可.
最后定义了一个类UserImpl来实现具体的User作随包的一个User供一般使用者使用.不建议直接使用UserImpl,因为以后的版本可能会重写该类.如果要使用的话可以把该类改名为自己的类即可.

这部分涉及到了一个ResourceLib类,该类中存是我自己定义的存储各种资源配置用的类,可以直接使用.

======================User.java=============================== 
package org.fswan.permission;
 
import org.fswan.Identity;
import java.util.Properties;
import org.fswan.workflow.exception.CantFoundIDException;
public interface User
{
	/**
	 * 获取用户名
	 * @return 用户名
	 */
	public String getName();
	/**
	 * 获取用户描述
	 * @return 描述
	 */
	public String getDescription();
	/**
	 * 获取用户标识
	 * @return 用户标识
	 */
	public Identity getId();
	/**
	 * 获取属性
	 * @return 属性值
	 */
	public Properties getProperties();
	/**
	 * 获取所属组
	 * @return 组列表
	 */
	public Group[] getGroups() throws CantFoundIDException;
	/**
	 * 获取所有角色
	 * @return 角色数组
	 */
	public Role[] getRoles() throws CantFoundIDException;
	/**
	 * 获取用户用作权限判断的属性
	 * @param prop 权限属性
	 * @return 属性值
	 */
	public Object getPermissionProp(String prop);
}

=======================AbstractUser=================================== 
package org.fswan.permission;
import java.util.HashMap;
import java.util.Properties;
 
import org.fswan.Identity;
import org.fswan.workflow.exception.IdentityMappingError;
/**
 * 
 * 实现AbstractUser的类构造必须做的一些事
 * 初始化变量description,name,group,id,prop,role,propMap
 */
public class AbstractUser implements User
{
	/**
	 * 描述
	 */
	protected String description;
	/**
	 * 名称
	 */
	protected String name;
	/**
	 * 所属的组的标识
	 */
	protected Identity[] group;
	/**
	 * 用户标识
	 */
	protected Identity id;
	/**
	 * 属性
	 */
	protected Properties prop;
	/**
	 * 角色
	 */
	protected Identity[] role;
	/**
	 * 权限属性存储的位置
	 */
	protected HashMap propMap;
	
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getDescription()
	 */
	public String getDescription()
	{
		return description;
	}
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getGroups()
	 */
	public Group[] getGroups()
	{
		Group[] groups = new Group[group.length];
		for (int i = 0; i < groups.length; i++)
		{
			try
			{
				groups[i] = (Group) group[i].newInstance();
			} catch (IdentityMappingError e)
			{
				e.printStackTrace();
			}
		}
		return groups;
	}
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getId()
	 */
	public Identity getId()
	{
		return id;
	}
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getName()
	 */
	public String getName()
	{
		return name;
	}
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getProperties()
	 */
	public Properties getProperties()
	{
		return prop;
	}
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getRoles()
	 */
	public Role[] getRoles()
	{
		Role[] roles = new Role[role.length];
		for (int i = 0; i < roles.length; i++)
		{
			try
			{
				roles[i] = (Role) role[i].newInstance();
			} catch (IdentityMappingError e)
			{
				e.printStackTrace();
			}
		}
		return roles;
	}
	public String toString()
	{
		String retStr = id.getIdName();
		retStr += ":" + name;
		retStr += "   " + description + "\n";
		retStr += "Group:";
		Group[] groups = this.getGroups();
		if (groups != null)
		{
			for (int i = 0; i < groups.length; i++)
			{
				if (groups[i] != null)
					retStr += groups[i].getId().getIdName() + "\t";
			}
		}
		Properties p = getProperties();
		Object[] obj = p.keySet().toArray();
		for (int i = 0; i < obj.length; i++)
		{
			retStr+=obj[i]+":"+p.getProperty(obj[i].toString())+"\n";
		}
		return retStr;
	}
	
	/* (non-Javadoc)
	 * @see org.fswan.permission.User#getPermissionProp(java.lang.String)
	 */
	public Object getPermissionProp(String prop)
	{
		return propMap.get(prop);
	}
 
}

==============================UserImpl.java=========================== 
package org.fswan.permission;
import java.util.ArrayList;
import java.util.Properties;
import javax.xml.parsers.DocumentBuilderFactory;
import org.fswan.Identity;
import org.fswan.IdentityImpl;
import org.fswan.ImplementIdentity;
import org.fswan.ResourceLib;
import org.fswan.workflow.exception.IdentityMappingError;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
public class XMLUser extends AbstractUser implements ImplementIdentity
{
	/**
	 * XML中定义用户的标签
	 */
	public static final String USER = "User";
	public Object newInstance(Identity id)
	{
		ArrayList sources = ResourceLib.getXmlResource();
		for (int i = 0; i < sources.size(); i++)
		{
			try
			{
				Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(sources.get(i).toString());
				NodeList nl = doc.getElementsByTagName(USER);
				for (int j = 0; j < nl.getLength(); j++)
				{
					Element tempEl = (Element) nl.item(j);
					String idStr = tempEl.getAttribute("id");
					if (idStr != null && !idStr.equals(""))
					{
						if (idStr.equals(id.getIdName()))
						{
							this.id = new IdentityImpl(Identity.SWITCH, Identity.XMLUSER, idStr);
							NodeList tempNl = tempEl.getElementsByTagName("Name");
							name = tempNl.item(0).getChildNodes().item(0).getNodeValue();
							tempNl = tempEl.getElementsByTagName("Description");
							description = tempNl.item(0).getChildNodes().item(0).getNodeValue();
							tempNl = tempEl.getElementsByTagName("ParentGroup");
							Identity[] groups = new Identity[tempNl.getLength()];
							for (int iGroup = 0; iGroup < groups.length; iGroup++)
							{
								Element tempEl2 = (Element) tempNl.item(iGroup);
								String subType = tempEl.getAttribute("subType");
								if(subType==null || subType.equals(""))subType = Identity.XMLGROUP;
								groups[iGroup] = new IdentityImpl(Identity.GROUP, subType, tempEl2.getAttribute("id"));
							}
							this.group = groups;
							tempNl = tempEl.getElementsByTagName("Role");
							Identity[] roles = new Identity[tempNl.getLength()];
							for (int iRole = 0; iRole < tempNl.getLength(); iRole++)
							{
								Element tempEl2 = (Element) tempNl.item(iRole);
								String subType = tempEl.getAttribute("subType");
								if(subType==null || subType.equals(""))subType = Identity.XMLROLE;
								roles[iRole] = new IdentityImpl(Identity.ROLE, subType, tempEl2.getAttribute("id"));
							}
							this.role = roles;
							this.prop = new Properties();
							tempNl = tempEl.getElementsByTagName("Property");
							if (tempNl != null)
								for (int k = 0; k < tempNl.getLength(); k++)
								{
									Element tempElement = (Element) tempNl.item(k);
									System.out.println(tempElement.getAttribute("name"));
									this.prop.setProperty(tempElement.getAttribute("name"), tempElement.getAttribute("value"));
								}
							return this;
						}
					}
				}
			} catch (Exception e)
			{
				e.printStackTrace();
			}
		}
		return null;
	}
	public static void main(String[] args)
	{
		try
		{
			ResourceLib.addResource("D:\\eclipse\\workspace\\workflow\\workflow.xml");
			User u = (User) new IdentityImpl(Identity.USER, Identity.XMLUSER, "U01").newInstance();
			System.out.println(u);
		} catch (IdentityMappingError e)
		{
			e.printStackTrace();
		}
	}
}

========================XML格式===================== 
<User id="U01">
		<Name>Swan</Name>
		<Description>方志文</Description>
		<ParentGroup id="G01"/>
		<Property name="SEX" value="male"/>
		<Property name="AGE" value="20"/>
	</User>
========================XML描述文件==================
	<xs:complexType name="User">
		<xs:annotation>
			<xs:documentation>用户名</xs:documentation>
		</xs:annotation>
		<xs:sequence>
			<xs:element name="Name"/>
			<xs:element name="Description"/>
			<xs:element name="ParentGroup" type="Identity" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="Role" type="Identity" minOccurs="0" maxOccurs="unbounded"/>
			<xs:element name="Property" minOccurs="0" maxOccurs="unbounded">
				<xs:complexType>
					<xs:attribute name="name" use="required"/>
					<xs:attribute name="value" use="required"/>
				</xs:complexType>
			</xs:element>
		</xs:sequence>
		<xs:attribute name="id" use="required"/>
	</xs:complexType>

权限组件之二(群组)收藏
    首先,我定义了一个群组接口,除了继承用户的方法以外还有两个方法,getUsers,getSubGroup.代码如后面所示.用户除了各种不同的属性以外还必须设置其角色以及所属的群组.

    然后定义一个AbstractGroup,他继承了Group以及AbstractUser,并实现了Group接口定义的两个方法.用户只要根据实现情况继承AbstractGroup把自己要定义的属性进行处理即可.(因为每个系统的用户都会有不同的属性,所以留成抽象类供使用者自己扩展). 只要初始化变量description, name ,group ,id, prop,role,propMap,subGroup,user即可.

    最后定义了一个类XMLGroup来实现具体的Group作随包的一个Group供一般使用者使用.不建议直接使用XMLGroup,因为以后的版本可能会重写该类.如果要使用的话可以把该类改名为自己的类即可.



    这部分涉及到了一个ResourceLib类,该类中存是我自己定义的存储各种资源配置用的类,可以直接使用.



======================Group.java=============================== 
package org.fswan.permission;

public interface Group extends User

{

    /**

     * 获取组下所有的用户

     * @return 用户数组

     */

    public User[] getUsers();

    /**

     * 获取组下属的组

     * @return 组的数组

     */

    public Group[] getSubGroup();

}

=======================AbstractGroup================================== 
package org.fswan.permission;

 

import org.fswan.Identity;

import org.fswan.workflow.exception.IdentityMappingError;

public class AbstractGroup extends AbstractUser implements Group

{

    protected Identity[] subGroup;

    protected Identity[] user;

    /* (non-Javadoc)

     * @see org.fswan.permission.Group#getSubGroup()

     */

    public Group[] getSubGroup()

    {

        Group[] groups = new Group[subGroup.length];

       for (int i = 0; i < groups.length; i++)

       {

           try

           {

              groups[i] = (Group)subGroup[i].newInstance();

           } catch (IdentityMappingError e)

           {

               e.printStackTrace();

           }

       }

        return groups;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Group#getUsers()

     */

    public User[] getUsers()

    {

      User[] users = new User[user.length];

       for (int i = 0; i < users.length; i++)

       {

           try

           {

               users[i] = (User)user[i].newInstance();

           } catch (IdentityMappingError e)

           {

               e.printStackTrace();

           }

       }

        return users;

    }

    public String toString()

    {

        String retStr = id.getIdName();

        retStr +=":"+name;

        retStr += "   "+description;

        return retStr;

    }

}

==============================XMLGroup.java=========================== 
package org.fswan.permission;

 

import java.util.ArrayList;

import java.util.Properties;

 

import javax.xml.parsers.DocumentBuilderFactory;

 

import org.fswan.Identity;

import org.fswan.IdentityImpl;

import org.fswan.ImplementIdentity;

import org.fswan.ResourceLib;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

 

public class XMLGroup extends AbstractGroup implements ImplementIdentity

{

    /**

     * XML中定义群组的标签

     */

    public static final String GROUP = "Group";

    public Object newInstance(Identity id)

    {

        ArrayList sources = ResourceLib.getXmlResource();

       for (int i = 0; i < sources.size(); i++)

       {

           try

           {

               Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(sources.get(i).toString());

               NodeList nl = doc.getElementsByTagName(GROUP);

               for (int j = 0; j < nl.getLength(); j++)

               {

                   Element tempEl = (Element)nl.item(j);

                  

                   String idStr = tempEl.getAttribute("id");

                   if(idStr!=null && !idStr.equals(""))

                  {

                      if(idStr.equals(id.getIdName()))

                      {

                          this.id = new IdentityImpl(Identity.SWITCH,Identity.XMLGROUP,idStr);

                          //加载名称

                          NodeList tempNl = tempEl.getElementsByTagName("Name");

                          name = tempNl.item(0).getChildNodes().item(0).getNodeValue();

                          //加载描述

                          tempNl = tempEl.getElementsByTagName("Description");

                          description = tempNl.item(0).getChildNodes().item(0).getNodeValue();

                          //加载父群组

                          tempNl = tempEl.getElementsByTagName("ParentGroup");

                          Identity[] groups = new Identity[tempNl.getLength()];

                          for (int iGroup=0; iGroup < tempNl.getLength(); iGroup++)

                          {

                              tempEl = (Element)tempNl.item(iGroup);

                              groups[iGroup] = new IdentityImpl(Identity.GROUP,Identity.XMLGROUP,tempEl.getAttribute("id"));

                          }

                          this.subGroup = groups;

                          //加载角色

                          tempNl = tempEl.getElementsByTagName("Role");

                          Identity[] roles = new Identity[tempNl.getLength()];

                          for (int iRole=0; iRole < tempNl.getLength(); iRole++)

                          {

                              tempEl = (Element)tempNl.item(iRole);

                              roles[iRole] = new IdentityImpl(Identity.ROLE,Identity.XMLROLE,tempEl.getAttribute("id"));

                          }

                          this.role = roles;

                          //加载属性

                          this.prop = new Properties();

                          tempNl = tempEl.getElementsByTagName("Property");

                          if(tempNl!=null)

                          for (int k = 0; k < tempNl.getLength(); k++)

                          {

                              Element tempElement = (Element)tempNl.item(k);

                              this.prop.setProperty(tempElement.getAttribute("name"),tempElement.getAttribute("value"));

                          }

                          //加载子群组

                          tempNl = tempEl.getElementsByTagName("SubGroup");

                          if (tempNl != null)

                          {

                              subGroup = new Identity[tempNl.getLength()];

                             for (int k = 0; k < subGroup.length; k++)

                             {

                                 Element tempElement = (Element) tempNl.item(k);

                                 subGroup[k] = new IdentityImpl(Identity.GROUP,Identity.XMLGROUP,tempElement.getAttribute("id"));

                             }

                          }

                          //加载用户

                          tempNl = tempEl.getElementsByTagName("User");

                          if (tempNl != null)

                          {

                             user = new Identity[tempNl.getLength()];

                             for (int k = 0; k < subGroup.length; k++)

                             {

                                 Element tempElement = (Element) tempNl.item(k);

                                 user[k] = new IdentityImpl(Identity.USER,Identity.XMLUSER,tempElement.getAttribute("id"));

                             }

                          }

                          return this;

                      }

                  }

               }

           } catch (Exception e)

           {

               e.printStackTrace();

           }

       }

        return null;

    }

}

========================XML格式===================== 
<Group id="G01">

       <Name>系统部</Name>

      <Description>系统部</Description>

     </Group>

========================XML描述文件================== 
    <xs:complexType name="Group">

        <xs:annotation>

           <xs:documentation>群组</xs:documentation>

        </xs:annotation>

        <xs:complexContent>

           <xs:extension base="User">

               <xs:sequence>

                   <xs:element name="SubGroup" type="Identity" minOccurs="0" maxOccurs="unbounded"/>

                   <xs:element name="User" type="Identity" minOccurs="0" maxOccurs="unbounded"/>

               </xs:sequence>

           </xs:extension>

        </xs:complexContent>

    </xs:complexType>

    首先,我定义了一个角色接口,可以从其中取出其的各种属性.代码如后面所示.

    然后定义一个AbstractRole把Role共性的东西进行处理.所有的取属性的方法都已实现.用户只要根据实现情况继承AbstractRole把自己要定义的属性进行处理即可.(因为每个系统的用户都会有不同的属性,所以留成抽象类供使用者自己扩展). 只要初始化变量description, name ,id, prop,users(可能是群组), permissionMap即可.



    最后定义了一个类XMLRole来实现具体的Role作随包的一个Role供一般使用者使用.不建议直接使用XMLRole,因为以后的版本可能会重写该类.如果要使用的话可以把该类改名为自己的类即可.



    这部分涉及到了一个ResourceLib类,该类中存是我自己定义的存储各种资源配置用的类,可以直接使用.



======================Role.java=============================== 
package org.fswan.permission;

import org.fswan.Identity;

import java.util.Properties;

import org.fswan.workflow.exception.CantFoundIDException;

public interface Role

{

    /**

     * 获取角色ID

     * @return 

     */

    public Identity getId();

    /**

     * 获取角色的名称

     * @return 名称

     */

    public String getName();

    /**

     * 获取角色的描述

     * @return 描述

     */

    public String getDescription();

    /**

     * 获取角色的所有的用户(组)

     * @return 用户

     */

    public User[] getUsers() throws CantFoundIDException;

    /**

     * 角色的属性

     * @return 属性值

     */

    public Properties getProperties();

    

    /**

     * 获取用户用作权限判断的属性

     * @param prop 权限属性

     * @return 属性值

     */

    public Object getPermissionProp(String prop);

}

=======================AbstractRole=================================== 
package org.fswan.permission;

 

import java.util.HashMap;

import java.util.Properties;

 

import org.fswan.Identity;

import org.fswan.workflow.exception.IdentityMappingError;

 

public class AbstractRole implements Role

{

    /**

     * 描述

     */

    protected String description ;

    /**

     * 名称

     */

    protected String name;

    /**

     * 标识

     */

    protected Identity id;

    /**

     * 属性

     */

    protected Properties prop;

    /**

     * 该角色所有用户的标识

     */

    protected Identity[] users;

    /**

     * 权限属性表

     */

    protected HashMap permissionMap;

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getDescription()

     */

    public String getDescription()

    {

        return description;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getId()

     */

    public Identity getId()

    {

        return id;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getName()

     */

    public String getName()

    {

        return name;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getProperties()

     */

    public Properties getProperties()

    {

        return prop;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getUsers()

     */

    public User[] getUsers()

    {

      User[] retUser = new User[users.length];

       for (int i = 0; i < retUser.length; i++)

       {

           try

           {

               retUser[i] = (User)users[i].newInstance();

           } catch (IdentityMappingError e)

           {

               e.printStackTrace();

           }

       }

        return retUser;

    }

    

    public String toString()

    {

        String retStr = id.getIdName();

        retStr +=":"+name;

        retStr += "   "+description;

        return retStr;

    }

 

    /* (non-Javadoc)

     * @see org.fswan.permission.Role#getPermissionProp(java.lang.String)

     */

    public Object getPermissionProp(String prop)

    {

        return permissionMap.get(prop);       

    }
}

==============================XMLRole.java=========================== 
/*

 * Created on 2004-4-21

 *

 * To change the template for this generated file go to

 * Window&gt;Preferences&gt;Java&gt;Code Generation&gt;Code and Comments

 */

package org.fswan.permission;

import java.util.ArrayList;

import java.util.Properties;

 

import javax.xml.parsers.DocumentBuilderFactory;

 

import org.fswan.Identity;

import org.fswan.IdentityImpl;

import org.fswan.ImplementIdentity;

import org.fswan.ResourceLib;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.NodeList;

public class XMLRole extends AbstractRole implements ImplementIdentity

{

    /**

     * XML标签用的字符串

     */

    public static final String ROLE = "Role";

    public Object newInstance(Identity id)

    {

        ArrayList sources = ResourceLib.getXmlResource();

       for (int i = 0; i < sources.size(); i++)

       {

           try

           {

               Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(sources.get(i).toString());

               NodeList nl = doc.getElementsByTagName(ROLE);

               for (int j = 0; j < nl.getLength(); j++)

               {

                   Element tempEl = (Element)nl.item(j);

                  

                   String idStr = tempEl.getAttribute("id");

                   if(idStr!=null && !idStr.equals(""))

                  {

                      if(idStr.equals(id.getIdName()))

                      {

                          this.id = new IdentityImpl(Identity.SWITCH,Identity.XMLROLE,idStr);

                          

                          NodeList tempNl = tempEl.getElementsByTagName("Name");

                          name = tempNl.item(0).getChildNodes().item(0).getNodeValue();

                          tempNl = tempEl.getElementsByTagName("Description");

                          description = tempNl.item(0).getChildNodes().item(0).getNodeValue();

                                                                                                       

                          this.prop = new Properties();

                          tempNl = tempEl.getElementsByTagName("Property");

                          if(tempNl!=null)

                          for (int k = 0; k < tempNl.getLength(); k++)

                          {

                              Element tempElement = (Element)tempNl.item(k);

                              this.prop.setProperty(tempElement.getAttribute("name"),tempElement.getAttribute("value"));

                          }

                          

                          return this;

                      }

                  }

               }

           } catch (Exception e)

           {

               e.printStackTrace();

           }

       }

        return null;

    }

    

}

========================XML格式===================== 
   <Role id="R01">

       <Name>系统管理员</Name>

      <Description>系统管理员</Description>

   </Role>

========================XML描述文件================== 
    <xs:complexType name="Role">

        <xs:annotation>

           <xs:documentation>角色名</xs:documentation>

        </xs:annotation>

        <xs:sequence>

           <xs:element name="Name"/>

           <xs:element name="Description"/>

           <xs:element name="Property" minOccurs="0" maxOccurs="unbounded"/>

        </xs:sequence>

        <xs:attribute name="id" use="required"/>

    </xs:complexType>
分享到：
| BUG? must be escaped when used within th ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    统一权限组件

    《统一权限组件详解》 在IT领域，权限管理是一个至关重要的环节，尤其在大型系统或者企业级应用中，权限控制不仅...对于开发者而言，深入学习和实践这类组件，有助于提升系统的安全性，并为用户提供更友好的权限体验。

    权限组件设计思路(推荐)

    本篇文章将深入探讨权限组件的设计思路，帮助开发者理解如何有效地实现这一重要功能。 首先，权限组件的核心目标是实现对用户操作的精细化控制。这包括对资源（如数据、功能模块）的访问权限进行定义、分配、检查...

    基于Java语言的Android权限申请组件LinJiuXPermissionClient设计源码

    该项目是一个基于Java语言的Android权限申请组件LinJiuXPermissionClient，包含了101个文件，其中包括28个XML配置文件、13个MD5校验文件...该组件专为Android平台上的权限管理需求而设计，适用于各种Android应用程序。

    djangorbac权限管理组件.zip

    djangorbac权限管理组件

    解决金蝶远程组件及配置工具异常：组件无法正常工作

    七、用户权限未设置：中间层、客户端或者其中的一个或者多个不在域里边，那么要求客户端当前登录Windows的用户必须存于中间层服务器的Power Users组中或者administrators组中。 解决方法：确保用户权限正确，中间层...

    COM 组件注册方法

    COM组件，全称为Component Object Model，是微软提出的一种软件组件模型，它允许不同应用程序之间进行交互和通信。...同时，MTS还允许对组件进行配置，如设置安全权限、事务属性等，进一步增强了组件的管理和控制能力。

    delphi管理权限源码

    本篇文章将深入探讨Delphi如何实现权限管理，以及通过提供的源代码，新手可以学习到哪些关键概念。 首先，权限管理的核心是角色（Role）- 权限（Permission）模型。在Delphi中，你可以创建一系列角色，每个角色对应...

    zoo组件joomla

    Zoo组件同样适用于文章管理。它不仅支持标准的文章格式，还可以创建自定义文章类型，适应新闻、博客、案例研究等多种内容形式。每篇文章可以设置不同的元数据、标签、作者信息，并通过内置的评论系统促进用户互动。...

    权限设计(包括表结构)

    权限设计的主要组件包括权限管理模块、角色管理模块、用户管理模块和权限分配模块。权限管理模块负责管理所有的权限，包括功能权限和资源权限。角色管理模块负责管理所有的角色，包括管理员、普通用户等。用户管理...

    C# winform 权限控制 包括角色 用户 权限设置

    在C# WinForm应用开发中，权限控制是一个关键的安全组件，它确保了只有授权的用户才能访问特定的功能或数据。本教程将详细讲解如何在C# WinForm环境中实现基于角色的权限控制，包括角色、用户和权限的设置。 首先，...

    win7语音组件

    标题中的“win7语音组件”指的是Windows 7操作系统中的语音技术相关组件，这些组件支持文本转语音（TTS，Text-to-Speech）功能，允许计算机将文字转化为可听见的语音输出。在进行TTS开发时，这部分组件是必不可少的...

    easyui基本权限管理系统

    复选框可以用来选择或取消具体的操作权限，而树形组件则适合展示层次化的资源结构，用户可以选择某个节点（代表资源）下的所有权限。 3. 动态菜单生成 根据用户的角色，动态生成菜单是权限管理的关键。EasyUI的...

    通用的权限管理，ssh项目中权限管理的一个小示例

    在这个"通用的权限管理，ssh项目中权限管理的一个小示例"中，我们将深入探讨SSH框架如何实现权限控制，并学习如何通过自定义标签进行更灵活的定制。 首先，让我们了解一下SSH框架的三个主要组件： 1. **Spring**：...

    检索 COM 类工厂中 CLSID 为 {96749377-3391-11D2-9EE3-00C04F797396} 的组件失败，适用于64位win7

    3. **安装兼容性补丁**：如果是由于系统兼容性导致的问题，可能需要寻找适用于64位Win7的更新或补丁。 4. **以管理员权限运行**：尝试以管理员权限启动可能导致错误的应用程序，看是否能解决问题。 5. **修复或重...

    springboot通用后台管理系统

    主要定位于后台管理系统学习交流，已内置后台管理系统的基础功能和高效的代码生成工具， 包括：系统权限组件、数据权限组件、数据字典组件、核心工具组件、视图操作组件、工作流组件、代码生成等。 前端界面风格...

    vue权限管理

    本文将详细介绍Vue权限管理相关知识点，为vue实战、学习和项目实战提供参考。 首先，Vue权限管理可以分为前端权限控制和后端权限控制两个部分。前端权限控制主要负责页面级别的访问权限，例如页面元素显示隐藏、...

    COM+组件编程技术内幕

    在学习COM+组件编程时，需要理解这些基本概念并掌握如何创建、配置和使用COM+组件。同时，熟悉Visual Studio和COM+设计工具，如Component Services，将有助于实际开发过程中的应用。尽管现在.NET Framework和.NET ...

    Java组件设计

    第1章 组件设计概述 第2章 组件设计原则 第3章 预备知识 第4章 配置组件 第5章 Socket通信组件 第6章 日志组件 第7章 数据库访问组件 第8章 JSON转换器 第9章 权限组件

    SpringMVC+Hibernate+Easyui权限管理系统

    对于初学者来说，这是一个很好的学习平台，不仅可以深入了解各组件的使用，还能掌握权限管理的设计和实现。同时，对于有经验的开发者，此项目也是一个有价值的参考，可以帮助他们快速构建类似的业务系统。

Magicbox
Global site tag (gtag.js) - Google Analytics