1. /** 
   2.  * 角色 
   3.  */  
   4. public class Role {  
   5.     //角色当前用户  
   6.     private User nowUser;  
   7.     //角色使用的资源列表  
   8.     private List<Source> sourceList;  
   9.     //角色用户列表  
  10.     private List<User> userList;  
  11.     //角色用户组列表  
  12.     private List<UserGroup> userGroupList;  
  13.     //角色在不同用户下，能管理的部门的关系Map  
  14.     private Map<User,Department> map;    
  16.     /** Creates a new instance of Role */  
  17.     public Role() {  
  18.     }  
  20.     /** 
  21.      * 得到当前角色的用户 
  22.      */  
  23.     public User getNowUser() {  
  24.         return nowUser;  
  25.     }  
  27.     /** 
  28.      * 设置角色当前用户但是角色必须在用户列表和用户组列表中 
  29.      */  
  30.     public void setNowUser(User nowUser) {  
  31.         if (userList.indexOf(nowUser)>-1){  
  32.             this.nowUser = nowUser;  
  33.         } else {  
  34.             for(UserGroup ug:userGroupList){  
  35.                 List<User> tmpList=ug.getUserList();  
  36.                 if (tmpList.indexOf(nowUser)>-1){  
  37.                     this.nowUser = nowUser;  
  38.                 }  
  39.             }  
  40.         }  
  41.     }  
  43.     /** 
  44.      * 得到当前角色所管理的部门 
  45.      */  
  46.     public Department getScope(){  
  47.         if (nowUser != null) {  
  48.             return map.get(nowUser);  
  49.         } else {  
  50.             return null;  
  51.         }  
  52.     }  
  53. }  
  55. /** 
  56.  * 用户 
  57.  */  
  58. public class User {  
  59.     //当前用户角色  
  60.     private Role nowRole;  
  61.     //用户所属部门列表  
  62.     private List<Department> departmentList;  
  63.     //用户所属用户组列表  
  64.     private List<UserGroup> user;  
  65.     //用户拥有角色列表  
  66.     private List<Role> roleList;  
  67.     //用户在不同角色下，能管理的部门的关系Map  
  68.     private Map<Role,Department> map;  
  70.     /** Creates a new instance of User */  
  71.     public User() {  
  72.     }  
  74.     /** 
  75.      * 得到当前用户所管理的部门 
  76.      */  
  77.     public Department getScope(){  
  78.         if (nowRole != null) {  
  79.             return map.get(nowRole);  
  80.         } else {  
  81.             return null;  
  82.         }  
  83.     }  
  85.     /** 
  86.      * 得到当前用户的角色 
  87.      */  
  88.     public Role getNowRole() {  
  89.         return nowRole;  
  90.     }  
  92.     /** 
  93.      * 设置用户当前角色，但是角色必须在用户角色列表中 
  94.      */  
  95.     public void setNowRole(Role nowRole) {  
  96.         if (roleList.indexOf(nowRole) > -1) {  
  97.             this.nowRole = nowRole;  
  98.         }  
  99.     }     
 100. }  
 102. /** 
 104.  * 部门 
 105.  */  
 106. public class Department {  
 108.     private List<User> userList;  
 110.     /** Creates a new instance of Department */  
 111.     public Department() {  
 112.     }     
 113. }  
 115. /** 
 116.  * 资源 
 117.  */  
 118. public class Source {  
 120.     private List<Role> RoleList;  
 122.     private List<Menu> menuList;  
 124.     /** Creates a new instance of Source */  
 125.     public Source() {  
 126.     }     
 127. }  
 129. /** 
 130.  * 用户组 
 131.  */  
 132. public class UserGroup {  
 134.     private List<User> userList;  
 136.     private List<Role> roleList;  
 138.     /** Creates a new instance of UserGroup */  
 139.     public UserGroup() {  
 140.     }  
 142.     public List<User> getUserList() {  
 143.         return userList;  
 144.     }  
 146.     public void setUserList(List<User> userList) {  
 147.         this.userList = userList;  
 148.     }  
 149. }