• springboot 数据字典设计思路：字典表+字典枚举 两者兼故方案，查询返回结果在controller方法上添加注解进行字典翻译

    方式一：使用字典表存取 

            说明：适合于前端页面使用的下拉框数据值、或者字典数据不固定有变化调整的字典，建议放在数据表中维护。

           直接借鉴Ruoyi框架提供的2张字典表，sys_dict_type（字典类型定义表）、sys_dict_data（字典数据表）

    1. CREATE TABLE `sys_dict_type` (
    2.   `dict_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '字典主键',
    3.   `dict_name` varchar(100) DEFAULT '' COMMENT '字典名称',
    4.   `dict_type` varchar(100) DEFAULT '' COMMENT '字典类型',
    5.   `status` char(1) DEFAULT '0' COMMENT '状态（0正常 1停用）',
    6.   `create_by` varchar(64) DEFAULT '' COMMENT '创建者',
    7.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
    8.   `update_by` varchar(64) DEFAULT '' COMMENT '更新者',
    9.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
    10.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    11.   PRIMARY KEY (`dict_id`),
    12.   UNIQUE KEY `dict_type` (`dict_type`)
    13. ) COMMENT='字典类型表';
    14.  
    15. CREATE TABLE `sys_dict_data` (
    16.   `dict_code` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '字典编码',
    17.   `dict_sort` int(4) DEFAULT '0' COMMENT '字典排序',
    18.   `dict_label` varchar(100) DEFAULT '' COMMENT '字典标签',
    19.   `dict_value` varchar(100) DEFAULT '' COMMENT '字典键值',
    20.   `dict_type` varchar(100) DEFAULT '' COMMENT '字典类型',
    21.   `css_class` varchar(100) DEFAULT NULL COMMENT '样式属性（其他样式扩展）',
    22.   `list_class` varchar(100) DEFAULT NULL COMMENT '表格回显样式',
    23.   `is_default` char(1) DEFAULT 'N' COMMENT '是否默认（Y是 N否）',
    24.   `status` char(1) DEFAULT '0' COMMENT '状态（0正常 1停用）',
    25.   `create_by` varchar(64) DEFAULT '' COMMENT '创建者',
    26.   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
    27.   `update_by` varchar(64) DEFAULT '' COMMENT '更新者',
    28.   `update_time` datetime DEFAULT NULL COMMENT '更新时间',
    29.   `remark` varchar(500) DEFAULT NULL COMMENT '备注',
    30.   PRIMARY KEY (`dict_code`)
    31. ) COMMENT='字典数据表';

    方式二：自定义枚举变量

            说明：适用于系统级别、固定不变的字典；可以考虑直接写在代码中，方便其它人在代码中使用。

    1. @DictType("sys_disable")
    2. public enum SysDisableEnum {
    3.     ENABLE("0", "启用"),
    4.     DISABLE("1", "停用");
    5.  
    6.     private String code;
    7.     private String desc;
    8.  
    9.     public static List toList() {
    10.         return (List)Stream.of(values()).map((row) -> {
    11.             DictOptions options = new DictOptions();
    12.             options.setDictLabel(row.getDesc());
    13.             options.setDictValue(row.getCode());
    14.             return options;
    15.         }).collect(Collectors.toList());
    16.     }
    17.  
    18.     private SysDisableEnum(final String code, final String desc) {
    19.         this.code = code;
    20.         this.desc = desc;
    21.     }
    22.  
    23.     public String getCode() {
    24.         return this.code;
    25.     }
    26.  
    27.     public String getDesc() {
    28.         return this.desc;
    29.     }
    30. }

            对于字典表，在使用时很简单，无非是提供好添加、更新、删除及查询的API即可；但对于枚举字典，怎么能不重复配置到字典表中，同时又能融入到 查询字典的API中，这里就需要好好封装一下代码了！

            具体实现代码参考如下：  

    1. /**
    2.  * 字典类型枚举：@DictType(value="sys_sex")
    3.  */
    4. @Documented
    5. @Inherited
    6. @Retention(RetentionPolicy.RUNTIME)
    7. @Target(ElementType.TYPE)
    8. public @interface DictType {
    9.  
    10.     String value();//字典类型别名
    11. }
    12.  
    13.  
    14. /**
    15.  * 字典翻译注解：@DictEnum(value="sex", dictType="sys_sex")
    16.  */
    17. @Documented
    18. @Retention(RetentionPolicy.RUNTIME)
    19. @Target(ElementType.METHOD)
    20. public @interface DictEnum {
    21.  
    22.     String value();//实体类字段
    23.  
    24.     String dictType() default "";//字典code;指的是dict_type
    25.  
    26.     String target() default "";//返回目标属性,如 sexDesc
    27. }
    28.  
    29. /**
    30.  * 字典类型注解：用于多个字典翻译
    31.  */
    32. @Documented
    33. @Retention(RetentionPolicy.RUNTIME)
    34. @Target(ElementType.METHOD)
    35. public @interface DictEnums {
    36.  
    37.     DictEnum[] value();//多个字典值
    38. }
    1. package com.geline.cloud.core.dict;
    2.  
    3. import com.geline.cloud.core.domain.DictOptions;
    4.  
    5. import java.util.HashMap;
    6. import java.util.List;
    7. import java.util.Map;
    8.  
    9. /**
    10.  * 字典枚举缓存
    11.  * @author: mengxin
    12.  * @date: 2022/9/25 10:14
    13.  */
    14. public class DictTypeCache {
    15.  
    16.     private static Map> dictMapCache = new HashMap<>();
    17.  
    18.     public static void put(String dictType, List optionsList) {
    19.         dictMapCache.put(dictType, optionsList);
    20.     }
    21.  
    22.     public static Map> getAll(){
    23.         return dictMapCache;
    24.     }
    25.  
    26.     /**
    27.      * 获取字典值对应的标签名
    28.      * @param dictType
    29.      * @param dictValue
    30.      * @return
    31.      */
    32.     public static String getDictLabel(String dictType, String dictValue){
    33.         List options = dictMapCache.get(dictType);
    34.         if(options != null){
    35.             for (DictOptions row : options){
    36.                 if(row.getDictValue().equals(dictValue)){
    37.                     return row.getDictLabel();
    38.                 }
    39.             }
    40.         }
    41.         return null;
    42.     }
    43. }
    1. package com.geline.cloud.core.dict;
    2.  
    3. import com.geline.cloud.core.dict.annotation.DictType;
    4. import com.geline.cloud.core.domain.DictOptions;
    5. import org.springframework.boot.CommandLineRunner;
    6. import org.springframework.context.ResourceLoaderAware;
    7. import org.springframework.core.io.Resource;
    8. import org.springframework.core.io.ResourceLoader;
    9. import org.springframework.core.io.support.ResourcePatternResolver;
    10. import org.springframework.core.io.support.ResourcePatternUtils;
    11. import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
    12. import org.springframework.core.type.classreading.MetadataReader;
    13. import org.springframework.core.type.classreading.MetadataReaderFactory;
    14. import org.springframework.stereotype.Component;
    15. import org.springframework.util.ClassUtils;
    16.  
    17. import java.lang.reflect.InvocationTargetException;
    18. import java.lang.reflect.Method;
    19. import java.util.List;
    20. import java.util.Map;
    21.  
    22. /**
    23.  * 扫描自定义字典枚举类 @DictType
    24.  * @author: mengxin
    25.  * @date: 2022/9/25 10:16
    26.  */
    27. @Component
    28. public class DictTypeHandler implements CommandLineRunner, ResourceLoaderAware {
    29.     private ResourceLoader resourceLoader;
    30.  
    31.     private ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
    32.     private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
    33.     private static final String FULLTEXT_SACN_PACKAGE_PATH = "com.geline.cloud";
    34.  
    35.     @Override
    36.     public void setResourceLoader(ResourceLoader resourceLoader) {
    37.         this.resourceLoader = resourceLoader;
    38.     }
    39.  
    40.     @Override
    41.     public void run(String... args) throws Exception {
    42.         String concat = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
    43.                 .concat(ClassUtils.convertClassNameToResourcePath(FULLTEXT_SACN_PACKAGE_PATH)
    44.                         .concat("/**/*Enum*.class")); //只扫描文件名中包含Enum的文件,会快点
    45.         Resource[] resources = resolver.getResources(concat);
    46.         MetadataReader metadataReader = null;
    47.         for (Resource resource : resources) {
    48.             if (resource.isReadable()) {
    49.                 metadataReader = metadataReaderFactory.getMetadataReader(resource);
    50.                 boolean flag = metadataReader.getAnnotationMetadata().hasAnnotation(DictType.class.getName());
    51.                 String className = metadataReader.getClassMetadata().getClassName();
    52.  
    53.                 if(flag) {
    54.                     Map annotationAttributes = metadataReader.getAnnotationMetadata()
    55.                             .getAnnotationAttributes(DictType.class.getName());
    56.                     String dictType = annotationAttributes.get("value").toString();
    57.  
    58.                     try {
    59.                         Class aClass = Class.forName(className);
    60.                         Method listDict = aClass.getDeclaredMethod("toList");
    61.                         Object[] oo = aClass.getEnumConstants();
    62.                         List list = (List) listDict.invoke(oo[0]);
    63.                         if(list != null){
    64.                             DictTypeCache.put(dictType, list);
    65.                         }
    66.                     } catch (ClassNotFoundException | NoSuchMethodException e) {
    67.                         e.printStackTrace();
    68.                     } catch (IllegalAccessException e) {
    69.                         e.printStackTrace();
    70.                     } catch (InvocationTargetException e) {
    71.                         e.printStackTrace();
    72.                     }
    73.                 }
    74.             }
    75.         }
    76.     }
    77. }
    1. package com.geline.cloud.core.domain;
    2.  
    3. import lombok.Getter;
    4. import lombok.Setter;
    5.  
    6. /**
    7.  * 查询字典列表
    8.  * @author: mengx
    9.  * @date: 2021/9/14 16:18
    10.  */
    11. @Getter
    12. @Setter
    13. public class DictOptions {
    14.  
    15.     private String dictType;
    16.     private String dictLabel;
    17.     private String dictValue;
    18.     private String isDefault;
    19.     private String listClass;
    20. }
    1. package com.geline.cloud.core.dict;
    2.  
    3. import cn.hutool.core.util.ObjectUtil;
    4. import cn.hutool.core.util.ReflectUtil;
    5. import cn.hutool.core.util.StrUtil;
    6. import com.baomidou.mybatisplus.core.metadata.IPage;
    7. import com.geline.cloud.core.dict.annotation.DictEnum;
    8. import com.geline.cloud.core.dict.annotation.DictEnums;
    9. import com.geline.cloud.core.domain.Result;
    10. import com.geline.cloud.core.domain.TableDataInfo;
    11. import lombok.extern.slf4j.Slf4j;
    12. import org.springframework.core.MethodParameter;
    13. import org.springframework.http.MediaType;
    14. import org.springframework.http.server.ServerHttpRequest;
    15. import org.springframework.http.server.ServerHttpResponse;
    16. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    17.  
    18. import java.lang.reflect.Field;
    19. import java.lang.reflect.Method;
    20. import java.util.Map;
    21.  
    22. /**
    23.  * 使用方式：子类继承后加 @ControllerAdvice
    24.  * @author: mengxin
    25.  * @date: 2022/9/17 10:05
    26.  */
    27. @Slf4j
    28. public abstract class AbstractDictEnumHandler implements ResponseBodyAdvice {
    29.  
    30.     /**
    31.      * 从DB中查询字典标签名
    32.      * @param dictType 字典类型code
    33.      * @param dictValue 字典值code
    34.      * @return
    35.      */
    36.     public abstract String selectDictLabelByDatabase(String dictType, String dictValue);
    37.  
    38.     /**
    39.      * 从枚举字典中取字典标签名
    40.      * @param dictType
    41.      * @param dictValue
    42.      * @return
    43.      */
    44.     public String selectDictLabelByEnum(String dictType, String dictValue){
    45.         return DictTypeCache.getDictLabel(dictType, dictValue);
    46.     }
    47.  
    48.     @Override
    49.     public boolean supports(MethodParameter methodParameter, Class aClass) {
    50.         return methodParameter.hasMethodAnnotation(DictEnum.class) || methodParameter.hasMethodAnnotation(DictEnums.class);
    51.     }
    52.  
    53.     @Override
    54.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class clazz,
    55.                                   ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
    56.         if (ObjectUtil.isEmpty(o)) {
    57.             return null;
    58.         }
    59.         // 获取方法 注解参数
    60.         Method method = methodParameter.getMethod();
    61.         final String methodName = method == null ? "" : (method.getDeclaringClass().getSimpleName() + "." + method.getName());
    62.         DictEnum[] sensibles;
    63.         if (methodParameter.hasMethodAnnotation(DictEnum.class)) {
    64.             DictEnum sensible = methodParameter.getMethodAnnotation(DictEnum.class);
    65.             sensibles = new DictEnum[]{sensible};
    66.         } else {
    67.             DictEnums typeSensibles = methodParameter.getMethodAnnotation(DictEnums.class);
    68.             sensibles = typeSensibles == null ? new DictEnum[]{} : typeSensibles.value();
    69.         }
    70.         // 处理返回值
    71.         this.dis(o, sensibles, methodName);
    72.         return o;
    73.     }
    74.  
    75.     /**
    76.      * 处理返回数据
    77.      *
    78.      * @param obj       对象
    79.      * @param sensibles 字典类型
    80.      */
    81.     private void dis(Object obj, DictEnum[] sensibles, String methodName) {
    82.         // 处理返回类型
    83.         if (obj instanceof TableDataInfo) {
    84.             this.dis(((TableDataInfo) obj).getRows(), sensibles, methodName);
    85.             return;
    86.         }
    87.         if (obj instanceof Result) {
    88.             this.dis(((Result) obj).getData(), sensibles, methodName);
    89.             return;
    90.         }
    91.         if (obj instanceof IPage) {
    92.             ((IPage) obj).getRecords().forEach(e -> this.dis(e, sensibles, methodName));
    93.             return;
    94.         }
    95.         if (obj instanceof Iterable) {
    96.             ((Iterable) obj).forEach(e -> this.dis(e, sensibles, methodName));
    97.             return;
    98.         }
    99.         if (obj instanceof Map) {
    100.             Map map = (Map) obj;
    101.             for (DictEnum sensible : sensibles) {
    102.                 if (!map.containsKey(sensible.value())) {
    103.                     log.warn("--- 方法 {},字典 {} 进行忽略,不存在 ------", methodName, sensible.value());
    104.                     continue;
    105.                 }
    106.                 Object value = map.get(sensible.value());
    107.                 if (value instanceof Iterable) {
    108.                     this.dis(value, sensibles, methodName);
    109.                     continue;
    110.                 }
    111.                 String dictType = StrUtil.isEmpty(sensible.dictType()) ? StrUtil.toUnderlineCase(sensible.value()) : sensible.dictType();
    112.                 String label = selectDictLabelByEnum(dictType, String.valueOf(value));
    113.                 if(label == null){
    114.                     label = selectDictLabelByDatabase(dictType, String.valueOf(value));
    115.                 }
    116.                 String target = sensible.target();
    117.                 map.put(StrUtil.isNotBlank(target) ? target : sensible.value(), label);
    118.             }
    119.             return;
    120.         }
    121.         Class clazz = obj.getClass();
    122.         for (DictEnum sensible : sensibles) {
    123.             try {
    124.                 Field field = ReflectUtil.getField(clazz, sensible.value());
    125.                 if (field == null || !field.getType().getSimpleName().contains("String")) {
    126.                     log.warn("--- 方法 {},字典 {} 进行忽略,不存在 || 非String类型 ------", methodName, sensible.value());
    127.                     continue;
    128.                 }
    129.                 Object val = ReflectUtil.getFieldValue(obj, field);
    130.                 if (ObjectUtil.isEmpty(val)) {
    131.                     continue;
    132.                 }
    133.                 String dictType = StrUtil.isEmpty(sensible.dictType()) ? StrUtil.toUnderlineCase(sensible.value()) : sensible.dictType();
    134.                 String label = selectDictLabelByEnum(dictType, String.valueOf(val));
    135.                 if(label == null){
    136.                     label = selectDictLabelByDatabase(dictType, String.valueOf(val));
    137.                 }
    138.                 ReflectUtil.setFieldValue(obj, field, label);
    139.             } catch (Exception e) {
    140.                 e.printStackTrace();
    141.             }
    142.         }
    143.     }
    144. }
      145.  

      1. package com.geline.cloud.util.dict;
      2.  
      3. import com.geline.cloud.core.dict.AbstractDictEnumHandler;
      4. import com.geline.cloud.modules.system.entity.SysDictData;
      5. import com.geline.cloud.modules.system.service.SysDictDataService;
      6. import lombok.extern.slf4j.Slf4j;
      7. import org.springframework.beans.factory.annotation.Autowired;
      8. import org.springframework.web.bind.annotation.ControllerAdvice;
      9.  
      10. /**
      11.  * 自定义字典处理
      12.  * @author: mengxin
      13.  * @date: 2022/9/17 10:43
      14.  */
      15. @ControllerAdvice
      16. @Slf4j
      17. public class MyDictEnumHandler extends AbstractDictEnumHandler {
      18.  
      19.     @Autowired
      20.     private SysDictDataService sysDictDataService;
      21.  
      22.     @Override
      23.     public String selectDictLabelByDatabase(String dictType, String dictValue) {
      24.         SysDictData dictData = sysDictDataService.getDictData(dictType, dictValue);
      25.         if(dictData != null){
      26.             return dictData.getDictLabel();
      27.         }
      28.         return null;
      29.     }
      30. }
       

      具体使用方法：
       

      在controller方法上添加注解，扩展返回字典字段，如查询返回 sex, 增加一个sexDesc；
       

      举例：分页查询返回 Page处理字典，多个字典字段使用 @DictEnums，一个字典字段使用 @DictEnum 。
       

      1.     /**
      2.      * 分页查询
      3.      * localhost:9501/reportData/pageMaps?pageNum=1&pageSize=10&orderByColumn=create_time&isAsc=desc&reportTitle=标题
      4.      * @param pageNum
      5.      * @param pageSize
      6.      * @param orderByColumn
      7.      * @param isAsc
      8.      * @return
      9.      */
      10.     @DictEnums({
      11.             @DictEnum(value = "reportType", dictType = "sys_report_type"),
      12.             @DictEnum(value = "status", dictType = "sys_disable", target = "statusDesc")
      13.     })
      14.     @GetMapping({"/pageMaps"})
      15.     public TableDataInfo pageMaps(String reportTitle,
      16.                                   int pageNum, int pageSize, String orderByColumn, String isAsc) {
      17.         ReportDataQueryVO queryVO = new ReportDataQueryVO();
      18.         queryVO.setReportTitle(reportTitle);
      19.         QueryWrapper query = QueryWrapperUtil.build(queryVO, orderByColumn, isAsc);
      20.         Page page = this.getBaseService().pageMaps(new Page(pageNum, pageSize), query);
      21.         return this.getTableDataInfo(page);
      22.     }
      23.  
      24.  
      25.     /**
      26.      * 地图数据 - 分页查询
      27.      * localhost:9501/visualMap/pageMaps?pageNum=1&pageSize=10&orderByColumn=create_time&isAsc=desc&name={名称}
      28.      * @return
      29.      */
      30.     @DictEnum(value = "disable", dictType = "sys_disable")
      31.     @GetMapping({"/pageMaps"})
      32.     public TableDataInfo pageMaps(int pageNum, int pageSize, String orderByColumn, String isAsc, String name) {
      33.         VisualMapQueryVO queryVO = new VisualMapQueryVO();
      34.         queryVO.setName(name);
      35.         QueryWrapper query = QueryWrapperUtil.build(queryVO, orderByColumn, isAsc);
      36.         Page page = this.visualMapService.pageMaps(new Page(pageNum, pageSize), query);
      37.         return this.getTableDataInfo(page);
      38.     }
       

              至于 添加、更新相关代码，直接用mybatis生成的 Enitity.java，不用在实体类中额外添加 @Dict注解，前端添加、更新时传入字典code直接保存及更新，字典问题－只考虑查询返回的字典翻译问题。
       

              最后，再提供2个查询返回字典列表方法：
       

      1. package com.geline.cloud.system;
      2.  
      3. import com.geline.cloud.core.dict.DictTypeCache;
      4. import com.geline.cloud.core.domain.DictOptions;
      5. import com.geline.cloud.core.domain.Result;
      6. import com.geline.cloud.modules.system.service.SysDictDataService;
      7. import org.springframework.beans.factory.annotation.Autowired;
      8. import org.springframework.web.bind.annotation.GetMapping;
      9. import org.springframework.web.bind.annotation.PathVariable;
      10. import org.springframework.web.bind.annotation.RequestMapping;
      11. import org.springframework.web.bind.annotation.RestController;
      12.  
      13. import java.util.List;
      14. import java.util.Map;
      15.  
      16. /**
      17.  * 字典管理 Controller
      18.  * @author mengx
      19.  * @date 2020/7/26 21:45
      20.  */
      21. @RestController
      22. @RequestMapping("/system/dict")
      23. public class SysDictController {
      24.  
      25.     @Autowired
      26.     private SysDictDataService sysDictDataService;
      27.  
      28.     /**
      29.      * 查询所有枚举字典Map
      30.      * /system/dict/listEnums
      31.      * @return
      32.      */
      33.     @GetMapping("/listEnums")
      34.     public Result listEnums(){
      35.         return Result.ok(DictTypeCache.getAll());
      36.     }
      37.  
      38.     /**
      39.      * 根据字典类型查询字典列表
      40.      * /system/dict/list/{dictType}
      41.      * @param dictType
      42.      * @return
      43.      */
      44.     @GetMapping("/list/{dictType}")
      45.     public Result list(@PathVariable String dictType){
      46.         Map> all = DictTypeCache.getAll();
      47.         List options = all.get(dictType);
      48.         if(options != null){
      49.             return Result.ok(options);
      50.         }
      51.         return Result.ok(sysDictDataService.getListByDictType(dictType));
      52.     }
      53.  
      54. }
       

       
       

       
      
                
                    
                

                
    145. 

                    相关阅读:
      
                    
超全，看完这份微服务架构与实践文档，微服务不再难                            
      
iRDMA Flow Control Introduction                            
      
计算点云每个点的高斯曲率（附open3d python代码）                            
      
Java集合源码剖析——基于JDK1.8中ConcurrentHashMap的实现原理                            
      
第2节 volatile 关键字内存可见性                            
      
智能咖啡厅助手：人形机器人 +融合大模型，行为驱动的智能咖啡厅机器人                            
      
计算机网络知识点总结——第四章网络层                            
      
C++:map和set容器                            
      
Character.AI：产品优势和商业壁垒在哪里？                            
      
C语言——有一篇文章，共有 3 行文字，每行有 80 个字符。要求分别统计出其中英文大写字母、小写字母、数字、空格以及其他字符的个数                            
      
                          
                
      146. 
                
    146. 
                    原文地址：https://blog.csdn.net/mxskymx/article/details/127107953
                
      147.