springboot通过aop实现自定义字典翻译注解

1.字典翻译注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface TranslationDict {

    FieldParam[] value();

}

2.字典翻译字段注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
@Documented
public @interface FieldParam {

    /**
     * 字段类型 默认字典
     * 暂不区分字典类型
     * @return
     */
    int type() default 1;

    /**
     * 字典dictType
     *
     * @return
     */
    String dictKey() default "";

    /**
     * 要翻译的字段 目标字段为翻译的字段+Str
     *
     * @return
     */
    String targetField() default "";

    /**
     * 要翻译的字段值类型
     *
     * @return
     */
    Class targetFieldValueClazz() default String.class;

}

3.切面

@Aspect
@Component
@Slf4j
public class TranslateFieldAspect {

    @Autowired
    BaseDictionariesService baseDictionariesService;

    /**
     * * 翻译字典值
     * * @param joinPoint
     * * @return
     * * @throws Throwable
     */
    @Around("@annotation(com.onesports.jsty.common.annotation.TranslationDict)")
    public ResponseEntity aroundMethodDict(ProceedingJoinPoint joinPoint) throws Throwable {
        //接收到请求时间
        Long startTime = System.currentTimeMillis();
        //注意，如果调用joinPoint.proceed()方法，则修改的参数值不会生效，必须调用joinPoint.proceed(Object[] args)
        ResponseEntity result = (ResponseEntity) joinPoint.proceed();
        if (result.getStatusCodeValue() != 200) {
            return ResultUtil.success();
        }

        //获取返回值类型
        Class returnType = ((MethodSignature) joinPoint.getSignature()).getReturnType();

        //取出要翻译字段的字典值
        String returnJsonResult = JSONObject.toJSONString(result.getBody());
        //开始解析（翻译字段注解参数指定的字段）
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        //获取注解上参数
        TranslationDict annotation = method.getAnnotation(TranslationDict.class);
        FieldParam[] fieldParams = annotation.value();
        //遍历
        for (FieldParam fieldParam : fieldParams) {
            log.info("开始翻译字典CODE:{},取值字段：{},取值字段值类型：{}.",
                    fieldParam.dictKey(), fieldParam.targetField(), fieldParam.targetFieldValueClazz());
            Pattern dictPattern = getPattern(fieldParam);
            Matcher dictMatcher = dictPattern.matcher(returnJsonResult);
            StringBuffer sb = new StringBuffer();
            //转义字段
            this.translateDict(fieldParam, dictPattern, dictMatcher, sb);
            dictMatcher.appendTail(sb);
            returnJsonResult = sb.toString();
        }

        JSONObject jsonObject = JSONObject.parseObject(returnJsonResult);
        //如果这里不返回result，则目标对象实际返回值会被置为null
        //处理完请求时间
        Long endTime = System.currentTimeMillis();
        log.info("The request takes {}ms", endTime - startTime);
        return ResultUtil.success(jsonObject.get("data"));
    }

    /**
     * 字典值转义为中文
     */
    private void translateDict(FieldParam fieldParam, Pattern fieldPattern, Matcher fieldMatcher, StringBuffer sb) {
        //根据字典值查询字典集合
        List<BaseDictDTO> baseDictDTOS = baseDictionariesService.listDictByDictKey(fieldParam.dictKey());
        //获取字典的key和value转成map
        Map<String, String> dictNames = baseDictDTOS.stream().filter(t -> t.getFieldValue() != null)
                .collect(Collectors.toMap(BaseDictDTO::getFieldKey, BaseDictDTO::getFieldValue, (k1, k2) -> k1));
        while (fieldMatcher.find()) {
            //取出要翻译字段对应的值
            Matcher dictValueMatcher = fieldPattern.matcher(fieldMatcher.group());
            dictValueMatcher.find();
            String group = dictValueMatcher.group();

            //属性无值
            if (group.split(":").length <= 1) continue;
            String dictName = "";

            //获取字典值
            String dictValue = group.split(":")[1].replace("\"", "");
            //属性值非为空 为空赋值空串
            if (StringUtils.isNotBlank(dictValue) && !dictValue.toLowerCase().equals("null")) {
                //多值
                if (dictValue.split(",").length > 1) {
                    for (String s : dictValue.split(",")) {
                        dictName += dictNames.get(s) + "/";
                    }
                } else {
                    dictName = dictNames.get(dictValue);
                }
            }

            String s = "\"" + fieldParam.targetField() + "Str" + "\":\"" + dictName + "\"," + fieldMatcher.group();
            log.debug("拼接后字符串:{}", s);
            fieldMatcher.appendReplacement(sb, s);
        }
    }


    /**
     * 获取对应的正则式
     *
     * @param fieldParam
     * @return
     */
    private Pattern getPattern(FieldParam fieldParam) {
        Pattern fieldPattern;//属性整型 字符型
        if (fieldParam.targetFieldValueClazz().equals(Integer.class)) {
            fieldPattern = Pattern.compile("\"" + fieldParam.targetField() + "\":(\\d+)?");
        } else {
            fieldPattern = Pattern.compile("\"" + fieldParam.targetField() + "\":\"([0-9a-zA-Z_,]+)?\"");
        }
        return fieldPattern;
    }
}

4.使用：在列表查询方法上使用注解，dictKey是字典的key，targetField是实体对象属性值

@TranslationDict(
        {@FieldParam(dictKey = "MZ",targetField = "nationCode"),
         @FieldParam(dictKey = "XL",targetField = "educationCode"),
         @FieldParam(dictKey = "ZZMM",targetField = "politicalCode")})
public ResponseEntity findPage(LiablePersonDto queryDto) {
    Page<LiablePersonResultDto> page = personMapper.findPage(queryDto.buildPage(), queryDto);
    return ResultUtil.success(page);
}

5.字典表数据结构参考