基于SpringBoot 、AOP与自定义注解转义字典值

　　一直以来，前端展示字典一般以中文展示为主，若在表中存字典值中文，当字典表更改字典值对应的中文，会造成数据不一致，为此设置冗余字段并非最优方案，若由前端自己写死转义，不够灵活，若在业务代码转义，臃肿也不够通用，从网络上了解到注解、AOP是一种不错的解决方案，主要有两种方式：

　　1、通过注解获取结果集转为JSON字符串，通过正则查找附加字段；

　　2、通过获取结果集中相关字段上注解，此种方法有两个需要解决的问题，父类继承字段、嵌合对象难以解决获取对应注解字段问题，解决起来均比较麻烦；

　　因此本文采用第一种方法，能有效规避第二种方法相关问题，做到逻辑相对简单，引入缓存提高效率。

一、新建注解

　　标注方法上使用

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface TranslationDict {
    FieldParam[] value();
}

　　注解参数：FieldParam

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

    /**
     * 字段类型 默认字典 
     * Constant.FIELDTYPE_DICT 为自定义常量
     * @return
     */
    int type() default Constant.FIELDTYPE_DICT;

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

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

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

}

二、注解的使用

　　在需要转义方法体上添加注解，在注解上指定需要转义的字段，不声明则使用默认值。

@TranslationDict({@FieldParam(dictType = "CUSTOMER_SEX", targetField = "sex"),
            @FieldParam(dictType = "CUSTOMER_STATUS", targetField = "status", targetFieldValueClazz = Integer.class)})

三、新建切面

　　切面核心在于将结果集转为JSON字符串，通过正则查询需要转义的字段，进行拼接替换，以增加属性。

@Aspect
@Component
@Slf4j
public class TranslateFieldAspect {

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

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

        //首先，取出要翻译字段的字典值
        String returnJsonResult = JSONObject.toJSONString(result);
        //开始解析（翻译字段注解参数指定的字段）
        Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
        //获取注解上参数
        TranslationDict annotation = method.getAnnotation(TranslationDict.class);
        FieldParam[] fieldParams = annotation.value();
        //遍历
        for (FieldParam fieldParam : fieldParams) {
            log.info("开始翻译字典CODE:{},取值字段：{},取值字段值类型：{}.",
                    fieldParam.dictType(),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();
        }

        result = JSONObject.parseObject(returnJsonResult,returnType);
        //如果这里不返回result，则目标对象实际返回值会被置为null
        //处理完请求时间
        Long endTime = System.currentTimeMillis();
        log.info("The request takes {}ms",endTime-startTime);
        return result;
    }
　　/**
     * 字典值转义为中文
     * @param fieldParam
     * @param fieldPattern
     * @param fieldMatcher
     * @param sb
     */
    private void translateDict(FieldParam fieldParam, Pattern fieldPattern, Matcher fieldMatcher, StringBuffer sb) {
        //从缓存中一次性取值
        Map<String, String> dictNames = DictData.getDictNames(fieldParam.dictType());
        while (fieldMatcher.find()){

            //取出要翻译字段对应的值
            Matcher dictValueMatcher = fieldPattern.matcher(fieldMatcher.group());
            dictValueMatcher.find();
            String group = dictValueMatcher.group();
            //""sex":1", ""sex":"1"",""sex":null"
            //属性无值
            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(",")) {
                        //fieldParam.dictType() + "_" + s 根据自己字典表设置的规则去查询
                        dictName += dictNames.get(fieldParam.dictType() + "_" + s) + "/";
                    }
                }else {
                    dictName = dictNames.get(fieldParam.dictType() + "_" + 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;
    }
}

四、测试

　　测试类

@Slf4j
@RestController
@RequestMapping("/demo")
@Api(tags="demo")
public class DemoController {


    /**
     * 测试注解字典
     * @return
     */
    @TranslationDict({@FieldParam(dictType = "CUSTOMER_SEX", targetField = "sex"),
            @FieldParam(dictType = "CUSTOMER_STATUS", targetField = "status", targetFieldValueClazz = Integer.class)})
    @GetMapping("/test")
    @ApiOperation(value = "测试字典转义")
    public ResultVo test1() {
        //接收到请求时间
        Long startTime = System.currentTimeMillis();
        List result = this.getResult();
        //处理完请求时间
        Long endTime = System.currentTimeMillis();
        log.info("The request takes {}ms",endTime-startTime);
        return new ResultVo().success(result);
    }

    private List getResult() {
        List demos = new ArrayList<>();
        Demo demo = new Demo("张三","1,2",1);
        Demo demo2= new Demo("李四","2,1",2);
        demos.add(demo);
        demos.add(demo2);

        for (int i = 0; i < 5; i++) {
            demos.add(new Demo("张三"+i,"1",1) );
        }
        return demos;
    }

实体对象

@Data
public class Demo {

    private String name;

    private String sex;

    private Integer status;

    public Demo() {
    }

    public Demo(String name, String sex, Integer status) {
        this.name = name;
        this.sex = sex;
        this.status = status;
    }

    public Demo(String name) {
        this.name = name;
    }

    public Demo(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
    
}

测试效果

{
  "code": 0,
  "message": "success",
  "data": [
    {
      "statusStr": "报备",
      "sex": "1,2",
      "name": "张三",
      "sexStr": "男/女/",
      "status": 1
    },
    {
      "statusStr": "到访",
      "sex": "2,1",
      "name": "李四",
      "sexStr": "女/男/",
      "status": 2
    },
    {
      "statusStr": "报备",
      "sex": "1",
      "name": "张三0",
      "sexStr": "男",
      "status": 1
    },...
  ]
}

到此本文结束，如您有更好的解决方案，还请留言告知，非常感谢。

参考资料：https://blog.csdn.net/qq_44754081/article/details/106142458

　　　　　https://blog.csdn.net/Better_Mei/article/details/103901273

　　　　　https://my.oschina.net/angelbo/blog/2875887