資訊專欄INFORMATION COLUMN
摘要：現在我們來做一個權限管理系統，體驗一下多表的業務邏輯，順便鞏固一下過濾器的知識。目的現在我有一個管理商品訂單的頁面。這里我們是這樣子做的作為，權限作為，構成一個集合。
前言
前面我們做的小項目都是一個表的，業務代碼也相對簡單。現在我們來做一個權限管理系統，體驗一下多表的業務邏輯，順便鞏固一下過濾器的知識。！目的
現在我有一個管理商品、訂單的頁面。當用戶點擊某個超鏈接時，過濾器會檢測該用戶是否有權限！
需求分析按照面向對象的思想，我們至少應該有權限（Privilege）和用戶（User）實體。兩個實體足夠了嗎？細想一下，如果我們有多個用戶，多個用戶也有多個權限，當要為用戶授權的時候，這樣子就會非常麻煩！所以我們應該引入角色（Role）這個實體！
引入角色（Role）這個實體方便在哪呢？？把權限賦給角色（比如：把刪除、修改的權限給管理員這個角色），管理員這個角色再賦給用戶，那么該用戶就有了修改、刪除的權限了！
權限和角色是多對多的關系，角色和用戶也是多對多的關系！
開發實體 用戶實體
public class User {
private String id;
private String username;
private String password;
//記住角色
private Set roles = new HashSet<>();
//各種getter和setter.....
}
角色實體
public class Role {
private String id;
private String name;
private String description;
//記住所有的用戶
private Set users = new HashSet<>();
//記住所有的權限
private Set privileges = new HashSet<>();
//各種getter和setter.....
}
權限實體
public class Privilege {
private String id;
private String name;
private String description;
//記住所有的角色
private Set roles = new HashSet<>();
//各種getter和setter.....
}
改良
用戶和角色、角色和權限都是多對多的關系，這是毋庸置疑的！我們也按照面向對象的方法來設計，用集合來記住另一方的數據！
但是呢，我們想想：
在權限的Dao中，在查看權限的時候，有必要列出相對應的角色嗎？？
在角色的Dao中，在查看角色的時候，有必要列出相對應的用戶嗎？？
答案是沒有的，一般我們都不會顯示出來。所以，權限的實體沒必要使用Set集合來記住角色，角色實體沒必要使用Set集合來記住用戶！
改良后的權限實體
public class Privilege {
private String id;
private String name;
private String description;
//各種setter和getter方法
}
改良后的角色實體
public class Role {
private String id;
private String name;
private String description;
//記住所有的權限
private Set privileges = new HashSet<>();
//各種setter和getter方法
}
在數據庫中建表
user表
CREATE TABLE user (
id VARCHAR(20) PRIMARY KEY,
username VARCHAR(20) NOT NULL,
password VARCHAR(20) NOT NULL
);
role表
CREATE TABLE role (
id VARCHAR(20) PRIMARY KEY,
name VARCHAR(20) NOT NULL,
description VARCHAR(255)
);
privilege表
CREATE TABLE privilege (
id VARCHAR(20) PRIMARY KEY,
name VARCHAR(20) NOT NULL,
description VARCHAR(255)
);
user和role的關系表
CREATE TABLE user_role (
user_id VARCHAR(20),
role_id VARCHAR(20),
PRIMARY KEY (user_id, role_id),
CONSTRAINT user_id_FK FOREIGN KEY (user_id) REFERENCES user (id),
CONSTRAINT role_id_FK FOREIGN KEY (role_id) REFERENCES role (id)
);
role和privilege的關系表
CREATE TABLE role_privilege (
role_id VARCHAR(20),
privilege_id VARCHAR(20),
PRIMARY KEY (role_id, privilege_id),
CONSTRAINT role_id_FK1 FOREIGN KEY (role_id) REFERENCES role (id),
CONSTRAINT privilege_id_FK FOREIGN KEY (privilege_id) REFERENCES privilege (id)
);
注意：user和role的關系表、role和privilege的關系都有role_id作為外鍵，外鍵的名稱是不能一樣的！
開發DAO PrivilegeDao/**
* 權限的管理應該有以下的功能：
* 1.添加權限
* 2.查看所有權限
* 3.查找某個權限
*
* */
public class PrivilegeDao {
/*添加權限*/
public void addPrivilege(Privilege privilege) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "INSERT INTO privilege (id, name, description) VALUE (?, ?, ?)";
queryRunner.update(sql, new Object[]{privilege.getId(), privilege.getName(), privilege.getDescription()});
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("添加權限失敗了！");
}
}
/*查找權限*/
public Privilege findPrivilege(String id) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "SELECT *FROM privilege WHERE id = ?";
Privilege privilege = (Privilege) queryRunner.query(sql, new BeanHandler(Privilege.class), new Object[]{id});
return privilege;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("查找權限失敗了！");
}
}
/*獲取所有的權限*/
public List getAllPrivileges() {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "SELECT * FROM privilege ";
List privileges = (List) queryRunner.query(sql, new BeanListHandler(Privilege.class));
return privileges;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("查找權限失敗了！");
}
}
}
測試PrivilegeDao的功能
為了測試方便，添加有參構造函數到Privilege對象中
public class PrivilegeDaoTest {
PrivilegeDao privilegeDao = new PrivilegeDao();
@Test
public void add() {
Privilege privilege = new Privilege("2", "修改", "修改功能");
privilegeDao.addPrivilege(privilege);
}
@Test
public void getAll() {
List list = privilegeDao.getAllPrivileges();
for (Privilege privilege : list) {
System.out.println(privilege.getId());
}
}
@Test
public void find() {
String id = "2";
Privilege privilege = privilegeDao.findPrivilege(id);
System.out.println(privilege.getName());
}
}
UserDao
public class UserDao {
public void addUser(User user) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "INSERT INTO user (id,username,password) VALUES(?,?,?)";
queryRunner.update(sql, new Object[]{user.getId(), user.getUsername(), user.getPassword()});
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("添加權限失敗了！");
}
}
public User find(String id) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "SELECT * FROM user WHERE id=?";
User user = (User) queryRunner.query(sql, new BeanHandler(User.class), new Object[]{id});
return user;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("添加權限失敗了！");
}
}
public List getAll() {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "SELECT * FORM user";
List users = (List) queryRunner.query(sql, new BeanListHandler(User.class));
return users;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("添加權限失敗了！");
}
}
}
測試UserDao
public class UserDaoTest {
UserDao userDao = new UserDao();
@Test
public void add() {
User user = new User();
user.setId("2");
user.setUsername("qqq");
user.setPassword("123");
userDao.addUser(user);
}
@Test
public void find() {
String id = "1";
User user = userDao.find(id);
System.out.println(user.getUsername());
}
@Test
public void findALL() {
List userList = userDao.getAll();
for (User user : userList) {
System.out.println(user.getUsername());
}
}
}
RoleDao
public void add(Role role){
try{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "insert into role(id,name,description) values(?,?,?)";
Object params[] = {role.getId(),role.getName(),role.getDescription()};
runner.update(sql, params);
}catch (Exception e) {
throw new RuntimeException(e);
}
}
public Role find(String id){
try{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from role where id=?";
return (Role) runner.query(sql, id, new BeanHandler(Role.class));
}catch (Exception e) {
throw new RuntimeException(e);
}
}
//得到所有角色
public List getAll(){
try{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "select * from role";
return (List) runner.query(sql, new BeanListHandler(Role.class));
}catch (Exception e) {
throw new RuntimeException(e);
}
}
測試RoleDao
RoleDao roleDao = new RoleDao();
@Test
public void add() {
Role role = new Role();
role.setId("1");
role.setName("manager");
role.setDescription("this is a manager");
roleDao.add(role);
}
@Test
public void find( ) {
String id = "1";
Role role = roleDao.find(id);
System.out.println(role.getName());
}
@Test
public void getAdd() {
List roleList = roleDao.getAll();
for (Role role : roleList) {
System.out.println(role.getName());
}
}
補充
上面的僅僅是單表的Dao功能，User和Role表是多對多的關系，Role和Privilege表也是多對多的關系。
前面已經分析了
在User對象中，需要一個Set集合來記住Role的關系。【顯示用戶的時候，應該把所有角色顯示出來】
在Role對象中，需要一個Set集合來記住Privilege的關系【顯示角色的時候，應該把所有權限顯示很出來】。
所以應該在UserDao有獲取某用戶所有的角色的方法：
/*得到用戶的所有角色*/
public List getRoles(String user_id) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
//根據用戶id查詢所有角色，重點就在角色上，所以要有role表。然后查詢user_role表，就可以鎖定用戶id對應的角色了！
String sql = "SELECT r.* FROM role r, user_role ur WHERE ur.user_id = ? AND r.id = ur.role_id ";
List roles = (List) queryRunner.query(sql, new BeanListHandler(Role.class), new Object[]{user_id});
return roles;
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("得到用戶所有的角色失敗了！");
}
}
在RoleDao有獲取所有權限的方法：
//得到某角色的所有權限【權限表、權限和角色關系表】
public List getPrivileges(String role_id) {
try{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
String sql = "SELECT p.* FROM privilege p, role_privilege rp WHERE rp.role_id = ? AND p.id = rp.role_id";
List privileges = (List) runner.query(sql, new BeanListHandler(Privilege.class), new Object[]{role_id});
return privileges;
}catch (Exception e) {
throw new RuntimeException(e);
}
}
我們既然能獲取得到用戶所有的角色了，獲取得到角色所有的權限了。那自然我們就應該有修改用戶的角色功能，修改角色的權限的功能啦！
我們先來分析一下它怎么寫：要修改用戶所擁有的角色，應該知道修改用戶是哪一個，所以需要用戶的id或者User對象！修改的角色是什么,需要Role對象或者裝載Role對象的集合！
在UserDao有修改某用戶角色的方法，我們是想把所有的角色都刪除了，再添加新的角色
//更新用戶的角色
public void updateRole(User user, List roles) {
try {
QueryRunner queryRunner = new QueryRunner(JdbcUtils.getDataSource());
//先把用戶原來的所有角色刪掉了
String delete = "DELETE FROM user_role WHERE user_id = ?";
queryRunner.update(delete, user.getId());
String add = "INSERT INTO user_role (user_id,role_id) VALUES(?,?)";
for (Role role : roles) {
queryRunner.update(add, new Object[]{user.getId(), role.getId()});
}
} catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("添加權限失敗了！");
}
}
在RoleDao有修改角色權限的方法，和上面是類似的。
//為某個角色授權
public void addPrivilege2Role(Role role, List privileges) {
try{
QueryRunner runner = new QueryRunner(JdbcUtils.getDataSource());
//先刪除該角色的所有權限
String delete = "DELETE FROM role_privilege WHERE role_id = ?";
runner.update(delete, new Object[]{role.getId()});
//賦予角色新的權限
String sql = "INSERT INTO role_privilege (role_id, privilege_id) VALUES (?, ?)";
for (Privilege privilege : privileges) {
runner.update(sql, new Object[]{role.getId(), privilege.getId()});
}
}catch (Exception e) {
throw new RuntimeException(e);
}
}
更新
剛才又思考了一下：
其實我們并不需要在User類用使用集合來維護Role，在Role中使用集合來維護Privilege。在原本的做法我們已經看到了，我們完全是不需要這兩個變量也能完成效果的。
那么，現在問題就來了。什么時候我們才需要在實體中使用變量來維護多的一方的關系呢？？？我覺得是這樣的：當我們在查詢一方數據的時候，另一方的數據也同時需要展示。那么此時我們就應該使用集合來維護多的一方數據了。
基于上面一個例子，就比如：訂單與訂單項。當我們查看訂單的時候，同時一定會把所有的訂單項都列舉出來。
再比如：當我們查看購物車的時候，就需要把所有的購物項都列舉出來。
而我們使用展示用戶的時候，并不需要第一時間就把角色列舉出來，而是通過超鏈接來查看用戶下的角色，基于這種情況，我覺得我們是不用使用集合變量來維護多的一方的數據的。
這就跟Hibernate的懶加載差不多。用到關聯關系的數據的時候才加載，沒有用到的時候就先不查詢數據庫。
ps:我不知道在這我理解得對不對，如果有錯的地方希望能指出!
開發BusinessService UserService
public class UserService {
UserDao userDao = new UserDao();
//添加用戶
public void addUser(User user) {
userDao.addUser(user);
}
//根據id查找用戶
public User findUser(String id) {
return userDao.find(id);
}
//得到所有的用戶
public List getAllUser() {
return userDao.getAll();
}
//獲取用戶所有的角色
public List getUserRole(String user_id) {
return userDao.getRoles(user_id);
}
//修改用戶的角色
public void updateUserRole(User user, List roles) {
userDao.updateRole(user, roles);
}
}
RoleService
public class RoleService {
RoleDao roleDao = new RoleDao();
//添加角色
public void addRole(Role role) {
roleDao.add(role);
}
//根據id查找角色
public Role findRole(String id) {
return roleDao.find(id);
}
//獲取所有的角色
public List getAllRole() {
return roleDao.getAll();
}
//獲取角色所有的權限
public List getRolePrivilege(String role_id) {
return roleDao.getPrivileges(role_id);
}
//修改角色的權限
public void updateRolePrivilege(Role role, List privileges) {
roleDao.addPrivilege2Role(role, privileges);
}
}
PrivilegeService
public class PrivilegeService {
PrivilegeDao privilegeDao = new PrivilegeDao();
//添加權限
public void addPrivilege(Privilege privilege) {
privilegeDao.addPrivilege(privilege);
}
//根據id獲得權限
public Privilege findPrivilege(String id) {
return privilegeDao.findPrivilege(id);
}
//獲取所有的權限
public List getAllPrivileges() {
return privilegeDao.getAllPrivileges();
}
}
開發Web
用戶模塊
添加用戶
提供頁面界面的Servlet
//直接跳轉到顯示添加用戶的界面
request.getRequestDispatcher("/WEB-INF/jsp/addUser.jsp").forward(request, response);
顯示頁面的JSP
處理表單數據的Servlet
//得到客戶端傳遞進來的參數
String username = request.getParameter("username");
String password = request.getParameter("password");
User user = new User();
user.setId(WebUtils.makeId());
user.setUsername(username);
user.setPassword(password);
try {
UserService userService = new UserService();
userService.addUser(user);
request.setAttribute("message","添加用戶成功！");
} catch (Exception e) {
request.setAttribute("message", "添加用戶失敗！");
throw new RuntimeException("在Controller添加客戶失敗");
}
request.getRequestDispatcher("/message.jsp").forward(request,response);
}
效果：
顯示用戶提供頁面界面的Servlet
UserService userService = new UserService();
List list = userService.getAllUser();
request.setAttribute("list", list);
//跳轉到顯示頁面
request.getRequestDispatcher("/WEB-INF/jsp/LookUser.jsp").forward(request, response);
顯示頁面JSP
