在進入正題之前，先來聊一個耳熟能詳，家喻戶曉的東西，這裡稱之為東西，因為不好界定他到底是什麼，往大了說，他可以單獨拎出來作為一個微服務系統，他包括所有權限相關，用戶鑑權服務，比如說一般電商系統中，或者會員相關的系統中，權限很錯綜複雜，但是往小了說他缺失智能作為一個模塊存在。僅僅只包含簡單的如下關係。

用戶表

<code>DROP TABLE IF EXISTS `cpt_system_user` ;
CREATE TABLE IF NOT EXISTS `cpt_system_user` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主鍵',
  `uk` varchar(20) NOT NULL DEFAULT '' COMMENT '用戶uk',
  `name` varchar(100) NOT NULL DEFAULT '' COMMENT '用戶中文名',
  `create_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '創建時間',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新時間',
  `last_login_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '最近一次登錄時間',
  PRIMARY KEY (`id`),
  KEY `uk_index` (`uk`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用戶表';/<code>

角色表

<code>-- 角色表
DROP TABLE IF EXISTS `cpt_system_role` ;
CREATE TABLE IF NOT EXISTS `cpt_system_role` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主鍵',
  `name` varchar(255) NOT NULL DEFAULT '' COMMENT '角色名',
  `create_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '創建時間',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新時間',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='角色';/<code>

分組表

<code>-- 用戶組
DROP TABLE IF EXISTS `cpt_system_group` ;
CREATE TABLE `cpt_system_group` (
  `id` bigint(20) unsigned NOT NULL AUTO_INCREMENT COMMENT '主鍵',
  `name` varchar(200) NOT NULL COMMENT '組名',
  `create_time` timestamp NOT NULL DEFAULT '0000-00-00 00:00:00' COMMENT '創建時間',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新時間',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;/<code>

用戶關聯角色表

<code>-- 用戶和角色綁定關係表 

DROP TABLE IF EXISTS `cpt_system_user_role`;
CREATE TABLE IF NOT EXISTS `cpt_system_user_role` (
  `uk` varchar(20) NOT NULL COMMENT '用戶ID',
  `role_id` bigint(20) NOT NULL COMMENT '角色ID',
  `active`  int(1) NOT NULL DEFAULT 1 COMMENT '是否有效 0，無效， 1： 有效,  用來作為軟刪除的狀態位',
  PRIMARY KEY (`uk`,`role_id`, `active`),
  KEY `index_uk` (`uk`),
  KEY `index_role_id` (`role_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用戶和角色綁定關係';/<code>

用戶關聯分組表

<code>-- 用戶和用戶組綁定關係
DROP TABLE IF EXISTS `cpt_system_user_group` ;
CREATE TABLE IF NOT EXISTS `cpt_system_user_group` (
  `uk` varchar(20) NOT NULL COMMENT '用戶ID',
  `group_id` bigint(20) NOT NULL COMMENT '用戶組ID',
  `active`  int(1) NOT NULL DEFAULT 1 COMMENT '是否有效 0，無效， 1： 有效,  用來作為軟刪除的狀態位',
  PRIMARY KEY (`uk`, `group_id`, `active`),
  KEY `index_uk` (`uk`),
  KEY `index_group_id` (`group_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用戶和用戶組綁定關係';/<code>

那麼最簡單粗暴的 方案就是這樣。

持久層代碼如下

<code>    // 查詢出用於已經綁定的角色，無論狀態位是0還是1
    @Select("select * from cpt_system_user_role where uk = #{uk};")
    List<userrole> fetchRoleNoMatter(@Param("uk") String uk);
 
    // 查詢出用於已經綁定的分組，無論狀態位是0還是1
    @Select("select * from cpt_system_user_group where uk = #{uk};") 

    List<usergroup> fetchGroupNoMatter(@Param("uk") String uk);    
 
    // 因為用戶綁定分組和綁定角色相差甚微 使用SQL注入來合併為一個方法，以下兩個方法類似
    //設置有效狀態位無效
    @Update("")
    int disabledUserGroupOrRole(@Param("uk") String uk, @Param("list") List<long> list, @Param("table") String table, @Param("joinKey") String joinKey);
 
    // 設置無效狀態為有效
    @Update("")
    int enabledUserGroupOrRole(@Param("uk") String uk, @Param("list") List<long> list, @Param("table") String table, @Param("joinKey") String joinKey);
 
    // 新增有效關聯數據
    @Update("")
    int insertUserGroupOrRole(@Param("uk") String uk, @Param("list") List<long> list, @Param("table") String table, @Param("joinKey") String joinKey);/<long>/<long>/<long>/<usergroup>/<userrole>/<code>

說完持久層，service層代碼如下

<code>@Service
public class UserServiceImpl implements UserService {
 
    @Autowired
    private UserDao userDao;
 
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @Override
    public void grantRole(String uk, List<long> list) {
        List<long> exists = userDao.fetchRoleNoMatter(uk).stream().map(UserRole::getRoleId).collect(Collectors.toList());
        baseGrant(uk, list, exists, "cpt_system_user_role", "role_id");
    }
 
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @Override
    public void grantGroup(String uk, List<long> list) {
        List<long> exists = userDao.fetchGroupNoMatter(uk).stream().map(UserGroup::getGroupId).collect(Collectors.toList());
        baseGrant(uk, list, exists, "cpt_system_user_group", "group_id");
    }
 
 
    /**
     * 通用的授權，授分組方法
     * @param uk
     * @param list 

     * @param exists
     * @param table
     * @param joinKey
     */
    public void baseGrant(String uk, List<long> list, List<long> exists, String table, String joinKey) {
        if(list == null || list.size() == 0) {
            // 查詢出已經存在的
            if(exists.size() != 0) {
                //全部刪除並返回
                userDao.disabledUserGroupOrRole(uk, list, table, joinKey);
                return;
            }
            // 直接返回，不做任何和處理
            return;
        }
        //1、查詢已經存在的
        if(exists.size() == 0) {
            //如果不存在，那麼全部新增之後返回
            userDao.insertUserGroupOrRole(uk, list, table, joinKey);
            return;
        }
        //2、差集 求出需要新增的   新增設置為  1
        List<long> add = list.stream().filter(t -> !exists.contains(t)).collect(Collectors.toList());
        userDao.insertUserGroupOrRole(uk, add, table, joinKey);
 
        //3、差集  求出需要剔除的  設置為 0
        List<long> del = exists.stream().filter(t -> !list.contains(t)).collect(Collectors.toList());
        userDao.disabledUserGroupOrRole(uk, del, table, joinKey);
 
        //4、求出交集，並全部設置為active為 1
        List<long> join = list.stream().filter(exists::contains).collect(Collectors.toList());
        userDao.enabledUserGroupOrRole(uk, join , table, joinKey);
    }
}/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<code>

其實如果這麼寫，如果已經穩定沒有其他需求了，其實就可以了，但是，如果以後再來一個用戶綁定地區，或者地區綁定用戶，用戶綁定身份啥的，那麼，就需要再寫一個相同的邏輯和業務，我們現在要做的就是把這個東西抽象出來，能不管你什麼綁定什麼，比如再反著來一個分組綁定用戶

dao層

<code>    @Select("select b.uk,b.name,b.create_time,b.update_time,b.last_login_time from cpt_system_user_group a join cpt_system_user b on a.uk = b.uk where a.group_id = ${groupId}")
    List<user> fetchUserByGroupIdNoMatter(@Param("groupId") Long groupId);
 
    //設置有效狀態位無效
    @Update("")
    int disabledGroupUser(@Param("groupId") Long groupId, @Param("list") List<string> list);
 
    // 設置無效狀態為有效
    @Update("")
    int enabledGroupUser(@Param("groupId") Long groupId, @Param("list") List<string> list);
 
    // 新增有效關聯數據
    @Update("")
    int insertGroupUser(@Param("groupId") Long groupId, @Param("list") List<string> list);/<string>/<string>/<string>/<user>/<code>

很明顯，不能使用剛才哪個baseGrant方法了，因為參數類型變化了。

用戶綁定分組 邏輯： 是一個 String 類型的 uk 對應多個 Long類型的分組ID

分組綁定用戶 邏輯： 是一個 Long 類型的 分組ID 對應多個 String 類型的uk

所以如果能抽取一個更加通用的模板，參數可以支持任意類型的映射關係就可以減少大量重複的代碼。

抽取步驟

1、選擇適合的設計模式：因為模板設計模式相對簡單，並且能夠解決當前問題，所以選擇模板方法設計模式

2、既然選擇模板方法設計模式，那麼就要把baseGrant這個方法中的與具體業務相關的摘除掉。通過參數傳遞進來。

3、實現。

定義Selector接口，裡面包含業務中所使用到的三個業務方法

<code>/**
 * 通用用戶授權，用戶授組，組內用戶組件 選擇器
 */
public interface Selector {
 
    // 將 active = 0 設置為 active = 1
    void enable(List join);
 
    // 將 active = 1 設置為 active = 0
    void disable(List del);
 
    // 新增 active = 1
    void insert(List add);
 
}/<code>

進行模板的封裝

<code>@Component
public class BasicTemplate {
 
    /**
     * 通用的授權，授分組方法
     * @param list      提交的 數組
     * @param selector  查詢已經存在的方法 ,包含 禁用方法，啟用方法，新增方法 

     */
    public  void baseGrant(List list, List exists, Selector selector) {
        // 一.如果提交的list為空表示清空
        if(list == null || list.size() == 0) {
            //查詢出已經存在的，無論狀態位  是 0 還是 1 ，保證 每個綁定關係無論怎麼刪除新增 只有一條
            if(exists.size() != 0) {
                //全部刪除並返回
                selector.disable(exists);
                return;
            }
            // 直接返回，不做任務和處理
            return;
        }
        // 二.如果在新增前沒有存在過的數據，表示都是新增
        if(exists.size() == 0) {
            //如果不存在，那麼全部新增之後返回
            selector.insert(list);
            return;
        }
        // 三. 正常兩邊都有數據，有提交，並且之前也有數據存在
        //2、差集 求出需要新增的   新增設置為  1
        List add = list.stream().filter(t -> !exists.contains(t)).collect(Collectors.toList());
        selector.insert(add);
 
        //3、差集  求出需要剔除的  設置為 0
        List del = exists.stream().filter(t -> !list.contains(t)).collect(Collectors.toList());
        selector.disable(del);
 
        //4、求出交集，並全部設置為active為 1 

        List join = list.stream().filter(exists::contains).collect(Collectors.toList());
        selector.enable(join);
    }
}/<code>

然後在service中只要關係持久層的方法實現就可以了。

UserService中

<code>    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @Override
    public void grantRole(String uk, List<long> list) {
        List<long> exists = userDao.fetchRoleNoMatter(uk).stream().map(UserRole::getRoleId).collect(Collectors.toList());
        basicTemplate.baseGrant(list, exists, new Selector<long>() {
            @Override
            public void enable(List<long> join) {
                userDao.enabledUserGroupOrRole(uk, join, "cpt_system_user_role", "role_id");
            }
 
            @Override
            public void disable(List<long> del) {
                userDao.disabledUserGroupOrRole(uk, del, "cpt_system_user_role", "role_id");
            }
 
            @Override
            public void insert(List<long> add) {
                userDao.insertUserGroupOrRole(uk, add, "cpt_system_user_role", "role_id");
            }
        });
    }
    
 
    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @Override
    public void grantGroup(String uk, List<long> list) {
        List<long> exists = userDao.fetchGroupNoMatter(uk).stream().map(UserGroup::getGroupId).collect(Collectors.toList());
        basicTemplate.baseGrant(list, exists, new Selector<long>() {
            @Override
            public void enable(List<long> join) {
                userDao.enabledUserGroupOrRole(uk, join, "cpt_system_user_group", "group_id"); 

            }
            @Override
            public void disable(List<long> del) {
                userDao.disabledUserGroupOrRole(uk, del, "cpt_system_user_group", "group_id");
            }
            @Override
            public void insert(List<long> add) {
                userDao.insertUserGroupOrRole(uk, add, "cpt_system_user_group", "group_id");
            }
        });
    }/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<long>/<code>

GroupService中

<code>    @Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
    @Override
    public void addUsersToGroup(Long groupId, List<string> list) {
        List<string> exists = groupDao.fetchUserByGroupIdNoMatter(groupId).stream().map(User::getUk).collect(Collectors.toList());
        basicTemplate.baseGrant(list, exists, new Selector<string>() {
            @Override
            public void enable(List<string> join) {
                groupDao.enabledGroupUser(groupId, join);
            }
            @Override
            public void disable(List<string> del) {
                groupDao.disabledGroupUser(groupId, del);
            }
            @Override
            public void insert(List<string> add) {
                groupDao.insertGroupUser(groupId, add);
            }
        });
    }/<string>/<string>/<string>/<string>/<string>/<string>/<code>

以上就是整個思考的心路歷程啦。

祝您學習愉快

閱讀更多 人鬼殊途菌 的文章

關鍵字: 設計模式 框架 模板