写用户与角色的关系

角色与权限:多对多
一个角色可以有多个权限，一个权限可以被多个角色使用。

那我们下面就来使用我们完成的角色。

我们先来看一下需求，记不记得之前的用户编辑界面：

可以看到，我们注册用户的时候是要给用户安排一个角色的，而我们的角色在角色管理系统里面已经创建好了，可以从创建好的角色中挑选需要的角色(该角色拥有自己特有的权限)。

所以，我们说一下用户与角色的关系设计:
用户：用户1，用户2
角色：管理员，一般用户

用户与角色的关系：多对多
一个用户可以有多个角色；一个角色可以被多个用户使用

用户：user
用户id,名称...
1      用户1
2      用户2

用户角色：user_role
用户id,角色id
1       1
1       2
2       2

角色：role
角色Id,名称
1      管理员
2      一般用户

总体就是:



查询出用户后；需要知道这个用户有哪些角色

我们下面来实现它。实现它就是改造之前的用户管理模块.我们刚刚设计过，“用户”表和“角色”表我们之前都有的，这里不能动，我们需要做的就是设计编写出“用户与角色”这张中间表:
UserRole.java:

[java]  view plain  copy

1. package cn.edu.hpu.tax.user.entity;  
2.   
3. import java.io.Serializable;  
4.   
5. public class UserRole implements Serializable {  
6.   
7.     //联合主键  
8.     private UserRoleId id;  
9.   
10.     public UserRole() {  
11.           
12.     }  
13.       
14.     public UserRole(UserRoleId id) {  
15.         this.id = id;  
16.     }  
17.   
18.   
19.     public UserRoleId getId() {  
20.         return id;  
21.     }  
22.   
23.   
24.     public void setId(UserRoleId id) {  
25.         this.id = id;  
26.     }  
27.       
28. }  

联合主键类(需要实现Serializable接口和改写equals和hashCode方法)
UserRoleId.java:

[java]  view plain  copy

1. package cn.edu.hpu.tax.user.entity;  
2.   
3. import java.io.Serializable;  
4.   
5. import cn.edu.hpu.tax.role.entity.Role;  
6.   
7. public class UserRoleId implements Serializable {  
8.       
9.     private String userId;  
10.     private Role role;  
11.       
12.     public UserRoleId(){  
13.           
14.     }  
15.       
16.     public UserRoleId(String userId, Role role) {  
17.         super();  
18.         this.userId = userId;  
19.         this.role = role;  
20.     }  
21.       
22.     public String getUserId() {  
23.         return userId;  
24.     }  
25.     public void setUserId(String userId) {  
26.         this.userId = userId;  
27.     }  
28.     public Role getRole() {  
29.         return role;  
30.     }  
31.     public void setRole(Role role) {  
32.         this.role = role;  
33.     }  
34.       
35.     @Override  
36.     public int hashCode() {  
37.         final int prime = 31;  
38.         int result = 1;  
39.         result = prime * result + ((role == null) ? 0 : role.hashCode());  
40.         result = prime * result + ((userId == null) ? 0 : userId.hashCode());  
41.         return result;  
42.     }  
43.     @Override  
44.     public boolean equals(Object obj) {  
45.         if (this == obj)  
46.             return true;  
47.         if (obj == null)  
48.             return false;  
49.         if (getClass() != obj.getClass())  
50.             return false;  
51.         UserRoleId other = (UserRoleId) obj;  
52.         if (role == null) {  
53.             if (other.role != null)  
54.                 return false;  
55.         } else if (!role.equals(other.role))  
56.             return false;  
57.         if (userId == null) {  
58.             if (other.userId != null)  
59.                 return false;  
60.         } else if (!userId.equals(other.userId))  
61.             return false;  
62.         return true;  
63.     }  
64.       
65. }  

然后写我们的映射文件:
UserRole.hbm.xml

[html]  view plain  copy

1. <?xml version="1.0" encoding="utf-8"?>  
2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
4.   
5.   
6. <hibernate-mapping>  
7.     <class name="cn.edu.hpu.tax.user.entity.UserRole" table="user_role">  
8.          <composite-id name="id" class="cn.edu.hpu.tax.user.entity.UserRoleId">  
9.             <key-many-to-one name="role" lazy="false" class="cn.edu.hpu.tax.role.entity.Role">  
10.                 <column name="role_id"></column>  
11.             </key-many-to-one>  
12.             <key-property name="userId" type="java.lang.String">  
13.                 <column name="user_id" length="32"></column>  
14.             </key-property>  
15.          </composite-id>  
16.     </class>  
17.   
18.   
19. </hibernate-mapping>  

按理来说接下来应该是Dao、Service、Action等，但是这些我们做用户管理的时候已经做好了，我们现在来改造它们。

先改造Action层:

[java]  view plain  copy

1. package cn.edu.hpu.tax.user.action;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5. import java.util.List;  
6. import java.util.UUID;  
7.   
8. import javax.annotation.Resource;  
9. import javax.servlet.ServletOutputStream;  
10. import javax.servlet.http.HttpServletResponse;  
11.   
12. import org.apache.commons.io.FileUtils;  
13. import org.apache.commons.lang3.StringUtils;  
14. import org.apache.struts2.ServletActionContext;  
15.   
16. import com.opensymphony.xwork2.ActionContext;  
17.   
18. import cn.edu.hpu.tax.core.action.BaseAction;  
19. import cn.edu.hpu.tax.role.service.RoleService;  
20. import cn.edu.hpu.tax.user.entity.User;  
21. import cn.edu.hpu.tax.user.service.UserService;  
22.   
23.   
24. public class UserAction extends BaseAction{  
25.       
26.     @Resource  
27.     private UserService userService;  
28.     //注入RoleService  
29.     @Resource  
30.     private RoleService roleService;  
31.     //其它参数省略  
32.       
33.     //跳转到新增页面  
34.     public String addUI(){  
35.         //加载角色列表  
36.         ActionContext.getContext().getContextMap().put("roleList", roleService.findObjects());  
37.         return "addUI";  
38.     }  
39.     //其它方法省略  
40.   
41.   
42. }  

上面我们在进入添加页面之前我们先从数据库将所有角色类型全部取出放入ActionContext域中(需要注入roleService来获得所有角色信息)。

我们之前用户“添加”页面的角色这一块是空的:


我们现在将我们放置在ActionContext域中的角色信息取出，使用struts的<s:checkboxlist>标签来将数据以复选框的形式展示在页面:

[html]  view plain  copy

1. <tr>  
2.     <td class="tdBg" width="200px">角色：</td>  
3.     <td>  
4.         <s:checkboxlist list="#roleList" name="userRoleIds" listKey="roleId" listValue="name">  
5.         </s:checkboxlist>  
6.     </td>  
7. </tr>  

效果:


可以看到用户角色一栏已经出现了我们之前添加的角色了。

然后接下来保存用户的时候我们也要将给用户分配的角色保存下来，我们继续完成Action的改造:

[java]  view plain  copy

1. package cn.edu.hpu.tax.user.action;  
2.   
3. import java.io.File;  
4. import java.io.IOException;  
5. import java.util.List;  
6. import java.util.UUID;  
7.   
8.   
9. import javax.annotation.Resource;  
10. import javax.servlet.ServletOutputStream;  
11. import javax.servlet.http.HttpServletResponse;  
12.   
13.   
14. import org.apache.commons.io.FileUtils;  
15. import org.apache.commons.lang3.StringUtils;  
16. import org.apache.struts2.ServletActionContext;  
17.   
18.   
19. import com.opensymphony.xwork2.ActionContext;  
20.   
21.   
22. import cn.edu.hpu.tax.core.action.BaseAction;  
23. import cn.edu.hpu.tax.role.service.RoleService;  
24. import cn.edu.hpu.tax.user.entity.User;  
25. import cn.edu.hpu.tax.user.service.UserService;  
26.   
27.   
28. public class UserAction extends BaseAction{  
29.       
30.     //前面的所有参数省略  
31.     //用户角色选择的id们  
32.     private String[] userRoleIds;  
33.     //get和set省略  
34.       
35.     //保存新增  
36.     public String add(){  
37.         try {  
38.             if(user!=null){  
39.                 //处理头像  
40.                 if(headImg!=null){  
41.                     //1、保存头像到upload/user  
42.                     //获取保存路径的绝对地址  
43.                     String filePath=ServletActionContext.getServletContext().getRealPath("upload/user");  
44.                     //生成带格式的随机文件名称  
45.                     String fileName=UUID.randomUUID().toString()+headImgFileName.substring(headImgFileName.lastIndexOf("."));  
46.                     //复制文件  
47.                     FileUtils.copyFile(headImg, new File(filePath,fileName));  
48.                       
49.                     //2、设置用户头像路径  
50.                     user.setHeadImg("user/"+fileName);  
51.                 }  
52.                   
53.                 //saveUserAndRole方法用来同时保存用户和用户的角色  
54.                 userService.saveUserAndRole(user,userRoleIds);  
55.                   
56.             }  
57.         } catch (IOException e) {  
58.             // TODO Auto-generated catch block  
59.             e.printStackTrace();  
60.         }  
61.         return "list";  
62.     }  
63.     //保存编辑  
64.     public String edit(){  
65.         try {  
66.             if(user!=null){  
67.                 //处理头像  
68.                 if(headImg!=null){  
69.                       
70.                     //1、保存头像到upload/user  
71.                     //获取保存路径的绝对地址  
72.                     String filePath=ServletActionContext.getServletContext().getRealPath("upload/user");  
73.                     //生成带格式的随机文件名称  
74.                     String fileName=UUID.randomUUID().toString()+headImgFileName.substring(headImgFileName.lastIndexOf("."));  
75.                     //复制文件  
76.                     FileUtils.copyFile(headImg, new File(filePath,fileName));  
77.                       
78.                     //如果旧头像存在，把旧头像删除  
79.                     if(user.getHeadImg()!=null){  
80.                         String oldfilename=filePath+"\\"+user.getHeadImg().substring(5);  
81.                         File file=new File(oldfilename);  
82.                         file.delete();  
83.                     }  
84.                       
85.                     /**/  
86.                       
87.                     //2、设置用户头像路径  
88.                     user.setHeadImg("user/"+fileName);  
89.                 }  
90.                   
91.                 userService.updateUserAndRole(user,userRoleIds);  
92.             }  
93.         } catch (IOException e) {  
94.             // TODO Auto-generated catch block  
95.             e.printStackTrace();  
96.         }  
97.         return "list";  
98.     }  
99.     //其他方法没有改动，省略  
100. }  

我们把userRoleIds引进来，用于获取用户的角色选择，然后我们把原来的save(User user)和update(User user)方法全部改为
保存用户和角色信息saveUserAndRole(User user, String[] userRoleIds)和
修改用户和角色信息updateUserAndRole(User user, String[] userRoleIds);

我们在UserService接口中定义这些方法，然后在UserServiceImpl中实现这两个方法:

[java]  view plain  copy

1. @Override  
2. public void saveUserAndRole(User user, String[] userRoleIds) {  
3.     //1.保存用户  
4.     save(user);  
5.     //2.保存用户对于的角色  
6.     if(userRoleIds!=null){  
7.         for (String roleId:userRoleIds) {  
8.             userDao.saveUserRole(new UserRole(new UserRoleId(user.getId(),new Role(roleId))));  
9.         }  
10.     }  
11. }  
12.   
13. @Override  
14. public void updateUserAndRole(User user, String[] userRoleIds) {  
15.     //1.根据用户删除该用户的所有角色  
16.     userDao.deleteUserRoleByUserId(user.getId());  
17.     //2.更新用户  
18.     update(user);  
19.     //3.保存用户对应的角色  
20.     if(userRoleIds!=null){  
21.         for (String roleId:userRoleIds) {  
22.             userDao.saveUserRole(new UserRole(new UserRoleId(user.getId(),new Role(roleId))));  
23.         }  
24.     }  
25. }  

其中saveUserRole和deleteUserRoleByUserId没有实现，我们在userDao接口中添加它们，在userDaoImpl中实现它们:

[java]  view plain  copy

1. @Override  
2. public void saveUserRole(UserRole userRole) {  
3.     getHibernateTemplate().save(userRole);  
4. }  
5.   
6.   
7. @Override  
8. public void deleteUserRoleByUserId(String id) {  
9.      Query query=getSession().createQuery("DELETE FROM UserRole WHERE id.userId=?");  
10.      query.setParameter(0, id);  
11.      query.executeUpdate();  
12. }  

我们做到了新增和编辑的时候保存给注册用户时选择的相应角色。

我们来实验一下:
先来添加一个用户，给他分配一个角色:


保存之后到数据库中查看，发现我们为用户设置了相应的角色:
用户权限id中间表:

妮妮的id

权限id:


然后是编辑界面:
我们的编辑界面还没有设置数据回显，我们先编辑jsp界面，将我们的数据设置在编辑页面上:

[html]  view plain  copy

1. <tr>  
2.     <td class="tdBg" width="200px">角色：</td>  
3.     <td>  
4.         <s:checkboxlist list="#roleList" name="userRoleIds" listKey="roleId" listValue="name">  
5.         </s:checkboxlist>  
6.     </td>  
7. </tr>  

然后修改UserAction中editUI()方法，使其也加载用户的角色:

[java]  view plain  copy

1. //跳转到编辑界面  
2. public String editUI(){  
3.     //加载角色列表  
4.     ActionContext.getContext().getContextMap().put("roleList", roleService.findObjects());  
5.     if(user!=null && user.getId()!=null){  
6.         user=userService.findObjectById(user.getId());  
7.         //处理角色回显  
8.         String[] ids=userService.getRoleIdByUserId(user.getId());  
9.         if(ids!=null&&ids.length>0){  
10.             userRoleIds=ids;  
11.         }  
12.     }  
13.     return "editUI";  
14. }  

上面新添加了getRoleIdByUserId方法，我们在UserService中添加getRoleIdByUserId方法，然后在其实现类UserServiceImpl中实现这个方法:

[java]  view plain  copy

1. @Override  
2. public String[] getRoleIdByUserId(String id) {  
3.     return userDao.getRoleIdByUserId(id);  
4. }  

上面Dao新添加了getRoleIdByUserId方法，我们在UserDao中添加getRoleIdByUserId方法，然后在其实现类UserDaoImpl中实现这个方法:

[java]  view plain  copy

1. @Override  
2. public String[] getRoleIdByUserId(String id) {  
3.     Query query=getSession().createQuery("FROM UserRole WHERE id.userId=?");  
4.     query.setParameter(0, id);  
5.     List<UserRole> list=query.list();  
6.     String[] ids=null;  
7.     if(list!=null&&list.size()>0){  
8.         ids=new String[list.size()];  
9.         for (int i = 0; i < list.size(); i++) {  
10.             ids[i]=list.get(i).getId().getRole().getRoleId();  
11.         }  
12.     }  
13.     return ids;  
14. }  

测试:
点击编辑界面，将管理员的权限也勾选上:


保存之后可以看到妮妮这个用户又多了一个角色: