資料字典是系統中基本的必不可少的功能，在多種多樣的系統中，資料字典表的設計都大同小異。但是使用方式确是多種多樣，設計好一套易用的資料字典功能子產品，可以使開發事半功倍。

常用的資料字典使用方式：

直接在SQL語句中LEFT JOIN （當然是不推薦這樣用的）
查詢出原始資料，然後再根據原始資料需要的字典編碼，批量查詢字典表，并指派到原始資料的字典值字段。
背景提供通用資料字典接口，前端根據需求統一查詢資料字典資料并緩存在前台。當業務傳回背景原始資料時，前台通過類似于Filter（VUE）功能，進行字典值對應。
自定義資料字典注解，當接口傳回原始資料時，通過切面分析傳回對象中的資料字典字段，并将資料字典指派到資料字典值字段。
提供資料字典通用工具，手動處理單個或批量需要進行資料字典轉換的資料。

我們為了更好的滿足多樣的業務需求，那麼我們肯定是需要支援多種多樣的方式，來實作資料字典轉換的功能，接下來，我們以1注解+2工具+3前端轉換的方式來支援資料字典轉換。三種方式相輔相成、可以單獨使用，也可以結合起來使用。

可注解在Controller
可注解在Service
支援的集合類型：List、Set、Queue ，引用類型：Array一維數組
單獨的bean支援遞歸指派，不支援複雜資料遞歸
背景提供通用資料字典接口，前端頁面提供通用轉換方法。
隻注解在普通字段上，不要注解到複雜對象上

資料字典轉換流程：

在Service或者Controller添加@DictAuto注解，用于切面判斷此方法是需要進行資料字典轉換的方法。
切面發現此方法是需要資料字典轉換的方法之後，那麼解析方法的傳回參數，傳回參數有多種資料類型，這裡隻處理集合類型：List、Set、Queue ，引用類型：Array一維數組還有普通對象類型（自定義實體bean）。
無論是集合類型還是普通對象類型都需要進行周遊、遞歸等操作，因為List裡面是普通對象，對象中也有可能是集合類型。（此處需要注意，請不要在對象中的字段嵌套自己，這樣會造成死循環。當然，對象中可以嵌套自己的對象類型，可以引用非自己的對象執行個體，因為遞歸操作中，我們會判斷如果是null，那麼終止遞歸）
對傳回類型進行遞歸時，通過注解擷取到資料字典類型（system、business等）、資料字典CODE（一級資料字典CODE，作為資料字典的分類），通過此條件去Redis資料庫查詢資料字典清單。将查詢的資料字典清單存儲在Map中。在循環周遊過程中，增加判斷，如果Map中有了，那麼不再查詢Redis資料庫，而是直接從Map中取。
在周遊遞歸對象的同時，根據資料字典注解，擷取本對象中用于映射資料字典的字段值作為資料字典的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',
    },
  },
......

資料字典在系統中的使用非常頻繁，是以在設計和使用時，既要保證明時更新擷取最新配置，又要保證不能引發系統性能問題。在系統設計的時候，既要考慮到背景資料字典轉換，還需要考慮到前端資料字典轉換，這兩種轉換方式在使用過程中，我們根據具體業務需求和使用條件具體選擇其中一種即可。

源碼位址:

Gitee: https://gitee.com/wmz1930/GitEgg

GitHub: https://github.com/wmz1930/GitEgg

「SpringCloud」(四十八) 資料字典注解的設計與實作

常用的資料字典使用方式：

資料字典轉換流程：

一、通過注解實作資料字典轉換功能

1、新增資料字典注解定義

2、新增切面，處理資料字典注解

二、實作自定義工具，手動進行資料字典轉換

三、前端轉換資料字典

源碼位址:

繼續閱讀

MyBatis-Plus 之AR模式

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法