SpringCloud微服务实战——搭建企业级开发框架（五十）：系统通用数据字典注解的设计与实现-六虎

我正在参加「启航计划」

数据字典是体系中根本的必不可少的功用，在多种多样的体系中，数据字典表的规划都迥然不同。但是运用办法确是多种多样，规划好一套易用的数据字典功用模块，能够使开发事半功倍。

常用的数据字典运用办法：

直接在SQL语句中LEFT JOIN （当然是不引荐这样用的）
查询出原始数据，然后再依据原始数据需求的字典编码，批量查询字典表，并赋值到原始数据的字典值字段。
后台供给通用数据字典接口，前端依据需求统一查询数据字典数据并缓存在前台。当事务回来后台原始数据时，前台经过相似于Filter（VUE）功用，进行字典值对应。
自定义数据字典注解，当接口回来原始数据时，经过切面分析回来目标中的数据字典字段，并将数据字典赋值到数据字典值字段。
供给数据字典通用东西，手动处理单个或批量需求进行数据字典转化的数据。

咱们为了更好的满足多样的事务需求，那么咱们肯定是需求支撑多种多样的办法，来完成数据字典转化的功用，接下来，咱们以1注解+2东西+3前端转化的办法来支撑数据字典转化。三种办法相辅相成、能够独自运用，也能够结合起来运用。

可注解在Controller
可注解在Service
支撑的调集类型：List、Set、Queue ，引证类型：Array一维数组
独自的bean支撑递归赋值，不支撑杂乱数据递归
后台供给通用数据字典接口，前端页面供给通用转化办法。
只注解在一般字段上，不要注解到杂乱目标上

数据字典转化流程：

1、在Service或许Controller增加@DictAuto注解，用于切面判别此办法是需求进行数据字典转化的办法。

2、切面发现此办法是需求数据字典转化的办法之后，那么解析办法的回来参数，回来参数有多种数据类型，这儿只处理调集类型：List、Set、Queue ，引证类型：Array一维数组还有一般目标类型（自定义实体bean）。

3、不管是调集类型还是一般目标类型都需求进行遍历、递归等操作，由于List里面是一般目标，目标中也有可能是调集类型。（此处需求留意，请不要在目标中的字段嵌套自己，这要会形成死循环。当然，目标中能够嵌套自己的目标类型，能够引证非自己的目标实例，由于递归操作中，咱们会判别假如是null，那么终止递归）

4、对回来类型进行递归时，经过注解获取到数据字典类型（system、business等）、数据字典CODE（一级数据字典CODE，作为数据字典的分类），经过此条件去Redis数据库查询数据字典列表。将查询的数据字典列表存储在Map中。在循环遍历过程中，增加判别，假如Map中有了，那么不再查询Redis数据库，而是直接从Map中取。

5、在遍历递归目标的同时，依据数据字典注解，获取本目标中用于映射数据字典的字段值作为数据字典的CODE值（二级数据字典CODE，对应详细的数据字典），然后赋值到数据字典值上。

一、后端经过注解完成数据字典转化功用

1、新增数据字典注解定义

package com.gitegg.platform.base.annotation.dict;
import java.lang.annotation.*;
/**
 * 数据字典注解，注解在办法上，自动设置回来参数的字典数据
 * 1、能够注解在 service和 controller上，只注解回来值，支撑引证类型和常用的调集类型
 * 2、详细的实体类中，假如是引证类型，那么递归赋值
 * 3、支撑的调集类型：List Set Queue ，引证类型：Array一维数组，一般目标类型（自定义实体bean）。
 * @author GitEgg
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DictAuto {
}

package com.gitegg.platform.base.annotation.dict;
import java.lang.annotation.*;
/**
 * 数据字典注解，注解在字段上
 * 假如dictCode为空，且此字段是目标类型，那么表明此字段目标中拥有字典类型，
 * 也便是只要注解了此字段的数据才会去递归设置字典值，不去随意做无所谓的遍历
 *
 * @author GitEgg
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DictField {
    /**
     * 数据字典类型 ：体系字典 system 事务字典 business  地区字典 areas  其他字典：直接表名,例： t_sys_role
     * 1、确认挑选哪种类型的数据字典
     */
    String dictType() default "business";
    /**
     * 数据字典编码，便是取哪些数据字典的值
     * 2、确认需求匹配数据字典的调集
     */
    String dictCode() default "";
    /**
     * 要终究转化终究数据字典的键，是实体类中的一个字段，通常装备为此字段的定义称号，经过此字段作为key来转化数据字典的值
     * 3、确认需求把实体中哪个字段转化为字典值
     */
    String dictKey() default "";
    /**
     * 假如是自定义表数据时，此字段作为字典code，对应数据表的字段
     * 4、表中作为数据字典的键
     */
    String dictFiled() default "";
    /**
     * 假如是自定义表数据时，此字段作为字典value，对应数据表的字段
     * 5、表中作为数据字典的值
     */
    String dictValue() default "";
}

2、新增切面，处理数据字典注解

package com.gitegg.platform.boot.aspect;
import cn.hutool.core.util.ArrayUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.gitegg.platform.base.annotation.dict.DictAuto;
import com.gitegg.platform.base.annotation.dict.DictField;
import com.gitegg.platform.base.constant.DictConstant;
import com.gitegg.platform.base.constant.GitEggConstant;
import com.gitegg.platform.base.result.Result;
import com.gitegg.platform.boot.util.GitEggAuthUtils;
import com.gitegg.platform.redis.lock.IDistributedLockService;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import jodd.util.StringPool;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.BeanWrapperImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Component;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Consumer;
/**
 * 数据字典切面
 * @author GitEgg
 * @date 2022-4-10
 */
@Log4j2
@Component
@Aspect
@RequiredArgsConstructor(onConstructor_ = @Autowired)
@ConditionalOnProperty(name = "enabled", prefix = "dict", havingValue = "true", matchIfMissing = true)
public class DictAspect {
    /**
     * 是否敞开租户形式
     */
    @Value("${tenant.enable}")
    private Boolean enable;
    private final RedisTemplate redisTemplate;
    /**
     * 后置告诉 解析回来参数，进行字典设置
     * @AfterReturning 只要存在回来值时才会履行 @After 不管有没有回来值都会履行  所以这儿运用 @AfterReturning 只要存在回来值时才履行字典值注入操作
     * @param dictAuto 注解装备
     */
    @AfterReturning(pointcut = "@annotation(dictAuto)", returning = "returnObj")
    public void doAfterReturning( DictAuto dictAuto, Object returnObj){
        // 回来不为null时，进行数据字典处理
        if (null != returnObj) {
            doDictAuto(dictAuto, returnObj);
        }
    }
    /**
     * key的组成为: dict:userId:sessionId:uri:method:(依据spring EL表达式对参数进行拼接)
     * 此处要考虑多种回来类型，调集类型、引证类型、目标类型和根本数据类型，这儿只处理 调集类型：List Set Queue ，引证类型：Array数组，Array只支撑一维数组。
     * 关于目标中的子目标，为了提高功能，相同需求加@DictField注解才去填充，不然每个子目标都去递归判别，影响功能
     * 咱们要考虑此处的逻辑：
     * 1、判别回来数据类型，假如是调集类型，那么取出包含实体目标的调集类，然后进行目标解析
     * 2、假如是目标类型，那么直接进行目标解析
     * 3、假如是IPage类型，那么取出其间的list数据，判别是否为空，不为空，履行 1 过程
     * 4、假如是Result类型，判别Result的data是IPage还是调集类型，别离履行对应的 1 过程 或 3 过程，假如不是IPage也不是调集类型，直接履行第 2 过程
     * @param dictAuto 注解
     * @param objectReturn 办法回来值
     */
    private void doDictAuto(@NonNull DictAuto dictAuto, Object objectReturn) {
       // 临时存储数据字典map
       Map<String, Map<Object, Object>> dictMap = new HashMap<>();
       this.translationObjectDict(objectReturn, dictMap);
    }
    /**
     * 找到实际的目标或目标列表
     * 此处要考虑多种回来类型，调集类型、引证类型、目标类型和根本数据类型，这儿只处理 调集类型：List Set Queue ，引证类型：Array一维数组。
     * @param objectReturn
     * @param dictMap
     * @return
     */
    private void translationObjectDict(Object objectReturn, Map<String, Map<Object, Object>> dictMap) {
        if (Objects.isNull(objectReturn))
        {
            return;
        }
        // 判别回来值类型是Result、IPage、List、Object
        if (objectReturn instanceof Result) {
            Object objectTarget = ((Result) objectReturn).getData();
            translationObjectDict(objectTarget, dictMap);
        } else if (objectReturn instanceof IPage) {
            List<Object> objectTargetList = ((IPage) objectReturn).getRecords();
            translationObjectDict(objectTargetList, dictMap);
        } else if (objectReturn instanceof Collection) {
            ((Collection) objectReturn).forEach(object-> translationObjectDict(object, dictMap));
        } else if (ArrayUtil.isArray(objectReturn)) {
            // 数组这儿需求处理
            ((Collection) objectReturn).forEach(object-> translationObjectDict(object, dictMap));
        } else {
            parseObjectFieldCodeValue(objectReturn, dictMap);
        }
    }
    /**
     * 取出目标中需求进行字典转化的字段
     *
     * @param targetObj   : 取字段的目标
     * @param dictMap     : 存储数据字典
     * @author liam
     */
    private void parseObjectFieldCodeValue(Object targetObj, Map<String, Map<Object, Object>> dictMap) {
        if (Objects.isNull(targetObj))
        {
            return;
        }
        // 获取当时目标所有的field
        Field[] declaredFields = targetObj.getClass().getDeclaredFields();
        // 构造填充映射关系
        Arrays.stream(declaredFields).forEach(field ->
            // 递归处理
            parseFieldObjDict(field, targetObj,
                    fieldObj -> parseObjectFieldCodeValue(fieldObj, dictMap),
                    // 解析注解字段信息
                    () -> parseDictAnnotation(targetObj, field, dictMap)
            )
        );
    }
    /**
     * 解析field目标，对根本数据类型和杂乱类型直接依据注解赋值，关于目标或调集类型，继续进行递归遍历
     *
     * @param field          : 字段目标
     * @param obj            : 字段所属的obj目标
     * @param recursiveFunc  : 递归处理办法
     * @author liam
     */
    private static void parseFieldObjDict(Field field, Object obj, Consumer<Object> recursiveFunc,
                                          NestedFunction parseAnnotationFunc) {
        Class cls = field.getType();
        // 不处理map数据
        if (Map.class.isAssignableFrom(cls)) {
            return;
        }
        // 需求数据字典转化的特点：有Dict注解， @DictField只注解在一般字段上，不要注解到杂乱目标上
        if (field.isAnnotationPresent(DictField.class)) {
            // 分析注解并转化数据字典值
            parseAnnotationFunc.run();
        }
        // 没有注解的特点判别
        else {
            try {
                // 获取字段值且非空处理
                field.setAccessible(true);
                Optional.ofNullable(field.get(obj)).ifPresent(fieldValue -> {
                            // 调集类型，假如泛型的类型是JavaBean，继续递归处理
                            if (Collection.class.isAssignableFrom(cls)) {
                                // 假如是list-map成果，则这儿回来null
                                Class generic = getGeneric(obj.getClass(), field.getName());
                                if (null != generic && notInFilterClass(generic)) {
                                    // 循环递归处理
                                    ((Collection) fieldValue).forEach(recursiveFunc::accept);
                                }
                            }
                            // 非根本数据类型
                            else if (notInFilterClass(cls)) {
                                recursiveFunc.accept(fieldValue);
                            }
                        }
                );
            } catch (Exception e) {
                log.error(e.getMessage(), e);
            }
        }
    }
    /**
     * 获取一个类的特点的泛型；假如没有泛型，则回来null；
     * P.s 假如有多个，取第一个；假如有多层泛型，也回来null，比如List<Map>
     *
     * @param cls      :
     * @param property : 特点名
     * @author liam
     */
    public static Class getGeneric(Class cls, String property) {
        try {
            Type genericType = cls.getDeclaredField(property).getGenericType();
            // 假如是泛型参数的类型
            if (null != genericType && genericType instanceof ParameterizedType) {
                ParameterizedType pt = (ParameterizedType) genericType;
                Type type = pt.getActualTypeArguments()[GitEggConstant.Number.ZERO];
                // 这儿，type也可能是 ParameterizedType， 直接不考虑
                if (type instanceof Class) {
                    return (Class) type;
                }
            }
        } catch (Exception e) {
            log.error(e.getMessage(), e);
        }
        return null;
    }
    /**
     * 解析含有注解@DictField并赋值
     *
     * @param obj         : 目标
     * @param field       : 字段
     * @param dictMap     : 数据字典
     * @author liam
     */
    private void parseDictAnnotation(Object obj, Field field, Map<String, Map<Object, Object>> dictMap) {
        // 读取注解信息，获取编码类型
        DictField dictField = field.getAnnotation(DictField.class);
        String fieldName = field.getName();
        // 依据Dict的codeName特点或许字段称号，获取字典编码code
        String code = getFieldValue(obj, dictField, fieldName);
        if (!Strings.isNullOrEmpty(code)) {
            String dictType = dictField.dictType();
            String dictCode = dictField.dictCode();
            String dictKey = dictType + StringPool.COLON + dictCode;
            // 首先判别是否敞开多租户
            String redisDictKey = DictConstant.DICT_TENANT_MAP_PREFIX;
            if (enable) {
                redisDictKey += GitEggAuthUtils.getTenantId() + StringPool.COLON + dictKey;
            } else {
                redisDictKey = DictConstant.DICT_MAP_PREFIX + dictKey;
            }
            Map<Object, Object> dictKeyValue = dictMap.get(redisDictKey);
            // 首先从dictMap中获取值，假如没有，再从Redis数据库中获取值
            if (null == dictKeyValue) {
                // 从Redis数据库获取值
                Map<Object, Object> dictCodeMap = redisTemplate.opsForHash().entries(redisDictKey);
                dictMap.put(redisDictKey, dictCodeMap);
            }
            if (null != dictKeyValue.get(code))
            {
                try {
                    // 给Field赋值终究的数据字典
                    field.setAccessible(true);
                    field.set(obj, dictKeyValue.get(code));
                } catch (Exception e) {
                    log.error(e.getMessage(), e);
                }
            }
        }
    }
    /**
     * 依据Dict的codeName特点或许字段称号，获取字段值
     * 留意：假如当时字段没有以Name结束，那就取当时字段的值；也便是依据当时字段的值转化。
     *
     * @param obj            : 目标
     * @param dictField      : 字段注解目标
     * @param fieldName      : 字段称号
     * @return java.lang.String
     * @author liam
     */
    private String getFieldValue(Object obj, DictField dictField, String fieldName) {
        String codeName = dictField.dictKey();
        if (Strings.isNullOrEmpty(codeName)) {
            // 假如当时字段是Name结束，进行截取；不然取当时字段称号
            int endNameIndex = fieldName.lastIndexOf(DictConstant.NAME_SUFFIX);
            if (endNameIndex != -1) {
                codeName = fieldName.substring(0, endNameIndex);
            } else {
                codeName = fieldName;
            }
        }
        return getPropertyValue(obj, codeName);
    }
    /**
     * 获取目标里指定特点的值，并转化为字符串
     *
     * @param obj          : 目标
     * @param propertyName : 目标里面的特点称号
     * @author liam
     */
    private String getPropertyValue(Object obj, String propertyName) {
        BeanWrapperImpl beanWrapper = new BeanWrapperImpl(obj);
        if (beanWrapper.isReadableProperty(propertyName)) {
            Object propertyValue = beanWrapper.getPropertyValue(propertyName);
            if (null != propertyValue) {
                return propertyValue.toString();
            }
        }
        return "";
    }
    /**
     * 判别不在过滤类(常用根本数据类型)中
     */
    private static boolean notInFilterClass(Class cls) {
        return !DictConstant.baseTypeList.contains(cls);
    }
    /**
     * 函数式接口：相似freemarker中的<#nested>处理
     */
    @FunctionalInterface
    public interface NestedFunction {
        /**
         * 无参无回来值的办法运转
         */
        void run();
    }
}

二、前端转化数据字典

定义通用接口，首先从缓存查，缓存没有再查询数据库，在登录后重置数据字典。

1、前端新增dictUtils，用于dictCode的查询、缓存等操作

import { getAuthCache, setAuthCache } from '/@/utils/auth';
import { DICT_SYSTEM_CACHE_KEY, DICT_BUSSINESS_CACHE_KEY } from '/@/enums/cacheEnum';
import { listDict, batchListDict } from '/@/api/system/base/dict';
import { listDictBusiness, batchListDictBusiness } from '/@/api/system/base/dictBusiness';
// System default cache time
export const DICT_CACHE_TIME = 60 * 60 * 2 * 1000;
// Dict
export interface Dict {
  // dictCode
  dictCode: string;
  // dictList
  dictList?: [];
  // filterMap
  filterMap?: {};
}
// DictMap
export interface DictMap {
  // dictList
  dictMap: {};
}
export function getDictCacheOnly(dict: Dict) {
  let dictMap = getAuthCache(DICT_SYSTEM_CACHE_KEY) as any;
  if (!dictMap) {
    dictMap = {};
  }
  if (dictMap[dict.dictCode]) {
    return dictMap[dict.dictCode] as Dict;
  } else {
    getDict(dict).then(function (dictReturn) {
      dictMap[dict.dictCode] = dictReturn;
      // 数据字典默许缓存2小时，从头登陆后失效
      setAuthCache(DICT_SYSTEM_CACHE_KEY, dictMap);
    });
    return dict;
  }
}
export function getDictBusinessCacheOnly(dict: Dict) {
  let dictBusinessMap = getAuthCache(DICT_BUSSINESS_CACHE_KEY) as any;
  if (!dictBusinessMap) {
    dictBusinessMap = {};
  }
  if (dictBusinessMap[dict.dictCode]) {
    return dictBusinessMap[dict.dictCode] as Dict;
  } else {
    getDictBusiness(dict).then(function (dictReturn) {
      dictBusinessMap[dict.dictCode] = dictReturn;
      // 数据字典默许缓存2小时，从头登陆后失效
      setAuthCache(DICT_BUSSINESS_CACHE_KEY, dictBusinessMap);
    });
    return dict;
  }
}
export async function getDictCache(dict: Dict) {
  let dictMap = getAuthCache(DICT_SYSTEM_CACHE_KEY) as any;
  if (!dictMap) {
    dictMap = {};
  }
  if (dictMap[dict.dictCode]) {
    return dictMap[dict.dictCode] as Dict;
  } else {
    const dictReturn = await getDict(dict);
    dictMap[dict.dictCode] = dictReturn;
    // 数据字典默许缓存2小时，从头登陆后失效
    setAuthCache(DICT_SYSTEM_CACHE_KEY, dictMap);
    return dictReturn;
  }
}
export async function getDictBusinessCache(dict: Dict) {
  let dictBusinessMap = getAuthCache(DICT_BUSSINESS_CACHE_KEY) as any;
  if (!dictBusinessMap) {
    dictBusinessMap = {};
  }
  if (dictBusinessMap[dict.dictCode]) {
    return dictBusinessMap[dict.dictCode] as Dict;
  } else {
    const dictReturn = await getDictBusiness(dict);
    dictBusinessMap[dict.dictCode] = dictReturn;
    // 数据字典默许缓存2小时，从头登陆后失效
    setAuthCache(DICT_BUSSINESS_CACHE_KEY, dictBusinessMap);
    return dictReturn;
  }
}
// 批量初始化体系字典
export async function initDictCache(dictCodeList: string[]) {
  let dictMap = getAuthCache(DICT_SYSTEM_CACHE_KEY) as any;
  if (!dictMap) {
    dictMap = {};
  }
  const dictResultMap = await batchListDict(dictCodeList);
  if (dictResultMap) {
    dictCodeList.forEach(function (dictCode) {
      if (dictResultMap[dictCode]) {
        const dict = {} as Dict;
        dict.dictList = dictResultMap[dictCode];
        dict.filterMap = {};
        dict.dictList.forEach((item) => {
          const itemDict = item as any;
          dict.filterMap[itemDict.dictCode] = itemDict.dictName;
        });
        dictMap[dictCode] = dict;
      }
    });
    // 数据字典默许缓存2小时，从头登陆后失效
    setAuthCache(DICT_SYSTEM_CACHE_KEY, dictMap);
  }
}
// 批量初始化事务字典
export async function initDictBusinessCache(dictCodeList: string[]) {
  let dictMap = getAuthCache(DICT_BUSSINESS_CACHE_KEY) as any;
  if (!dictMap) {
    dictMap = {};
  }
  const dictResultMap = await batchListDictBusiness(dictCodeList);
  if (dictResultMap) {
    dictCodeList.forEach(function (dictCode) {
      if (dictResultMap[dictCode]) {
        const dict = {} as Dict;
        dict.dictList = dictResultMap[dictCode];
        dict.filterMap = {};
        dict.dictList.forEach((item) => {
          const itemDict = item as any;
          dict.filterMap[itemDict.dictCode] = itemDict.dictName;
        });
        dictMap[dictCode] = dict;
      }
    });
    // 数据字典默许缓存2小时，从头登陆后失效
    setAuthCache(DICT_BUSSINESS_CACHE_KEY, dictMap);
  }
}
export async function getDict(dict: Dict) {
  const dictList = await listDict(dict.dictCode);
  if (dictList && dictList.length > 0) {
    dict.dictList = dictList;
    dict.filterMap = {};
    dictList.forEach((item) => {
      dict.filterMap[item.dictCode] = item.dictName;
    });
  }
  return dict;
}
export async function getDictBusiness(dict: Dict) {
  const dictBusinessList = await listDictBusiness(dict.dictCode);
  if (dictBusinessList && dictBusinessList.length > 0) {
    dict.dictList = dictBusinessList;
    dict.filterMap = {};
    dictBusinessList.forEach((item) => {
      dict.filterMap[item.dictCode] = item.dictName;
    });
  }
  return dict;
}

2、登录成功后从头数据字典缓存，也便是每次在后台数据字典修正之后，前端需求从头登录才能改写数据字典缓存。

      // 从头初始化体系数据字典
      setAuthCache(DICT_SYSTEM_CACHE_KEY, {});
      // 从头初始化事务数据字典
      setAuthCache(DICT_BUSSINESS_CACHE_KEY, {});

3、在需求用到数据字典时，直接调用即可，依据utils的完成，首先会从缓存查询，假如缓存中没有，才会从后台查询。

import { getDictBusinessCache } from '/@/utils/gitegg/dictUtils';
......
  {
    label: '状况',
    field: 'status',
    component: 'ApiRadioGroup',
    required: true,
    defaultValue: '2',
    componentProps: {
      api: getDictBusinessCache,
      params: { dictCode: 'USER_STATUS' },
      resultField: 'dictList',
      // use name as label
      labelField: 'dictName',
      // use id as value
      valueField: 'dictCode',
    },
  },
......

数据字典在体系中的运用十分频繁，所以在规划和运用时，既要确保实时更新获取最新装备，又要确保不能引发体系功能问题。在体系规划的时候，既要考虑到后台数据字典转化，还需求考虑到前端数据字典转化，这两种转化办法在运用过程中，咱们依据详细事务需求和运用条件详细挑选其间一种即可。

SpringCloud微服务实战——搭建企业级开发框架（五十）：系统通用数据字典注解的设计与实现

常用的数据字典运用办法：

数据字典转化流程：

一、后端经过注解完成数据字典转化功用

1、新增数据字典注解定义

2、新增切面，处理数据字典注解

二、前端转化数据字典

相关文章

换种方式看后端参数接收、建议躺着看！！！

Rust语言从入门到精通系列 – 强大且灵活的匹配模式

Go语言基础必备知识点(九) 包(package)、init函数、go mod篇

Android设置时区功能开发

作者信息