Merge remote-tracking branch 'origin/master'

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/controller/MedicalInsRuleInfoController.java

@@ -1,6 +1,8 @@
 package org.jeecg.modules.medical.controller;
 
+import java.lang.reflect.Field;
 import java.util.*;
+import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
@@ -8,10 +10,17 @@ import java.net.URLDecoder;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.parser.Feature;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
+import net.sf.json.util.JSONUtils;
 import org.apache.shiro.SecurityUtils;
+import org.jeecg.common.api.CommonAPI;
 import org.jeecg.common.api.vo.Result;
 import org.jeecg.common.aspect.annotation.Dict;
+import org.jeecg.common.constant.CommonConstant;
 import org.jeecg.common.system.query.QueryGenerator;
 import org.jeecg.common.system.query.QueryRuleEnum;
 import org.jeecg.common.system.vo.*;
@@ -40,6 +49,8 @@ import org.jeecgframework.poi.excel.entity.ImportParams;
 import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
 import org.jeecg.common.system.base.controller.JeecgController;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Lazy;
+import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
@@ -69,6 +80,13 @@ public class MedicalInsRuleInfoController extends JeecgController<MedicalInsRule
     private final IMedicalInsRuleProjectService projectService;
     private final IFactorEnchanceService enchanceService;
 
+    public final RedisTemplate redisTemplate;
+
+    private final ObjectMapper objectMapper;
+    @Lazy
+    @Autowired
+    private CommonAPI commonApi;
+
     /**
      * 分页列表查询
      *
@@ -137,6 +155,9 @@ public class MedicalInsRuleInfoController extends JeecgController<MedicalInsRule
         QueryWrapper<MedicalInsRuleProject> queryWrapper = QueryGenerator.initQueryWrapper(medicalInsRuleProject, req.getParameterMap());
         Page<MedicalInsRuleProject> page = new Page<MedicalInsRuleProject>(pageNo, pageSize);
         IPage<MedicalInsRuleProject> pageList = projectService.page(page, queryWrapper);
+//        pageList = (IPage<MedicalInsRuleProject>) this.parseDictText(pageList);
+        Object pageList2 = this.parseDictText(pageList);
+
         Map<String, Object> map = new HashMap<>();
         if (dictDtos.size() > 0) {
             dictDtos.forEach(it -> {
@@ -288,5 +309,338 @@ public class MedicalInsRuleInfoController extends JeecgController<MedicalInsRule
     }
 
 
+    private Object parseDictText(Object result) {
+        List<JSONObject> items = new ArrayList<>();
+        List<Field> dictFieldList = new ArrayList<>();
+        // 字典数据列表， key = 字典code，value=数据列表
+        Map<String, List<String>> dataListMap = new HashMap<>(5);
+        //取出结果集
+        List<Object> records = ((IPage) (result)).getRecords();
+        //update-begin--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
+        Boolean hasDict = checkHasDict(records);
+        if (!hasDict) {
+            return result;
+        }
+
+        log.debug(" __ 进入字典翻译切面 DictAspect —— ");
+        //update-end--Author:zyf -- Date:20220606 ----for：【VUEN-1230】 判断是否含有字典注解,没有注解返回-----
+        for (Object record : records) {
+            String json = "{}";
+            try {
+                //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
+                //解决@JsonFormat注解解析不了的问题详见SysAnnouncement类的@JsonFormat
+                json = objectMapper.writeValueAsString(record);
+                //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
+            } catch (JsonProcessingException e) {
+                log.error("json解析失败" + e.getMessage(), e);
+            }
+            //update-begin--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
+            JSONObject item = JSONObject.parseObject(json, Feature.OrderedField);
+            //update-end--Author:scott -- Date:20211223 ----for：【issues/3303】restcontroller返回json数据后key顺序错乱 -----
+
+            //update-begin--Author:scott -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
+            //for (Field field : record.getClass().getDeclaredFields()) {
+            // 遍历所有字段，把字典Code取出来，放到 map 里
+            for (Field field : oConvertUtils.getAllFields(record)) {
+                String value = item.getString(field.getName());
+                if (oConvertUtils.isEmpty(value)) {
+                    continue;
+                }
+                //update-end--Author:scott  -- Date:20190603 ----for：解决继承实体字段无法翻译问题------
+                if (field.getAnnotation(Dict.class) != null) {
+                    if (!dictFieldList.contains(field)) {
+                        dictFieldList.add(field);
+                    }
+                    String code = field.getAnnotation(Dict.class).dicCode();
+                    String text = field.getAnnotation(Dict.class).dicText();
+                    String table = field.getAnnotation(Dict.class).dictTable();
+
+                    List<String> dataList;
+                    String dictCode = code;
+                    if (!StringUtils.isEmpty(table)) {
+                        dictCode = String.format("%s,%s,%s", table, text, code);
+                    }
+                    dataList = dataListMap.computeIfAbsent(dictCode, k -> new ArrayList<>());
+                    this.listAddAllDeduplicate(dataList, Arrays.asList(value.split(",")));
+                }
+                //date类型默认转换string格式化日期
+                //update-begin--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
+                //if (JAVA_UTIL_DATE.equals(field.getType().getName())&&field.getAnnotation(JsonFormat.class)==null&&item.get(field.getName())!=null){
+                //SimpleDateFormat aDate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+                // item.put(field.getName(), aDate.format(new Date((Long) item.get(field.getName()))));
+                //}
+                //update-end--Author:zyf -- Date:20220531 ----for：【issues/#3629】 DictAspect Jackson序列化报错-----
+            }
+            items.add(item);
+        }
+
+        //step.2 调用翻译方法，一次性翻译
+        Map<String, List<DictModel>> translText = this.translateAllDict(dataListMap);
+
+        //step.3 将翻译结果填充到返回结果里
+        for (JSONObject record : items) {
+            for (Field field : dictFieldList) {
+                String code = field.getAnnotation(Dict.class).dicCode();
+                String text = field.getAnnotation(Dict.class).dicText();
+                String table = field.getAnnotation(Dict.class).dictTable();
+
+                String fieldDictCode = code;
+                if (!StringUtils.isEmpty(table)) {
+                    fieldDictCode = String.format("%s,%s,%s", table, text, code);
+                }
+
+                String value = record.getString(field.getName());
+                if (oConvertUtils.isNotEmpty(value)) {
+                    List<DictModel> dictModels = translText.get(fieldDictCode);
+                    if (dictModels == null || dictModels.size() == 0) {
+                        continue;
+                    }
+
+                    String textValue = this.translDictText(dictModels, value);
+                    log.debug(" 字典Val : " + textValue);
+                    log.debug(" __翻译字典字段__ " + field.getName() + CommonConstant.DICT_TEXT_SUFFIX + "： " + textValue);
+
+                    // TODO-sun 测试输出，待删
+                    log.debug(" ---- dictCode: " + fieldDictCode);
+                    log.debug(" ---- value: " + value);
+                    log.debug(" ----- text: " + textValue);
+                    log.debug(" ---- dictModels: " + JSON.toJSONString(dictModels));
+
+                    record.put(field.getName() + CommonConstant.DICT_TEXT_SUFFIX, textValue);
+                }
+            }
+
+
+            ((IPage) (result)).setRecords(items);
+        }
+
+//        }
+        return result;
+    }
+
+    /**
+     * list 去重添加
+     */
+    private void listAddAllDeduplicate(List<String> dataList, List<String> addList) {
+        // 筛选出dataList中没有的数据
+        List<String> filterList = addList.stream().filter(i -> !dataList.contains(i)).collect(Collectors.toList());
+        dataList.addAll(filterList);
+    }
+
+    /**
+     * 一次性把所有的字典都翻译了
+     * 1.  所有的普通数据字典的所有数据只执行一次SQL
+     * 2.  表字典相同的所有数据只执行一次SQL
+     *
+     * @param dataListMap
+     * @return
+     */
+    private Map<String, List<DictModel>> translateAllDict(Map<String, List<String>> dataListMap) {
+        // 翻译后的字典文本，key=dictCode
+        Map<String, List<DictModel>> translText = new HashMap<>(5);
+        // 需要翻译的数据（有些可以从redis缓存中获取，就不走数据库查询）
+        List<String> needTranslData = new ArrayList<>();
+        //step.1 先通过redis中获取缓存字典数据
+        for (String dictCode : dataListMap.keySet()) {
+            List<String> dataList = dataListMap.get(dictCode);
+            if (dataList.size() == 0) {
+                continue;
+            }
+            // 表字典需要翻译的数据
+            List<String> needTranslDataTable = new ArrayList<>();
+            for (String s : dataList) {
+                String data = s.trim();
+                if (data.length() == 0) {
+                    continue; //跳过循环
+                }
+                if (dictCode.contains(",")) {
+                    String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, data);
+                    if (redisTemplate.hasKey(keyString)) {
+                        try {
+                            String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
+                            List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
+                            list.add(new DictModel(data, text));
+                        } catch (Exception e) {
+                            log.warn(e.getMessage());
+                        }
+                    } else if (!needTranslDataTable.contains(data)) {
+                        // 去重添加
+                        needTranslDataTable.add(data);
+                    }
+                } else {
+                    String keyString = String.format("sys:cache:dict::%s:%s", dictCode, data);
+                    if (redisTemplate.hasKey(keyString)) {
+                        try {
+                            String text = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
+                            List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
+                            list.add(new DictModel(data, text));
+                        } catch (Exception e) {
+                            log.warn(e.getMessage());
+                        }
+                    } else if (!needTranslData.contains(data)) {
+                        // 去重添加
+                        needTranslData.add(data);
+                    }
+                }
+
+            }
+            //step.2 调用数据库翻译表字典
+            if (needTranslDataTable.size() > 0) {
+                String[] arr = dictCode.split(",");
+                String table = arr[0], text = arr[1], code = arr[2];
+                String values = String.join(",", needTranslDataTable);
+                log.debug("translateDictFromTableByKeys.dictCode:" + dictCode);
+                log.debug("translateDictFromTableByKeys.values:" + values);
+                List<DictModel> texts = commonApi.translateDictFromTableByKeys(table, text, code, values);
+                log.debug("translateDictFromTableByKeys.result:" + texts);
+                List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
+                list.addAll(texts);
+
+                // 做 redis 缓存
+                for (DictModel dict : texts) {
+                    String redisKey = String.format("sys:cache:dictTable::SimpleKey [%s,%s]", dictCode, dict.getValue());
+                    try {
+                        // update-begin-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
+                        // 保留5分钟
+                        redisTemplate.opsForValue().set(redisKey, dict.getText(), 300, TimeUnit.SECONDS);
+                        // update-end-author:taoyan date:20211012 for: 字典表翻译注解缓存未更新 issues/3061
+                    } catch (Exception e) {
+                        log.warn(e.getMessage(), e);
+                    }
+                }
+            }
+        }
+
+        //step.3 调用数据库进行翻译普通字典
+        if (needTranslData.size() > 0) {
+            List<String> dictCodeList = Arrays.asList(dataListMap.keySet().toArray(new String[]{}));
+            // 将不包含逗号的字典code筛选出来，因为带逗号的是表字典，而不是普通的数据字典
+            List<String> filterDictCodes = dictCodeList.stream().filter(key -> !key.contains(",")).collect(Collectors.toList());
+            String dictCodes = String.join(",", filterDictCodes);
+            String values = String.join(",", needTranslData);
+            log.debug("translateManyDict.dictCodes:" + dictCodes);
+            log.debug("translateManyDict.values:" + values);
+            Map<String, List<DictModel>> manyDict = commonApi.translateManyDict(dictCodes, values);
+            log.debug("translateManyDict.result:" + manyDict);
+            for (String dictCode : manyDict.keySet()) {
+                List<DictModel> list = translText.computeIfAbsent(dictCode, k -> new ArrayList<>());
+                List<DictModel> newList = manyDict.get(dictCode);
+                list.addAll(newList);
+
+                // 做 redis 缓存
+                for (DictModel dict : newList) {
+                    String redisKey = String.format("sys:cache:dict::%s:%s", dictCode, dict.getValue());
+                    try {
+                        redisTemplate.opsForValue().set(redisKey, dict.getText());
+                    } catch (Exception e) {
+                        log.warn(e.getMessage(), e);
+                    }
+                }
+            }
+        }
+        return translText;
+    }
+
+    /**
+     * 字典值替换文本
+     *
+     * @param dictModels
+     * @param values
+     * @return
+     */
+    private String translDictText(List<DictModel> dictModels, String values) {
+        List<String> result = new ArrayList<>();
+
+        // 允许多个逗号分隔，允许传数组对象
+        String[] splitVal = values.split(",");
+        for (String val : splitVal) {
+            String dictText = val;
+            for (DictModel dict : dictModels) {
+                if (val.equals(dict.getValue())) {
+                    dictText = dict.getText();
+                    break;
+                }
+            }
+            result.add(dictText);
+        }
+        return String.join(",", result);
+    }
+
+    /**
+     * 翻译字典文本
+     *
+     * @param code
+     * @param text
+     * @param table
+     * @param key
+     * @return
+     */
+    @Deprecated
+    private String translateDictValue(String code, String text, String table, String key) {
+        if (oConvertUtils.isEmpty(key)) {
+            return null;
+        }
+        StringBuffer textValue = new StringBuffer();
+        String[] keys = key.split(",");
+        for (String k : keys) {
+            String tmpValue = null;
+            log.debug(" 字典 key : " + k);
+            if (k.trim().length() == 0) {
+                continue; //跳过循环
+            }
+            //update-begin--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
+            if (!StringUtils.isEmpty(table)) {
+                log.debug("--DictAspect------dicTable=" + table + " ,dicText= " + text + " ,dicCode=" + code);
+                String keyString = String.format("sys:cache:dictTable::SimpleKey [%s,%s,%s,%s]", table, text, code, k.trim());
+                if (redisTemplate.hasKey(keyString)) {
+                    try {
+                        tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
+                    } catch (Exception e) {
+                        log.warn(e.getMessage());
+                    }
+                } else {
+                    tmpValue = commonApi.translateDictFromTable(table, text, code, k.trim());
+                }
+            } else {
+                String keyString = String.format("sys:cache:dict::%s:%s", code, k.trim());
+                if (redisTemplate.hasKey(keyString)) {
+                    try {
+                        tmpValue = oConvertUtils.getString(redisTemplate.opsForValue().get(keyString));
+                    } catch (Exception e) {
+                        log.warn(e.getMessage());
+                    }
+                } else {
+                    tmpValue = commonApi.translateDict(code, k.trim());
+                }
+            }
+            //update-end--Author:scott -- Date:20210531 ----for： !56 优化微服务应用下存在表字段需要字典翻译时加载缓慢问题-----
+
+            if (tmpValue != null) {
+                if (!"".equals(textValue.toString())) {
+                    textValue.append(",");
+                }
+                textValue.append(tmpValue);
+            }
+
+        }
+        return textValue.toString();
+    }
+
+    /**
+     * 检测返回结果集中是否包含Dict注解
+     *
+     * @param records
+     * @return
+     */
+    private Boolean checkHasDict(List<Object> records) {
+        if (oConvertUtils.isNotEmpty(records) && records.size() > 0) {
+            for (Field field : oConvertUtils.getAllFields(records.get(0))) {
+                if (oConvertUtils.isNotEmpty(field.getAnnotation(Dict.class))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
 
 }

jeecg-module-system/jeecg-system-biz/src/main/java/org/jeecg/modules/medical/entity/MedicalInsRuleProject.java

@@ -40,9 +40,11 @@ public class MedicalInsRuleProject implements Serializable {
 	@Excel(name = "医保规则ID", width = 15)
     @ApiModelProperty(value = "医保规则ID")
     private java.lang.Integer medicalInsRuleInfoId;
+
 	/**医保主数据类型;MEDICINE（药品主数据表）、CONSUMABLE_METERIAL(耗材主数据表)、DIAGNOSIS_TREATMENT（诊疗主数据表）、DIAGNOSIS(诊断主数据表)、OPERATIVE(手术主数据表)*/
 	@Excel(name = "医保主数据类型", width = 15)
     @ApiModelProperty(value = "医保主数据类型;MEDICINE（药品主数据表）、CONSUMABLE_METERIAL(耗材主数据表)、DIAGNOSIS_TREATMENT（诊疗主数据表）、DIAGNOSIS(诊断主数据表)、OPERATIVE(手术主数据表)")
+    @Dict(dicCode = "medicine_data_type")
     private java.lang.String medicineDataType;
 	/**主数据表编码*/
 	@Excel(name = "项目编码", width = 15)