[关闭]
@liruiyi962464 2025-07-25T08:13:06.000000Z 字数 42113 阅读 105

Jeecg-boot字典翻译改造

代码

一.找到字典切面类(DictAspect)
二.改造方法(parseDictText)
三.修改后的parseDictText方法，支持IPage、List、Object,parseDictText 注释此方法，完后拷贝下方代码

  1. private void parseDictText(Object result) {
  2.         if (result instanceof Result) {
  3.             List<Object> list = new LinkedList<>();
  4.             if (((Result) result).getResult() instanceof IPage) {
  5.                 //分页
  6.                 list = ((IPage) ((Result) result).getResult()).getRecords();
  7.             } else if (((Result) result).getResult() instanceof List) {
  8.                 //List集合
  9.                 list = (List<Object>) ((Result) result).getResult();
  10.             }else{
  11.                 //单对象
  12.                 Object record = ((Result) result).getResult();
  13.                 //判断能否转换成JSON，因为有些结果集返回的是String类型，导致翻译异常，因此判断是否可以转换json
  14.                 if(checkIsJsonStr(record)){
  15.                     //字典翻译
  16.                     record =  this.dictEscape(record);
  17.                 }
  18.                 ((Result) result).setResult(record);
  19.             }
  20.             if(list != null && list.size() > 0){
  21.                 List<Object> items = new ArrayList<>();
  22.                 for(Object record : list){
  23.                     if(checkIsJsonStr(record)){
  24.                         //字典翻译
  25.                         record =  this.dictEscape(record);
  26.                     }
  27.                     items.add(record);
  28.                 }
  29.                 if (((Result) result).getResult() instanceof IPage) {
  30.                     ((IPage) ((Result) result).getResult()).setRecords(items);
  31.                 } else if (((Result) result).getResult() instanceof List) {
  32.                     ((Result) result).setResult(items);
  33.                 }
  34.             }
  35.         }
  36.     }

四.提取公共代码作为单独的方法进行翻译

  1. /**
  2.      * 字典翻译
  3.      * @param record
  4.      * @return
  5.      */
  6.     private JSONObject dictEscape(Object record){
  7.         ObjectMapper mapper = new ObjectMapper();
  8.         String json = "{}";
  9.         JSONObject item = null;
  10.         try {
  11.             //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
  12.             json = mapper.writeValueAsString(record);//对象序列化为JSON字符串
  13.         } catch (JsonProcessingException e) {
  14.             log.error("json解析失败" + e.getMessage(), e);
  15.         }
  16.         try {
  17.             item = JSONObject.parseObject(json);
  18.             //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  19.             for (Field field : oConvertUtils.getAllFields(record)) {
  20.                 //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  21.                 if (field.getAnnotation(Dict.class) != null) {
  22.                     String code = field.getAnnotation(Dict.class).dicCode();
  23.                     String text = field.getAnnotation(Dict.class).dicText();
  24.                     String table = field.getAnnotation(Dict.class).dictTable();
  25.                     String key = String.valueOf(item.get(field.getName()));
  26.                     //翻译字典值对应的txt
  27.                     String textValue = key;
  28.                     //非中文时翻译
  29.                     if(!checkCountName(key)){
  30.                         textValue = translateDictValue(code, text, table, key);
  31.                     }
  32.                     log.debug(" 字典Val : " + textValue);
  33.                     log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
  34.                     item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  35.                 }
  36.                 //date类型默认转换string格式化日期
  37.                 if (field.getType().getName().equals("java.util.Date") && field.getAnnotation(JsonFormat.class) == null && item.get(field.getName()) != null) {
  38.                     SimpleDateFormat aDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  39.                     item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
  40.                 }
  41.             }
  42.         }catch (Exception e){
  43.             log.info("字典翻译异常："+e.getMessage(),e);
  44.         }
  45.         return item;
  46.     }

五.增加中文检测方法

  1. /**
  2.      * 检测是否是中文
  3.      * @param countName
  4.      * @return
  5.      */
  6.     public static boolean checkCountName(String countName){
  7.         Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
  8.         Matcher m = p.matcher(countName);
  9.         if (m.find()) {
  10.             return true;
  11.         }
  12.         return false;
  13.     }

六.增加检测是否可转换为JSON字符串方法

  1. /**
  2.      * 检测是否可转换为JSON字符串
  3.      * @param record
  4.      * @return
  5.      */
  6.     public static boolean checkIsJsonStr(Object record){
  7.         boolean jsonFlag = false;
  8.         try {
  9.             String json = new ObjectMapper().writeValueAsString(record);
  10.             if(json.startsWith("{")) {
  11.                 jsonFlag = true;
  12.             }
  13.         } catch (JsonProcessingException e) {
  14.             e.printStackTrace();
  15.         }
  16.         return jsonFlag;
  17.     }

七、不涉及分布式的整体修改

  1. package org.jeecg.common.aspect;
  3. import com.alibaba.fastjson.JSON;
  4. import com.alibaba.fastjson.JSONObject;
  5. import com.alibaba.fastjson.parser.Feature;
  6. import com.baomidou.mybatisplus.core.metadata.IPage;
  7. import com.fasterxml.jackson.annotation.JsonFormat;
  8. import com.fasterxml.jackson.core.JsonProcessingException;
  9. import com.fasterxml.jackson.databind.ObjectMapper;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.aspectj.lang.ProceedingJoinPoint;
  12. import org.aspectj.lang.annotation.Around;
  13. import org.aspectj.lang.annotation.Aspect;
  14. import org.aspectj.lang.annotation.Pointcut;
  15. import org.jeecg.common.api.CommonAPI;
  16. import org.jeecg.common.api.vo.Result;
  17. import org.jeecg.common.aspect.annotation.Dict;
  18. import org.jeecg.common.constant.CommonConstant;
  19. import org.jeecg.common.system.vo.DictModel;
  20. import org.jeecg.common.util.oConvertUtils;
  21. import org.jetbrains.annotations.NotNull;
  22. import org.springframework.beans.factory.annotation.Autowired;
  23. import org.springframework.context.annotation.Lazy;
  24. import org.springframework.data.redis.core.RedisTemplate;
  25. import org.springframework.stereotype.Component;
  26. import org.springframework.util.StringUtils;
  28. import java.lang.reflect.Field;
  29. import java.text.SimpleDateFormat;
  30. import java.util.*;
  31. import java.util.concurrent.TimeUnit;
  32. import java.util.regex.Matcher;
  33. import java.util.regex.Pattern;
  34. import java.util.stream.Collectors;
  36. /**
  37.  * @Description: 字典aop类
  38.  * @Author: dangzhenghui
  39.  * @Date: 2019-3-17 21:50
  40.  * @Version: 1.0
  41.  */
  42. @Aspect
  43. @Component
  44. @Slf4j
  45. public class DictAspect {
  46.     @Lazy
  47.     @Autowired
  48.     private CommonAPI commonApi;
  49.     @Autowired
  50.     public RedisTemplate redisTemplate;
  52.     @Autowired
  53.     private ObjectMapper objectMapper;
  55.     private static final String JAVA_UTIL_DATE = "java.util.Date";
  57.     /**
  58.      * 定义切点Pointcut
  59.      */
  60.     @Pointcut("(@within(org.springframework.web.bind.annotation.RestController) || " +
  61.             "@within(org.springframework.stereotype.Controller) || @annotation(org.jeecg.common.aspect.annotation.AutoDict)) " +
  62.             "&& execution(public org.jeecg.common.api.vo.Result org.jeecg..*.*(..))")
  63.     public void excudeService() {
  64.     }
  66.     @Around("excudeService()")
  67.     public Object doAround(@NotNull ProceedingJoinPoint pjp) throws Throwable {
  68.         long time1=System.currentTimeMillis();  
  69.         Object result = pjp.proceed();
  70.         long time2=System.currentTimeMillis();
  71.         log.debug("获取JSON数据 耗时："+(time2-time1)+"ms");
  72.         long start=System.currentTimeMillis();
  73.         // result=this.parseDictText(result);
  74.         this.parseDictText(result);
  75.         long end=System.currentTimeMillis();
  76.         log.debug("注入字典到JSON数据  耗时"+(end-start)+"ms");
  77.         return result;
  78.     }
  80.     /**
  81.      * 本方法针对返回对象为Result 的IPage的分页列表数据进行动态字典注入
  82.      * 字典注入实现 通过对实体类添加注解@dict 来标识需要的字典内容,字典分为单字典code即可 ，table字典 code table text配合使用与原来jeecg的用法相同
  83.      * 示例为SysUser   字段为sex 添加了注解@Dict(dicCode = "sex") 会在字典服务立马查出来对应的text 然后在请求list的时候将这个字典text，已字段名称加_dictText形式返回到前端
  84.      * 例输入当前返回值的就会多出一个sex_dictText字段
  85.      * {
  86.      *      sex:1,
  87.      *      sex_dictText:"男"
  88.      * }
  89.      * 前端直接取值sext_dictText在table里面无需再进行前端的字典转换了
  90.      *  customRender:function (text) {
  91.      *               if(text==1){
  92.      *                 return "男";
  93.      *               }else if(text==2){
  94.      *                 return "女";
  95.      *               }else{
  96.      *                 return text;
  97.      *               }
  98.      *             }
  99.      *             目前vue是这么进行字典渲染到table上的多了就很麻烦了 这个直接在服务端渲染完成前端可以直接用
  100.      * @param result
  101.      */
  102. //    private Object parseDictText(Object result) {
  103. //        //if (result instanceof Result) {
  104. //        if (true) {
  105. //            if (((Result) result).getResult() instanceof IPage) {
  106. //                List<JSONObject> items = new ArrayList<>();
  107. //
  108. //                //step.1 筛选出加了 Dict 注解的字段列表
  109. //                List<Field> dictFieldList = new ArrayList<>();
  110. //                // 字典数据列表， key = 字典code，value=数据列表
  111. //                Map<String, List<String>> dataListMap = new HashMap<>(5);
  112. //                //取出结果集
  113. //                List<Object> records=((IPage) ((Result) result).getResult()).getRecords();
  114. //                //update-begin--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
  115. //                Boolean hasDict= checkHasDict(records);
  116. //                if(!hasDict){
  117. //                    return result;
  118. //                }
  119. //
  120. //                log.debug(" __ 进入字典翻译切面 DictAspect —— " );
  121. //                //update-end--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
  122. //                for (Object record : records) {
  123. //                    String json="{}";
  124. //                    try {
  125. //                        //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  126. //                        //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
  127. //                         json = objectMapper.writeValueAsString(record);
  128. //                        //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  129. //                    } catch (JsonProcessingException e) {
  130. //                        log.error("json解析失败"+e.getMessage(),e);
  131. //                    }
  132. //                    //update-begin--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
  133. //                    JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
  134. //                    //update-end--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
  135. //
  136. //                    //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  137. //                    //for (Field field : record.getClass().getDeclaredFields()) {
  138. //                    // 遍历所有字段，把字典Code取出来，放到 map 里
  139. //                    for (Field field : oConvertUtils.getAllFields(record)) {
  140. //                        String value = item.getString(field.getName());
  141. //                        if (oConvertUtils.isEmpty(value)) {
  142. //                            continue;
  143. //                        }
  144. //                    //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  145. //                        if (field.getAnnotation(Dict.class) != null) {
  146. //                            if (!dictFieldList.contains(field)) {
  147. //                                dictFieldList.add(field);
  148. //                            }
  149. //                            String code = field.getAnnotation(Dict.class).dicCode();
  150. //                            String text = field.getAnnotation(Dict.class).dicText();
  151. //                            String table = field.getAnnotation(Dict.class).dictTable();
  152. //                            //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  153. //                            String dataSource = field.getAnnotation(Dict.class).ds();
  154. //                            //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  155. //                            List<String> dataList;
  156. //                            String dictCode = code;
  157. //                            if (!StringUtils.isEmpty(table)) {
  158. //                                //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  159. //                                dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  160. //                                //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  161. //                            }
  162. //                            dataList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
  163. //                            this.listAddAllDeduplicate(dataList, Arrays.asList(value.split(",")));
  164. //                        }
  165. //                        //date类型默认转换string格式化日期
  166. //                        //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  167. //                        //if (JAVA_UTIL_DATE.equals(field.getType().getName())&&field.getAnnotation(JsonFormat.class)==null&&item.get(field.getName())!=null){
  168. //                            //SimpleDateFormat aDate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  169. //                            // item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
  170. //                        //}
  171. //                        //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  172. //                    }
  173. //                    items.add(item);
  174. //                }
  175. //
  176. //                //step.2 调用翻译方法，一次性翻译
  177. //                Map<String, List<DictModel>> translText = this.translateAllDict(dataListMap);
  178. //
  179. //                //step.3 将翻译结果填充到返回结果里
  180. //                for (JSONObject record : items) {
  181. //                    for (Field field : dictFieldList) {
  182. //                        String code = field.getAnnotation(Dict.class).dicCode();
  183. //                        String text = field.getAnnotation(Dict.class).dicText();
  184. //                        String table = field.getAnnotation(Dict.class).dictTable();
  185. //                        //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  186. //                        // 自定义的字典表数据源
  187. //                        String dataSource = field.getAnnotation(Dict.class).ds();
  188. //                        //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  189. //                        String fieldDictCode = code;
  190. //                        if (!StringUtils.isEmpty(table)) {
  191. //                            //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  192. //                            fieldDictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  193. //                            //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  194. //                        }
  195. //
  196. //                        String value = record.getString(field.getName());
  197. //                        if (oConvertUtils.isNotEmpty(value)) {
  198. //                            List<DictModel> dictModels = translText.get(fieldDictCode);
  199. //                            if(dictModels==null || dictModels.size()==0){
  200. //                                continue;
  201. //                            }
  202. //
  203. //                            String textValue = this.translDictText(dictModels, value);
  204. //                            log.debug(" 字典Val : " + textValue);
  205. //                            log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
  206. //
  207. //                            // TODO-sun 测试输出，待删
  208. //                            log.debug(" ---- dictCode: " + fieldDictCode);
  209. //                            log.debug(" ---- value: " + value);
  210. //                            log.debug(" ----- text: " + textValue);
  211. //                            log.debug(" ---- dictModels: " + JSON.toJSONString(dictModels));
  212. //
  213. //                            record.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  214. //                        }
  215. //                    }
  216. //                }
  217. //
  218. //                ((IPage) ((Result) result).getResult()).setRecords(items);
  219. //            }
  220. //
  221. //        }
  222. //        return result;
  223. //    }
  224.     private void parseDictText(Object result) {
  225.         if (result instanceof Result) {
  226.             List<Object> list = new LinkedList<>();
  227.             if (((Result) result).getResult() instanceof IPage) {
  228.                 //分页
  229.                 list = ((IPage) ((Result) result).getResult()).getRecords();
  230.             } else if (((Result) result).getResult() instanceof List) {
  231.                 //List集合
  232.                 list = (List<Object>) ((Result) result).getResult();
  233.             }else{
  234.                 //单对象
  235.                 Object record = ((Result) result).getResult();
  236.                 //判断能否转换成JSON，因为有些结果集返回的是String类型，导致翻译异常，因此判断是否可以转换json
  237.                 if(checkIsJsonStr(record)){
  238.                     //字典翻译
  239.                     record =  this.dictEscape(record);
  240.                 }
  241.                 ((Result) result).setResult(record);
  242.             }
  243.             if(list != null && list.size() > 0){
  244.                 List<Object> items = new ArrayList<>();
  245.                 for(Object record : list){
  246.                     if(checkIsJsonStr(record)){
  247.                         //字典翻译
  248.                         record =  this.dictEscape(record);
  249.                     }
  250.                     items.add(record);
  251.                 }
  252.                 if (((Result) result).getResult() instanceof IPage) {
  253.                     ((IPage) ((Result) result).getResult()).setRecords(items);
  254.                 } else if (((Result) result).getResult() instanceof List) {
  255.                     ((Result) result).setResult(items);
  256.                 }
  257.             }
  258.         }
  259.     }
  260.     /**
  261.      * 字典翻译
  262.      * @param record
  263.      * @return
  264.      */
  265.     private JSONObject dictEscape(Object record){
  266.         ObjectMapper mapper = new ObjectMapper();
  267.         String json = "{}";
  268.         JSONObject item = null;
  269.         try {
  270.             //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
  271.             json = mapper.writeValueAsString(record);//对象序列化为JSON字符串
  272.         } catch (JsonProcessingException e) {
  273.             log.error("json解析失败" + e.getMessage(), e);
  274.         }
  275.         try {
  276.             item = JSONObject.parseObject(json);
  277.             //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  278.             for (Field field : oConvertUtils.getAllFields(record)) {
  279.                 //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  280.                 if (field.getAnnotation(Dict.class) != null) {
  281.                     String code = field.getAnnotation(Dict.class).dicCode();
  282.                     String text = field.getAnnotation(Dict.class).dicText();
  283.                     String table = field.getAnnotation(Dict.class).dictTable();
  284.                     String key = String.valueOf(item.get(field.getName()));
  285.                     //翻译字典值对应的txt
  286.                     String textValue = key;
  287.                     //非中文时翻译
  288.                     if(!checkCountName(key)){
  289.                         textValue = translateDictValue(code, text, table, key);
  290.                     }
  291.                     log.debug(" 字典Val : " + textValue);
  292.                     log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
  293.                     item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  294.                 }
  295.                 //date类型默认转换string格式化日期
  296.                 if (field.getType().getName().equals("java.util.Date") && field.getAnnotation(JsonFormat.class) == null && item.get(field.getName()) != null) {
  297.                     SimpleDateFormat aDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  298.                     item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
  299.                 }
  300.             }
  301.         }catch (Exception e){
  302.             log.info("字典翻译异常："+e.getMessage(),e);
  303.         }
  304.         return item;
  305.     }
  307.     /**
  308.      * 检测是否是中文
  309.      * @param countName
  310.      * @return
  311.      */
  312.     public static boolean checkCountName(String countName){
  313.         Pattern p = Pattern.compile("[\u4e00-\u9fa5]");
  314.         Matcher m = p.matcher(countName);
  315.         if (m.find()) {
  316.             return true;
  317.         }
  318.         return false;
  319.     }
  321.     /**
  322.      * 检测是否可转换为JSON字符串
  323.      * @param record
  324.      * @return
  325.      */
  326.     public static boolean checkIsJsonStr(Object record){
  327.         boolean jsonFlag = false;
  328.         try {
  329.             String json = new ObjectMapper().writeValueAsString(record);
  330.             if(json.startsWith("{")) {
  331.                 jsonFlag = true;
  332.             }
  333.         } catch (JsonProcessingException e) {
  334.             e.printStackTrace();
  335.         }
  336.         return jsonFlag;
  337.     }
  339.     /**
  340.      * list 去重添加
  341.      */
  342.     private void listAddAllDeduplicate(List<String> dataList, List<String> addList) {
  343.         // 筛选出dataList中没有的数据
  344.         List<String> filterList = addList.stream().filter(i -> !dataList.contains(i)).collect(Collectors.toList());
  345.         dataList.addAll(filterList);
  346.     }
  348.     /**
  349.      * 一次性把所有的字典都翻译了
  350.      * 1.  所有的普通数据字典的所有数据只执行一次SQL
  351.      * 2.  表字典相同的所有数据只执行一次SQL
  352.      * @param dataListMap
  353.      * @return
  354.      */
  355.     private Map<String, List<DictModel>> translateAllDict(Map<String, List<String>> dataListMap) {
  356.         // 翻译后的字典文本，key=dictCode
  357.         Map<String, List<DictModel>> translText = new HashMap<>(5);
  358.         // 需要翻译的数据（有些可以从redis缓存中获取，就不走数据库查询）
  359.         List<String> needTranslData = new ArrayList<>();
  360.         //step.1 先通过redis中获取缓存字典数据
  361.         for (String dictCode : dataListMap.keySet()) {
  362.             List<String> dataList = dataListMap.get(dictCode);
  363.             if (dataList.size() == 0) {
  364.                 continue;
  365.             }
  366.             // 表字典需要翻译的数据
  367.             List<String> needTranslDataTable = new ArrayList<>();
  368.             for (String s : dataList) {
  369.                 String data = s.trim();
  370.                 if (data.length() == 0) {
  371.                     continue; //跳过循环
  372.                 }
  373.                 if (dictCode.contains(",")) {
  374.                     String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, data);
  375.                     if (redisTemplate.hasKey(keyString)) {
  376.                         try {
  377.                             String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  378.                             List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  379.                             list.add(new DictModel(data, text));
  380.                         } catch (Exception e) {
  381.                             log.warn(e.getMessage());
  382.                         }
  383.                     } else if (!needTranslDataTable.contains(data)) {
  384.                         // 去重添加
  385.                         needTranslDataTable.add(data);
  386.                     }
  387.                 } else {
  388.                     String keyString = String.format("sys:cache:dict::%s:%s", dictCode, data);
  389.                     if (redisTemplate.hasKey(keyString)) {
  390.                         try {
  391.                             String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  392.                             List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  393.                             list.add(new DictModel(data, text));
  394.                         } catch (Exception e) {
  395.                             log.warn(e.getMessage());
  396.                         }
  397.                     } else if (!needTranslData.contains(data)) {
  398.                         // 去重添加
  399.                         needTranslData.add(data);
  400.                     }
  401.                 }
  403.             }
  404.             //step.2 调用数据库翻译表字典
  405.             if (needTranslDataTable.size() > 0) {
  406.                 String[] arr = dictCode.split(",");
  407.                 String table = arr[0], text = arr[1], code = arr[2];
  408.                 String values = String.join(",", needTranslDataTable);
  409.                 //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  410.                 // 自定义的数据源
  411.                 String dataSource = null;
  412.                 if (arr.length > 3) {
  413.                     dataSource = arr[3];
  414.                 }
  415.                 //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  416.                 log.debug("translateDictFromTableByKeys.dictCode:" + dictCode);
  417.                 log.debug("translateDictFromTableByKeys.values:" + values);
  418.                 //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  420.                 //update-begin---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
  421.                 if(null == dataSource){
  422.                     dataSource = "";
  423.                 }
  424.                 //update-end---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
  426.                 List<DictModel> texts = commonApi.translateDictFromTableByKeys(table, text, code, values, dataSource);
  427.                 //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  428.                 log.debug("translateDictFromTableByKeys.result:" + texts);
  429.                 List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  430.                 list.addAll(texts);
  432.                 // 做 redis 缓存
  433.                 for (DictModel dict : texts) {
  434.                     String redisKey = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, dict.getValue());
  435.                     try {
  436.                         // update-begin-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
  437.                         // 保留5分钟
  438.                         redisTemplate.opsForValue().set(redisKey, dict.getText(), 300, TimeUnit.SECONDS);
  439.                         // update-end-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
  440.                     } catch (Exception e) {
  441.                         log.warn(e.getMessage(), e);
  442.                     }
  443.                 }
  444.             }
  445.         }
  447.         //step.3 调用数据库进行翻译普通字典
  448.         if (needTranslData.size() > 0) {
  449.             List<String> dictCodeList = Arrays.asList(dataListMap.keySet().toArray(new String[]{}));
  450.             // 将不包含逗号的字典code筛选出来，因为带逗号的是表字典，而不是普通的数据字典
  451.             List<String> filterDictCodes = dictCodeList.stream().filter(key -> !key.contains(",")).collect(Collectors.toList());
  452.             String dictCodes = String.join(",", filterDictCodes);
  453.             String values = String.join(",", needTranslData);
  454.             log.debug("translateManyDict.dictCodes:" + dictCodes);
  455.             log.debug("translateManyDict.values:" + values);
  456.             Map<String, List<DictModel>> manyDict = commonApi.translateManyDict(dictCodes, values);
  457.             log.debug("translateManyDict.result:" + manyDict);
  458.             for (String dictCode : manyDict.keySet()) {
  459.                 List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  460.                 List<DictModel> newList = manyDict.get(dictCode);
  461.                 list.addAll(newList);
  463.                 // 做 redis 缓存
  464.                 for (DictModel dict : newList) {
  465.                     String redisKey = String.format("sys:cache:dict::%s:%s", dictCode, dict.getValue());
  466.                     try {
  467.                         redisTemplate.opsForValue().set(redisKey, dict.getText());
  468.                     } catch (Exception e) {
  469.                         log.warn(e.getMessage(), e);
  470.                     }
  471.                 }
  472.             }
  473.         }
  474.         return translText;
  475.     }
  477.     /**
  478.      * 字典值替换文本
  479.      *
  480.      * @param dictModels
  481.      * @param values
  482.      * @return
  483.      */
  484.     private String translDictText(List<DictModel> dictModels, String values) {
  485.         List<String> result = new ArrayList<>();
  487.         // 允许多个逗号分隔，允许传数组对象
  488.         String[] splitVal = values.split(",");
  489.         for (String val : splitVal) {
  490.             String dictText = val;
  491.             for (DictModel dict : dictModels) {
  492.                 if (val.equals(dict.getValue())) {
  493.                     dictText = dict.getText();
  494.                     break;
  495.                 }
  496.             }
  497.             result.add(dictText);
  498.         }
  499.         return String.join(",", result);
  500.     }
  502.     /**
  503.      *  翻译字典文本
  504.      * @param code
  505.      * @param text
  506.      * @param table
  507.      * @param key
  508.      * @return
  509.      */
  510.     @Deprecated
  511.     private String translateDictValue(String code, String text, String table, String key) {
  512.         if(oConvertUtils.isEmpty(key)) {
  513.             return null;
  514.         }
  515.         StringBuffer textValue=new StringBuffer();
  516.         String[] keys = key.split(",");
  517.         for (String k : keys) {
  518.             String tmpValue = null;
  519.             log.debug(" 字典 key : "+ k);
  520.             if (k.trim().length() == 0) {
  521.                 continue; //跳过循环
  522.             }
  523.             //update-begin--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
  524.             if (!StringUtils.isEmpty(table)){
  525.                 log.debug("--DictAspect------dicTable="+ table+" ,dicText= "+text+" ,dicCode="+code);
  526.                 String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s,%s,%s]",table,text,code,k.trim());
  527.                     if (redisTemplate.hasKey(keyString)){
  528.                     try {
  529.                         tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  530.                     } catch (Exception e) {
  531.                         log.warn(e.getMessage());
  532.                     }
  533.                 }else {
  534.                     tmpValue= commonApi.translateDictFromTable(table,text,code,k.trim());
  535.                 }
  536.             }else {
  537.                 String keyString = String.format("sys:cache:dict::%s:%s",code,k.trim());
  538.                 if (redisTemplate.hasKey(keyString)){
  539.                     try {
  540.                         tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  541.                     } catch (Exception e) {
  542.                        log.warn(e.getMessage());
  543.                     }
  544.                 }else {
  545.                     tmpValue = commonApi.translateDict(code, k.trim());
  546.                 }
  547.             }
  548.             //update-end--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
  550.             if (tmpValue != null) {
  551.                 if (!"".equals(textValue.toString())) {
  552.                     textValue.append(",");
  553.                 }
  554.                 textValue.append(tmpValue);
  555.             }
  557.         }
  558.         return textValue.toString();
  559.     }
  561.     /**
  562.      * 检测返回结果集中是否包含Dict注解
  563.      * @param records
  564.      * @return
  565.      */
  566.     private Boolean checkHasDict(List<Object> records){
  567.         if(oConvertUtils.isNotEmpty(records) && records.size()>0){
  568.             for (Field field : oConvertUtils.getAllFields(records.get(0))) {
  569.                 if (oConvertUtils.isNotEmpty(field.getAnnotation(Dict.class))) {
  570.                     return true;
  571.                 }
  572.             }
  573.         }
  574.         return false;
  575.     }
  577. }

八、涉及分布式的整体修改

  1. package org.jeecg.common.aspect;
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.alibaba.fastjson.parser.Feature;
  5. import com.baomidou.mybatisplus.core.metadata.IPage;
  6. import com.fasterxml.jackson.core.JsonProcessingException;
  7. import com.fasterxml.jackson.databind.ObjectMapper;
  8. import lombok.extern.slf4j.Slf4j;
  9. import org.aspectj.lang.ProceedingJoinPoint;
  10. import org.aspectj.lang.annotation.Around;
  11. import org.aspectj.lang.annotation.Aspect;
  12. import org.aspectj.lang.annotation.Pointcut;
  13. import org.jeecg.common.api.CommonAPI;
  14. import org.jeecg.common.api.vo.Result;
  15. import org.jeecg.common.aspect.annotation.Dict;
  16. import org.jeecg.common.constant.CommonConstant;
  17. import org.jeecg.common.system.vo.DictModel;
  18. import org.jeecg.common.util.oConvertUtils;
  19. import org.springframework.beans.factory.annotation.Autowired;
  20. import org.springframework.context.annotation.Lazy;
  21. import org.springframework.data.redis.core.RedisTemplate;
  22. import org.springframework.stereotype.Component;
  23. import org.springframework.util.StringUtils;
  25. import java.lang.reflect.Field;
  26. import java.lang.reflect.Method;
  27. import java.time.LocalDate;
  28. import java.time.LocalDateTime;
  29. import java.util.*;
  30. import java.util.concurrent.TimeUnit;
  31. import java.util.stream.Collectors;
  33. /**
  34.  * @Description: 字典aop类
  35.  * @Author: dangzhenghui
  36.  * @Date: 2019-3-17 21:50
  37.  * @Version: 1.0
  38.  */
  39. @Aspect
  40. @Component
  41. @Slf4j
  42. public class DictAspect {
  43.     @Lazy
  44.     @Autowired
  45.     private CommonAPI commonApi;
  46.     @Autowired
  47.     public RedisTemplate redisTemplate;
  49.     @Autowired
  50.     private ObjectMapper objectMapper;
  52.     private static final String JAVA_UTIL_DATE = "java.util.Date";
  54.     /**
  55.      * 定义切点Pointcut
  56.      */
  57.     @Pointcut("(@within(org.springframework.web.bind.annotation.RestController) || " +
  58.             "@within(org.springframework.stereotype.Controller) || @annotation(org.jeecg.common.aspect.annotation.AutoDict)) " +
  59.             "&& execution(public org.jeecg.common.api.vo.Result org.jeecg..*.*(..))")
  60.     public void excudeService() {
  61.     }
  63.     @Around("excudeService()")
  64.     public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
  65.         long time1=System.currentTimeMillis();
  66.         Object result = pjp.proceed();
  67.         long time2=System.currentTimeMillis();
  68.         log.debug("获取JSON数据 耗时："+(time2-time1)+"ms");
  69.         long start=System.currentTimeMillis();
  70.         result=this.parseDictText(result);
  71.         long end=System.currentTimeMillis();
  72.         log.debug("注入字典到JSON数据  耗时"+(end-start)+"ms");
  73.         return result;
  74.     }
  76.     /**
  77.      * 本方法针对返回对象为Result 的IPage的分页列表数据进行动态字典注入
  78.      * 字典注入实现 通过对实体类添加注解@dict 来标识需要的字典内容,字典分为单字典code即可 ，table字典 code table text配合使用与原来jeecg的用法相同
  79.      * 示例为SysUser   字段为sex 添加了注解@Dict(dicCode = "sex") 会在字典服务立马查出来对应的text 然后在请求list的时候将这个字典text，已字段名称加_dictText形式返回到前端
  80.      * 例输入当前返回值的就会多出一个sex_dictText字段
  81.      * {
  82.      *      sex:1,
  83.      *      sex_dictText:"男"
  84.      * }
  85.      * 前端直接取值sext_dictText在table里面无需再进行前端的字典转换了
  86.      *  customRender:function (text) {
  87.      *               if(text==1){
  88.      *                 return "男";
  89.      *               }else if(text==2){
  90.      *                 return "女";
  91.      *               }else{
  92.      *                 return text;
  93.      *               }
  94.      *             }
  95.      *             目前vue是这么进行字典渲染到table上的多了就很麻烦了 这个直接在服务端渲染完成前端可以直接用
  96.      * @param result
  97.      */
  98.     /*private Object parseDictText(Object result) {
  99.         //if (result instanceof Result) {
  100.         if (true) {
  101.             if (((Result) result).getResult() instanceof IPage) {
  102.                 List<JSONObject> items = new ArrayList<>();
  104.                 //step.1 筛选出加了 Dict 注解的字段列表
  105.                 List<Field> dictFieldList = new ArrayList<>();
  106.                 // 字典数据列表， key = 字典code，value=数据列表
  107.                 Map<String, List<String>> dataListMap = new HashMap<>(5);
  108.                 //取出结果集
  109.                 List<Object> records=((IPage) ((Result) result).getResult()).getRecords();
  110.                 //update-begin--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
  111.                 Boolean hasDict= checkHasDict(records);
  112.                 if(!hasDict){
  113.                     return result;
  114.                 }
  116.                 log.debug(" __ 进入字典翻译切面 DictAspect —— " );
  117.                 //update-end--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
  118.                 for (Object record : records) {
  119.                     String json="{}";
  120.                     try {
  121.                         //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  122.                         //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
  123.                          json = objectMapper.writeValueAsString(record);
  124.                         //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  125.                     } catch (JsonProcessingException e) {
  126.                         log.error("json解析失败"+e.getMessage(),e);
  127.                     }
  128.                     //update-begin--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
  129.                     JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
  130.                     //update-end--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
  132.                     //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  133.                     //for (Field field : record.getClass().getDeclaredFields()) {
  134.                     // 遍历所有字段，把字典Code取出来，放到 map 里
  135.                     for (Field field : oConvertUtils.getAllFields(record)) {
  136.                         String value = item.getString(field.getName());
  137.                         if (oConvertUtils.isEmpty(value)) {
  138.                             continue;
  139.                         }
  140.                     //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
  141.                         if (field.getAnnotation(Dict.class) != null) {
  142.                             if (!dictFieldList.contains(field)) {
  143.                                 dictFieldList.add(field);
  144.                             }
  145.                             String code = field.getAnnotation(Dict.class).dicCode();
  146.                             String text = field.getAnnotation(Dict.class).dicText();
  147.                             String table = field.getAnnotation(Dict.class).dictTable();
  148.                             //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  149.                             String dataSource = field.getAnnotation(Dict.class).ds();
  150.                             //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  151.                             List<String> dataList;
  152.                             String dictCode = code;
  153.                             if (!StringUtils.isEmpty(table)) {
  154.                                 //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  155.                                 dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  156.                                 //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  157.                             }
  158.                             dataList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
  159.                             this.listAddAllDeduplicate(dataList, Arrays.asList(value.split(",")));
  160.                         }
  161.                         //date类型默认转换string格式化日期
  162.                         //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  163.                         //if (JAVA_UTIL_DATE.equals(field.getType().getName())&&field.getAnnotation(JsonFormat.class)==null&&item.get(field.getName())!=null){
  164.                             //SimpleDateFormat aDate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  165.                             // item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
  166.                         //}
  167.                         //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
  168.                     }
  169.                     items.add(item);
  170.                 }
  172.                 //step.2 调用翻译方法，一次性翻译
  173.                 Map<String, List<DictModel>> translText = this.translateAllDict(dataListMap);
  175.                 //step.3 将翻译结果填充到返回结果里
  176.                 for (JSONObject record : items) {
  177.                     for (Field field : dictFieldList) {
  178.                         String code = field.getAnnotation(Dict.class).dicCode();
  179.                         String text = field.getAnnotation(Dict.class).dicText();
  180.                         String table = field.getAnnotation(Dict.class).dictTable();
  181.                         //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  182.                         // 自定义的字典表数据源
  183.                         String dataSource = field.getAnnotation(Dict.class).ds();
  184.                         //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  185.                         String fieldDictCode = code;
  186.                         if (!StringUtils.isEmpty(table)) {
  187.                             //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  188.                             fieldDictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  189.                             //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  190.                         }
  192.                         String value = record.getString(field.getName());
  193.                         if (oConvertUtils.isNotEmpty(value)) {
  194.                             List<DictModel> dictModels = translText.get(fieldDictCode);
  195.                             if(dictModels==null || dictModels.size()==0){
  196.                                 continue;
  197.                             }
  199.                             String textValue = this.translDictText(dictModels, value);
  200.                             log.debug(" 字典Val : " + textValue);
  201.                             log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
  203.                             // TODO-sun 测试输出，待删
  204.                             log.debug(" ---- dictCode: " + fieldDictCode);
  205.                             log.debug(" ---- value: " + value);
  206.                             log.debug(" ----- text: " + textValue);
  207.                             log.debug(" ---- dictModels: " + JSON.toJSONString(dictModels));
  209.                             record.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  210.                         }
  211.                     }
  212.                 }
  214.                 ((IPage) ((Result) result).getResult()).setRecords(items);
  215.             }
  217.         }
  218.         return result;
  219.     }*/
  222.     private Object parseDictText(Object result) {
  223.         if (result instanceof Result) {
  224.             Result<?> resultObj = (Result<?>) result;
  225.             Object data = resultObj.getResult();
  227.             // 处理IPage类型
  228.             if (data instanceof IPage) {
  229.                 handleIPage((IPage<?>) data);
  230.             }
  231.             // 新增：处理List类型
  232.             else if (data instanceof List) {
  233.                 handleList((List<?>) data, resultObj);
  234.             }
  235.             // 新增：处理单个对象类型
  236.             else if (data != null) {
  237.                 handleObject(data, resultObj);
  238.             }
  239.         }
  240.         return result;
  241.     }
  243.     // 判断是否为简单类型（无需字典处理的类型）
  244.     private boolean isSimpleType(Class<?> clazz) {
  245.         return clazz.isPrimitive()
  246.                 || clazz == String.class
  247.                 || Number.class.isAssignableFrom(clazz)
  248.                 || clazz == Boolean.class
  249.                 || clazz == Date.class
  250.                 || clazz == LocalDate.class
  251.                 || clazz == LocalDateTime.class;
  252.     }
  255.     private void handleObject(Object data, Result<?> resultObj) {
  256.         if (data == null) {
  257.             return;
  258.         }
  260.         // 新增：判断是否为简单类型（非对象/非集合），直接跳过
  261.         if (isSimpleType(data.getClass())) {
  262.             log.debug("跳过简单类型[{}]的字典处理", data.getClass().getSimpleName());
  263.             return;
  264.         }
  266.         if (data instanceof String) {
  267.             log.debug("跳过字符串类型结果的字典处理，内容：{}", data.toString().length() > 100 ? data.toString().substring(0, 100) + "..." : data);
  268.             return;
  269.         }
  271.         // 转换对象为JSONObject进行处理
  272.         JSONObject jsonObject;
  274.         try {
  275.             String jsonStr = objectMapper.writeValueAsString(data);
  276.             log.info("jsonStr:"+jsonStr);
  277.             // 移除JSON中的控制字符（可选，进一步避免解析错误）
  278.             jsonStr = jsonStr.replaceAll("[\\x00-\\x1F\\x7F]", "");
  279.             jsonObject = JSONObject.parseObject(jsonStr, Feature.OrderedField);
  280.         } catch (JsonProcessingException e) {
  281.             log.error("对象转JSON失败，跳过字典处理", e);
  282.             return; // 解析失败时直接返回原始对象，不进行字典处理
  283.         }
  285.         // 处理对象中的字典字段
  286.         List<Field> dictFieldList = new ArrayList<>();
  287.         Map<String, List<String>> dataListMap = new HashMap<>(5);
  289.         // 收集对象中所有需要翻译的字典字段
  290.         for (Field field : oConvertUtils.getAllFields(data)) {
  291.             String fieldValue = jsonObject.getString(field.getName());
  292.             if (oConvertUtils.isEmpty(fieldValue)) {
  293.                 continue;
  294.             }
  296.             Dict dictAnnotation = field.getAnnotation(Dict.class);
  297.             if (dictAnnotation != null) {
  298.                 dictFieldList.add(field);
  300.                 // 构建字典code
  301.                 String code = dictAnnotation.dicCode();
  302.                 String text = dictAnnotation.dicText();
  303.                 String table = dictAnnotation.dictTable();
  304.                 String dataSource = dictAnnotation.ds();
  305.                 String dictCode = code;
  306.                 if (!StringUtils.isEmpty(table)) {
  307.                     dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  308.                 }
  310.                 // 收集需要翻译的值
  311.                 List<String> valueList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
  312.                 listAddAllDeduplicate(valueList, Arrays.asList(fieldValue.split(",")));
  313.             }
  314.         }
  316.         // 如果没有字典字段，直接返回
  317.         if (dictFieldList.isEmpty()) {
  318.             return;
  319.         }
  321.         // 批量查询字典值
  322.         Map<String, List<DictModel>> translText = translateAllDict(dataListMap);
  324.         // 将字典文本填充到JSONObject
  325.         for (Field field : dictFieldList) {
  326.             Dict dictAnnotation = field.getAnnotation(Dict.class);
  327.             String code = dictAnnotation.dicCode();
  328.             String text = dictAnnotation.dicText();
  329.             String table = dictAnnotation.dictTable();
  330.             String dataSource = dictAnnotation.ds();
  331.             String dictCode = code;
  332.             if (!StringUtils.isEmpty(table)) {
  333.                 dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  334.             }
  336.             String fieldValue = jsonObject.getString(field.getName());
  337.             if (oConvertUtils.isEmpty(fieldValue)) {
  338.                 continue;
  339.             }
  341.             List<DictModel> dictModels = translText.get(dictCode);
  342.             if (dictModels == null || dictModels.isEmpty()) {
  343.                 continue;
  344.             }
  346.             String textValue = translDictText(dictModels, fieldValue);
  347.             jsonObject.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  348.         }
  350.         // 将处理后的JSONObject转换回原始对象类型
  351.         Object processedObject = convertToOriginalType(jsonObject, data.getClass());
  353.         // 使用反射设置结果
  354.         try {
  355.             Method setResultMethod = resultObj.getClass().getMethod("setResult", Object.class);
  356.             setResultMethod.invoke(resultObj, processedObject);
  357.         } catch (Exception e) {
  358.             log.error("设置结果失败", e);
  359.         }
  360.     }
  363.     /**
  364.      * 将JSONObject转换为原始对象类型
  365.      */
  366.     private Object convertToOriginalType(JSONObject jsonObject, Class<?> originalType) {
  367.         try {
  368.             return objectMapper.treeToValue(objectMapper.readTree(jsonObject.toJSONString()), originalType);
  369.         } catch (JsonProcessingException e) {
  370.             log.error("转换回原始类型失败", e);
  371.             return jsonObject; // 转换失败时返回JSONObject
  372.         }
  373.     }
  379.     /**
  380.      * 处理记录列表（支持IPage的records和普通List）
  381.      */
  382.     private List<JSONObject> processRecords(List<?> records) {
  383.         // 步骤1：检查是否包含@Dict注解字段，无则直接返回
  384.         Boolean hasDict = checkHasDict(records);
  385.         if (!hasDict) {
  386.             return records.stream()
  387.                     .map(record -> {
  388.                         try {
  389. //                            return JSONObject.parseObject(objectMapper.writeValueAsString(record), Feature.OrderedField);
  390.                             String jsonStr;
  391.                             // 对字符串类型直接处理，避免额外引号
  392.                             if (record instanceof String) {
  393.                                 String str = (String) record;
  394.                                 // 移除控制字符
  395.                                 str = str.replaceAll("[\\x00-\\x1F\\x7F]", "");
  396.                                 // 包装为JSON对象（键为"value"，值为处理后的字符串）
  397.                                 JSONObject json = new JSONObject();
  398.                                 json.put("value", str);
  399.                                 return json;
  400.                             } else {
  401.                                 // 非字符串类型正常转换并移除控制字符
  402.                                 jsonStr = objectMapper.writeValueAsString(record);
  403.                                 jsonStr = jsonStr.replaceAll("[\\x00-\\x1F\\x7F]", "");
  404.                                 return JSONObject.parseObject(jsonStr, Feature.OrderedField);
  405.                             }
  406.                         } catch (JsonProcessingException e) {
  407.                             log.error("对象转JSON失败", e);
  408.                             return new JSONObject();
  409.                         }
  410.                     })
  411.                     .collect(Collectors.toList());
  412.         }
  414.         log.debug("__ 进入字典翻译切面（处理List/IPage） __");
  416.         // 步骤2：收集需要翻译的字典信息
  417.         List<JSONObject> items = new ArrayList<>();
  418.         List<Field> dictFieldList = new ArrayList<>(); // 含@Dict注解的字段
  419.         Map<String, List<String>> dataListMap = new HashMap<>(5); // key：字典code，value：需要翻译的字段值列表
  421.         for (Object record : records) {
  422.             // 将对象转为有序JSONObject（保持字段顺序）
  423.             String json;
  424.             try {
  425.                 json = objectMapper.writeValueAsString(record);
  426.             } catch (JsonProcessingException e) {
  427.                 log.error("json解析失败", e);
  428.                 continue;
  429.             }
  430.             JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
  432.             // 遍历所有字段（含父类字段），收集字典信息
  433.             for (Field field : oConvertUtils.getAllFields(record)) {
  434.                 String fieldValue = item.getString(field.getName());
  435.                 if (oConvertUtils.isEmpty(fieldValue)) {
  436.                     continue;
  437.                 }
  439.                 Dict dictAnnotation = field.getAnnotation(Dict.class);
  440.                 if (dictAnnotation != null) {
  441.                     // 收集含@Dict注解的字段
  442.                     if (!dictFieldList.contains(field)) {
  443.                         dictFieldList.add(field);
  444.                     }
  446.                     // 构建字典code（区分普通字典和表字典）
  447.                     String code = dictAnnotation.dicCode();
  448.                     String text = dictAnnotation.dicText();
  449.                     String table = dictAnnotation.dictTable();
  450.                     String dataSource = dictAnnotation.ds(); // 数据源（分布式场景）
  451.                     String dictCode = code;
  452.                     if (!StringUtils.isEmpty(table)) {
  453.                         dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  454.                     }
  456.                     // 收集该字典code对应的所有需要翻译的值（去重）
  457.                     List<String> valueList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
  458.                     List<String> splitValues = Arrays.stream(fieldValue.split(","))
  459.                             .map(String::trim)
  460.                             .filter(v -> !v.isEmpty())
  461.                             .collect(Collectors.toList());
  462.                     listAddAllDeduplicate(valueList, splitValues);
  463.                 }
  464.             }
  465.             items.add(item);
  466.         }
  468.         // 步骤3：批量查询所有字典值（复用现有逻辑）
  469.         Map<String, List<DictModel>> translText = translateAllDict(dataListMap);
  471.         // 步骤4：将字典文本填充到结果中（添加xxx_dictText字段）
  472.         for (JSONObject item : items) {
  473.             for (Field field : dictFieldList) {
  474.                 Dict dictAnnotation = field.getAnnotation(Dict.class);
  475.                 String code = dictAnnotation.dicCode();
  476.                 String text = dictAnnotation.dicText();
  477.                 String table = dictAnnotation.dictTable();
  478.                 String dataSource = dictAnnotation.ds();
  479.                 String dictCode = code;
  480.                 if (!StringUtils.isEmpty(table)) {
  481.                     dictCode = String.format("%s,%s,%s,%s", table, text, code, dataSource);
  482.                 }
  484.                 String fieldValue = item.getString(field.getName());
  485.                 if (oConvertUtils.isEmpty(fieldValue)) {
  486.                     continue;
  487.                 }
  489.                 // 从翻译结果中获取文本
  490.                 List<DictModel> dictModels = translText.get(dictCode);
  491.                 if (dictModels == null || dictModels.isEmpty()) {
  492.                     continue;
  493.                 }
  494.                 String textValue = translDictText(dictModels, fieldValue);
  496.                 // 添加xxx_dictText字段
  497.                 item.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
  498.             }
  499.         }
  501.         return items;
  502.     }
  505.     /**
  506.      * 处理IPage类型结果
  507.      */
  508.     /**
  509.      * 处理IPage类型结果
  510.      */
  511.     private void handleIPage(IPage<?> page) {
  512.         List<?> records = page.getRecords();
  513.         if (oConvertUtils.isEmpty(records)) {
  514.             return;
  515.         }
  517.         // 处理记录并获取JSONObject列表
  518.         List<JSONObject> processedRecords = processRecords(records);
  520.         // 如果列表不为空，尝试转换回原始类型
  521.         if (!processedRecords.isEmpty() && records.size() > 0) {
  522.             Class<?> originalType = records.get(0).getClass();
  523.             List<Object> convertedRecords = processedRecords.stream()
  524.                     .map(json -> {
  525.                         try {
  526.                             // 将JSONObject转换回原始对象类型
  527.                             return objectMapper.treeToValue(objectMapper.readTree(json.toJSONString()), originalType);
  528.                         } catch (JsonProcessingException e) {
  529.                             log.error("转换JSONObject回原始类型失败", e);
  530.                             return json; // 转换失败时保留JSONObject
  531.                         }
  532.                     })
  533.                     .collect(Collectors.toList());
  535.             // 使用反射调用setRecords方法（绕过泛型检查）
  536.             try {
  537.                 Method setRecordsMethod = page.getClass().getMethod("setRecords", List.class);
  538.                 setRecordsMethod.invoke(page, processedRecords);
  539.             } catch (Exception e) {
  540.                 log.error("调用setRecords方法失败", e);
  541.             }
  542.         }
  543.     }
  545.     /**
  546.      * 处理List类型结果
  547.      */
  548.     private void handleList(List<?> records, Result<?> resultObj) {
  549.         if (oConvertUtils.isEmpty(records)) {
  550.             return;
  551.         }
  553.         // 转换为List<Object>（避免泛型问题）
  554.         List<Object> recordList = records.stream().map(r -> (Object) r).collect(Collectors.toList());
  555.         List<JSONObject> processedRecords = processRecords(recordList);
  557.         // 使用反射设置结果，绕过泛型检查
  558.         try {
  559.             Method setResultMethod = resultObj.getClass().getMethod("setResult", Object.class);
  560.             setResultMethod.invoke(resultObj, processedRecords);
  561.         } catch (Exception e) {
  562.             log.error("设置结果失败", e);
  563.         }
  564.     }
  567.     /**
  568.      * list 去重添加
  569.      */
  570.     private void listAddAllDeduplicate(List<String> dataList, List<String> addList) {
  571.         // 筛选出dataList中没有的数据
  572.         List<String> filterList = addList.stream().filter(i -> !dataList.contains(i)).collect(Collectors.toList());
  573.         dataList.addAll(filterList);
  574.     }
  576.     /**
  577.      * 一次性把所有的字典都翻译了
  578.      * 1.  所有的普通数据字典的所有数据只执行一次SQL
  579.      * 2.  表字典相同的所有数据只执行一次SQL
  580.      * @param dataListMap
  581.      * @return
  582.      */
  583.     private Map<String, List<DictModel>> translateAllDict(Map<String, List<String>> dataListMap) {
  584.         // 翻译后的字典文本，key=dictCode
  585.         Map<String, List<DictModel>> translText = new HashMap<>(5);
  586.         // 需要翻译的数据（有些可以从redis缓存中获取，就不走数据库查询）
  587.         List<String> needTranslData = new ArrayList<>();
  588.         //step.1 先通过redis中获取缓存字典数据
  589.         for (String dictCode : dataListMap.keySet()) {
  590.             List<String> dataList = dataListMap.get(dictCode);
  591.             if (dataList.size() == 0) {
  592.                 continue;
  593.             }
  594.             // 表字典需要翻译的数据
  595.             List<String> needTranslDataTable = new ArrayList<>();
  596.             for (String s : dataList) {
  597.                 String data = s.trim();
  598.                 if (data.length() == 0) {
  599.                     continue; //跳过循环
  600.                 }
  601.                 if (dictCode.contains(",")) {
  602.                     String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, data);
  603.                     if (redisTemplate.hasKey(keyString)) {
  604.                         try {
  605.                             String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  606.                             List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  607.                             list.add(new DictModel(data, text));
  608.                         } catch (Exception e) {
  609.                             log.warn(e.getMessage());
  610.                         }
  611.                     } else if (!needTranslDataTable.contains(data)) {
  612.                         // 去重添加
  613.                         needTranslDataTable.add(data);
  614.                     }
  615.                 } else {
  616.                     String keyString = String.format("sys:cache:dict::%s:%s", dictCode, data);
  617.                     if (redisTemplate.hasKey(keyString)) {
  618.                         try {
  619.                             String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  620.                             List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  621.                             list.add(new DictModel(data, text));
  622.                         } catch (Exception e) {
  623.                             log.warn(e.getMessage());
  624.                         }
  625.                     } else if (!needTranslData.contains(data)) {
  626.                         // 去重添加
  627.                         needTranslData.add(data);
  628.                     }
  629.                 }
  631.             }
  632.             //step.2 调用数据库翻译表字典
  633.             if (needTranslDataTable.size() > 0) {
  634.                 String[] arr = dictCode.split(",");
  635.                 String table = arr[0], text = arr[1], code = arr[2];
  636.                 String values = String.join(",", needTranslDataTable);
  637.                 //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  638.                 // 自定义的数据源
  639.                 String dataSource = null;
  640.                 if (arr.length > 3) {
  641.                     dataSource = arr[3];
  642.                 }
  643.                 //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  644.                 log.debug("translateDictFromTableByKeys.dictCode:" + dictCode);
  645.                 log.debug("translateDictFromTableByKeys.values:" + values);
  646.                 //update-begin---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  648.                 //update-begin---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
  649.                 if(null == dataSource){
  650.                     dataSource = "";
  651.                 }
  652.                 //update-end---author:wangshuai---date:2024-01-09---for:微服务下为空报错没有参数需要传递空字符串---
  654.                 List<DictModel> texts = commonApi.translateDictFromTableByKeys(table, text, code, values, dataSource);
  655.                 //update-end---author:chenrui ---date:20231221  for：[issues/#5643]解决分布式下表字典跨库无法查询问题------------
  656.                 log.debug("translateDictFromTableByKeys.result:" + texts);
  657.                 List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  658.                 list.addAll(texts);
  660.                 // 做 redis 缓存
  661.                 for (DictModel dict : texts) {
  662.                     String redisKey = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, dict.getValue());
  663.                     try {
  664.                         // update-begin-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
  665.                         // 保留5分钟
  666.                         redisTemplate.opsForValue().set(redisKey, dict.getText(), 300, TimeUnit.SECONDS);
  667.                         // update-end-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
  668.                     } catch (Exception e) {
  669.                         log.warn(e.getMessage(), e);
  670.                     }
  671.                 }
  672.             }
  673.         }
  675.         //step.3 调用数据库进行翻译普通字典
  676.         if (needTranslData.size() > 0) {
  677.             List<String> dictCodeList = Arrays.asList(dataListMap.keySet().toArray(new String[]{}));
  678.             // 将不包含逗号的字典code筛选出来，因为带逗号的是表字典，而不是普通的数据字典
  679.             List<String> filterDictCodes = dictCodeList.stream().filter(key -> !key.contains(",")).collect(Collectors.toList());
  680.             String dictCodes = String.join(",", filterDictCodes);
  681.             String values = String.join(",", needTranslData);
  682.             log.debug("translateManyDict.dictCodes:" + dictCodes);
  683.             log.debug("translateManyDict.values:" + values);
  684.             Map<String, List<DictModel>> manyDict = commonApi.translateManyDict(dictCodes, values);
  685.             log.debug("translateManyDict.result:" + manyDict);
  686.             for (String dictCode : manyDict.keySet()) {
  687.                 List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
  688.                 List<DictModel> newList = manyDict.get(dictCode);
  689.                 list.addAll(newList);
  691.                 // 做 redis 缓存
  692.                 for (DictModel dict : newList) {
  693.                     String redisKey = String.format("sys:cache:dict::%s:%s", dictCode, dict.getValue());
  694.                     try {
  695.                         redisTemplate.opsForValue().set(redisKey, dict.getText());
  696.                     } catch (Exception e) {
  697.                         log.warn(e.getMessage(), e);
  698.                     }
  699.                 }
  700.             }
  701.         }
  702.         return translText;
  703.     }
  705.     /**
  706.      * 字典值替换文本
  707.      *
  708.      * @param dictModels
  709.      * @param values
  710.      * @return
  711.      */
  712.     private String translDictText(List<DictModel> dictModels, String values) {
  713.         List<String> result = new ArrayList<>();
  715.         // 允许多个逗号分隔，允许传数组对象
  716.         String[] splitVal = values.split(",");
  717.         for (String val : splitVal) {
  718.             String dictText = val;
  719.             for (DictModel dict : dictModels) {
  720.                 if (val.equals(dict.getValue())) {
  721.                     dictText = dict.getText();
  722.                     break;
  723.                 }
  724.             }
  725.             result.add(dictText);
  726.         }
  727.         return String.join(",", result);
  728.     }
  730.     /**
  731.      *  翻译字典文本
  732.      * @param code
  733.      * @param text
  734.      * @param table
  735.      * @param key
  736.      * @return
  737.      */
  738.     @Deprecated
  739.     private String translateDictValue(String code, String text, String table, String key) {
  740.         if(oConvertUtils.isEmpty(key)) {
  741.             return null;
  742.         }
  743.         StringBuffer textValue=new StringBuffer();
  744.         String[] keys = key.split(",");
  745.         for (String k : keys) {
  746.             String tmpValue = null;
  747.             log.debug(" 字典 key : "+ k);
  748.             if (k.trim().length() == 0) {
  749.                 continue; //跳过循环
  750.             }
  751.             //update-begin--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
  752.             if (!StringUtils.isEmpty(table)){
  753.                 log.debug("--DictAspect------dicTable="+ table+" ,dicText= "+text+" ,dicCode="+code);
  754.                 String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s,%s,%s]",table,text,code,k.trim());
  755.                     if (redisTemplate.hasKey(keyString)){
  756.                     try {
  757.                         tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  758.                     } catch (Exception e) {
  759.                         log.warn(e.getMessage());
  760.                     }
  761.                 }else {
  762.                     tmpValue= commonApi.translateDictFromTable(table,text,code,k.trim());
  763.                 }
  764.             }else {
  765.                 String keyString = String.format("sys:cache:dict::%s:%s",code,k.trim());
  766.                 if (redisTemplate.hasKey(keyString)){
  767.                     try {
  768.                         tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
  769.                     } catch (Exception e) {
  770.                        log.warn(e.getMessage());
  771.                     }
  772.                 }else {
  773.                     tmpValue = commonApi.translateDict(code, k.trim());
  774.                 }
  775.             }
  776.             //update-end--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
  778.             if (tmpValue != null) {
  779.                 if (!"".equals(textValue.toString())) {
  780.                     textValue.append(",");
  781.                 }
  782.                 textValue.append(tmpValue);
  783.             }
  785.         }
  786.         return textValue.toString();
  787.     }
  789.     /**
  790.      * 检测返回结果集中是否包含Dict注解
  791.      * @param records
  792.      * @return
  793.      */
  794.     private Boolean checkHasDict(List<?> records){
  795.         if(oConvertUtils.isNotEmpty(records) && records.size()>0){
  796.             for (Field field : oConvertUtils.getAllFields(records.get(0))) {
  797.                 if (oConvertUtils.isNotEmpty(field.getAnnotation(Dict.class))) {
  798.                     return true;
  799.                 }
  800.             }
  801.         }
  802.         return false;
  803.     }
  805. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注