枚举+链对缓存实现以读取为主的请求接口

灰太狼 2024-04-17 06:15 37阅读 0赞

## 一、需求背景 ##

需要给一份问卷进行授权，授权的角色固定为4类，分别是： 农户、企业、金融机构、政府用户，这4类角色定义在字典里面，并且很少改动。这4类角色下面，可能有多个角色，这些角色通过字典的`key`关联到上述4个类型中的一个;  
在新增、编辑问卷的时候，需要把这4类所有的角色都展示出来，供管理员选择。

## 二、需求分析 ##

由于涉及到的数据很少改动，且主要以查询为主，于是第一想法就是通过 `枚举+链对`实现,具体实现如下:

## 三、实现过程 ##

### 1. 枚举类 ###

import lombok.Getter;
    import lombok.Setter;
    
    import java.util.*;
    import java.util.concurrent.ConcurrentHashMap;
    import java.util.function.Consumer;
    import java.util.stream.Stream;
    
    import static com.xxx.xxx.utils.StreamUtil.forEachIfPresent;
    
    /**
     * Author:   wxz
     * Date:     2023.11.29 10:35
     * Description: 问卷调查授权枚举
     */
    public enum PaperAuthorRoleEnum {
        
        ANONYMITY("un-limit", "不限", Collections.singletonList("")),
        AGRICULTURAL("member", "农户",Collections.singletonList("member")),
        ENTERPRISE("enterprises", "企业", Collections.singletonList("agricultural-enterprises")),
        FINANCIAL_INSTITUTION("finance", "金融机构",FinanceRoleKeys()),
        GOVERNMENT_USERS("government", "政府用户", GovernmentRoleKeys()),
        ;
        /**
         * 角色类型
         */
        @Getter
        private final String type;
        /**
         * 角色类型名称
         */
        @Getter
        private final String typeName;
    
        /**
         * 角色id集合
         */
        @Getter
        private final List<String> roleKeys;
    
        /**
         * 角色列表
         */
        @Getter
        private final List<PaperRole> paperRoleList;
        /**
         * 角色缓存数据
         */
        private static Map<String, SysRole> roleCache = new ConcurrentHashMap<>();
    
    
        PaperAuthorRoleEnum(String type, String typeName, List<String> roleKeys) {
        
            this.type = type;
            this.typeName = typeName;
            this.roleKeys = roleKeys;
            this.paperRoleList = getRolesFromCache(roleKeys);
        }
    
        /**
         * 根据角色类型查找枚举
         * @param type 角色类型
         * @return 类型枚举
         */
        public static PaperAuthorRoleEnum of(String type) {
        
            if (type == null) {
        
                return null;
            }
            PaperAuthorRoleEnum[] values = PaperAuthorRoleEnum.values();
            for (PaperAuthorRoleEnum a : values) {
        
                if (a.type.equals(type)) {
        
                    return a;
                }
            }
            return null;
        }
    
        /**
         * 金融机构角色keys
         */
        private static List<String> FinanceRoleKeys() {
        
            List<String> list = new ArrayList<>();
            //银行机构有5个等级
            for (int i = 1; i < 5; i++) {
        
                list.add("bank_level_" + i);
            }
            return list;
        }
    
        /**
         * 政府角色keys
         */
        private static List<String> GovernmentRoleKeys() {
        
            return new ArrayList<>(Arrays.asList("collector","government","government-role"));
        }
    
        /**
         * 获取所有枚举的keys
         * @return
         */
        private List<String> getAllRolKeys() {
        
            List<String> roleKeys = new ArrayList<>();
            roleKeys.addAll(Collections.singletonList("member"));
            roleKeys.addAll(Collections.singletonList("agricultural-enterprises"));
            roleKeys.addAll(FinanceRoleKeys());
            roleKeys.addAll(GovernmentRoleKeys());
            return roleKeys;
        }
    
        /**
         * 从缓存中获取角色列表
         * @param roleKeys
         * @return
         */
        private  List<PaperRole> getRolesFromCache(List<String> roleKeys) {
        
            List<PaperRole> paperRoles = new ArrayList<>();
            Set<String> notExitKeys = new HashSet<>();
            boolean sign = (roleCache == null);
            //如果已经存在缓存里面,则优先从缓存里面获取
            if (sign) {
        
                notExitKeys.addAll(getAllRolKeys());
                roleCache = new ConcurrentHashMap<>();
            } else {
        
                roleKeys.forEach(key -> {
        
                    if (!roleCache.containsKey(key)) {
        
                        notExitKeys.add(key);
                    } else {
        
                        PaperRole paperRole =
                                new PaperRole().setRoleId(roleCache.get(key).getRoleId()).setRoleName(roleCache.get(key).getRoleName());
                        paperRoles.add(paperRole);
                    }
                });
            }
            //不存在于缓存的数据,重新从数据库里面查询出来,放在缓存里面
            if (notExitKeys.size() > 0) {
        
                Optional<List<SysRole>> sysRoles =
                        Optional.ofNullable(SpringUtils.getBean(SysRoleMapper.class).selectListByRoleKeys(new ArrayList<>(notExitKeys)));
               // forEachIfPresent()方法参考:  https://blog.csdn.net/qq_37844454/article/details/134964619
                forEachIfPresent(sysRoles,item->{
        
                    roleCache.put(item.getRoleKey(), item);
                    PaperRole paperRole = new PaperRole().setRoleId(item.getRoleId()).setRoleName(item.getRoleName());
                    paperRoles.add(paperRole);
                });
            }
            return paperRoles;
        }
        /**
         * 获取所有的枚举
         */
        public static PaperAuthorRoleEnum[] getValues() {
        
            return new PaperAuthorRoleEnum[]{
        AGRICULTURAL, ENTERPRISE, FINANCIAL_INSTITUTION, GOVERNMENT_USERS};
        }
    }

### 2. 控制器调用 ###

//使用线程安装的链对做缓存,避免读多写少的数据频繁请求数据库
        private static ConcurrentLinkedQueue<PaperAuthorTypeDTO> dtoQueue = new ConcurrentLinkedQueue<>();
        
        @GetMapping(value = "/getRoleList")
        public AjaxResult getRoleList() {
        
            if (CollectionUtils.isEmpty(dtoQueue)) {
        
                dtoQueue = new ConcurrentLinkedQueue<>();
                Arrays.stream(PaperAuthorRoleEnum.getValues()).forEach(anEnum->{
        
                    dtoQueue.offer(new PaperAuthorTypeDTO().setRoleId(anEnum.getType()).setRoleName(anEnum.getTypeName()));
                });
            }
            return AjaxResult.success(dtoQueue);
        }