本文以自动处理金额字段为参考，将返回结果自动匹配相对应的单位（金额单位：【元，万元，亿】），且支持单位是否放置额外字段等。

本文涉及技术点：自定义注解、AOP、反射、递归

一、前提背景

α、回参原始样例

  1. {
  2.     "code": 0,
  3.     "msg": "成功",
  4.     "data": {
  5.         "money": "20000000",
  6.         "moneyUnit": null
  7.     }
  8. }

β、需要处理的两个场景

1、转换money，且将单位跟在money后。

  1. {
  2.     "code": 0,
  3.     "msg": "成功",
  4.     "data": {
  5.         "money": "2000.00万元",
  6.         "moneyUnit": null
  7.     }
  8. }

2、转换money，将单位放入额外字段moneyUnit。

  1. {
  2.     "code": 0,
  3.     "msg": "成功",
  4.     "data": {
  5.         "money": "2000.00",
  6.         "moneyUnit": "万元"
  7.     }
  8. }

二、设计思路

α、利用AOP在spring返回responseBody时切入处理

b、根据反射拿到DTO内部的属性和值

γ、若DTO内含DTO，用递归处理

δ、最终解析为基础类型进入处理方法，处理方法中根据自定义注解实现多种场景配置

三、代码演示

α、主逻辑代码

1、实现ResponseBodyAdvice类，重写supports，beforeBodyWrite方法。

  1. // ControllerAdvice用于对Controller进行“切面”环绕的注解
  2. @ControllerAdvice
  3. @Slf4j
  4. // 实现ResponseBodyAdvice类
  5. public class ResponseDealAdvice implements ResponseBodyAdvice {
  6.     @Override
  7.     public boolean supports(MethodParameter methodParameter, Class aClass) {
  8.         return true;
  9.     }
  11.     // 重写此方法
  12.     @Override
  13.     public Object beforeBodyWrite(Object o, MethodParameter methodParameter, 
  14.                                   MediaType mediaType, Class aClass,
  15.                                   ServerHttpRequest serverHttpRequest, 
  16.                                   ServerHttpResponse serverHttpResponse) {
  17.         try {
  18.             // 对统一返回类Result开始反射解析（统一返回类见四-α））
  19.             if (o instanceof Result) {
  20.                 Result resultContentVO = (Result) o;
  21.                 // 获取统一返回类中的实际返回类的所有属性
  22.                 Field[] declaredFields = resultContentVO.getData().getClass()
  23.                     .getDeclaredFields();
  24.                 // 调用递归方法（方法见三-α-2）
  25.                 recursion(result, declaredFields);
  26.             }
  27.         } catch (Exception e) {
  28.             log.error("ResponseDealAdvice beforeBodyWrite error:" + e);
  29.         }
  30.         return o;
  31.     }
  33.     //省略下方代码
  34.     ..........
  35. }

2、递归处理DTO方法，递归解析，一直解析到基础类型。

目前DTO仅支持：List、DTO（内部类）、基础数据类型

  1. /**
  2.  * 递归处理DTO属性
  3.  * 支持DTO类型：list，内部DTO，基本数据类型
  4.  * @param o
  5.  * @param declaredFields
  6.  */
  7. void recursion(Object o, Field[] declaredFields) {
  8.     try {
  9.         for (Field declaredField : declaredFields) {
  10.             Field declaredField = declaredFields[i];
  11.             //如果属性是List就解析list的对象
  12.             if (declaredField.getType().getName().contains("List")) {
  13.                 // 反射获取DTO里xxxList的get方法
  14.                 Method get = o.getClass().getMethod("get" 
  15.                      + declaredField.getName().substring(0, 1).toUpperCase()
  16.                      + declaredField.getName().substring(1));
  17.                 // 反射获取xxxList实例
  18.                 List invoke = (List) get.invoke(o);
  19.                 if (!CollectionUtils.isEmpty(invoke)) {
  20.                     // 遍历xxxList
  21.                     invoke.forEach(t -> {
  22.                         try {
  23.                             // 获取所有属性
  24.                             Field[] declaredFields1 = t.getClass()
  25.                                 .getDeclaredFields();
  26.                             // 对属性遍历
  27.                             for (Field field : declaredFields1) {
  28.                                 // 如果List中的属性有list和DTO递归处理
  29.                                 if (field.getType().getName().contains("List")
  30.                                     || field.getType().getName().contains("$")) {
  31.                                     recursion(t, declaredFields1);
  32.                                 }
  33.                                 // 剩下（基本类型）进入处理方法（方法见三-α-3）
  34.                                 dealMoney(t, field);
  35.                             }
  36.                         } catch (Exception e) {
  37.                             log.error("ResponseDealAdvice listForEach error:" + e);
  38.                         }
  40.                     });
  41.                 }
  42.             } else if (declaredField.getType().getName().contains("$")) {
  43.                 // 如果属性是内部DTO
  44.                 // 获取内部DTO所有的属性
  45.                 Field[] nestedClassFields = declaredField.getType().getDeclaredFields();
  46.                 // 反射拿到内部类的名字 ！！！ps:内部DTO名字保持和类型一致！！！
  47.                 String nestedClassName = declaredField.getType().getName()
  48.                     .substring(declaredField.getType().getName().indexOf("$")));
  49.                 Method method = o.getClass().getMethod("get" + nestedClassName);
  50.                 // 反射获取到内部DTO实例
  51.                 Object invoke = method.invoke(o);
  52.                 // 进入到递归方法
  53.                 recursion(invoke, nestedClassFields);
  54.             } else {
  55.                 // 非List，非DTO，基本类型直接处理（方法见三-α-3）
  56.                 dealMoney(o, declaredField);
  57.             }
  58.         }
  59.     } catch (Exception e) {
  60.         log.error("ResponseDealAdvice recursion error:" + e);
  61.     }
  62. }

3、基础类型统一处理方法

  1. /**
  2.  * 统一处理金额
  3.  *
  4.  * @param t
  5.  * @param filed
  6.  */
  7. void dealMoney(Object t, Field filed) {
  8.     try {
  9.         // 有DealMoney注解的属性进入（注解类见四-β）
  10.         if (filed.isAnnotationPresent(DealMoney.class)) {
  11.             // 获取字段名
  12.             String filedName = filed.getName();
  13.             // 反射获取字段的get方法
  14.             Method getMethodMain = t.getClass().getMethod("get"
  15.                    + filedName.substring(0, 1).toUpperCase()
  16.                    + filedName.substring(1));
  17.             // 根据发射的get方法获取实例的money值
  18.             String money = (String) getMethodMain.invoke(t);
  19.             // money为空处理
  20.             if (money == null || money.equals("-")) {
  21.                 return;
  22.             }
  23.             // 统一处理money，计算money是元/万元/亿元哪种，放入新DTO类返回（方法见三-α-4）
  24.             MoneyVO moneyAndUnit = getMoneyAndUnit(new BigDecimal(money));
  25.             // 通过反射获取注解字段的set方法
  26.             Method setMethodMain = t.getClass().getMethod("set"
  27.                    + filedName.substring(0, 1).toUpperCase()
  28.                    + filedName.substring(1), String.class);
  29.             // 获取字段的注解值
  30.             DealMoney annotation = filed.getAnnotation(DealMoney.class);  
  31.             if (annotation.HavaUnit() == 1) {
  32.                 // 默认1 注解字段+额外字段填充
  33.                 // 填充注解字段
  34.                 setMethodMain.invoke(t, moneyAndUnit.getMoneyAmount());
  35.                 // 获取额外字段单位的set方法
  36.                 Method setMethodUnit = t.getClass().getMethod("set"
  37.                        + filedName.substring(0, 1).toUpperCase()
  38.                        + filedName.substring(1) + "Unit", String.class);
  39.                 // 填充单位字段
  40.                 setMethodUnit.invoke(t, moneyAndUnit.getMoneyUnit());
  41.             } else if (annotation.HavaUnit() == 2) {
  42.                 // 2 金额+单位填充到注解字段中
  43.                 setMethodMain.invoke(t, moneyAndUnit.getMoneyAmount() 
  44.                                      + moneyAndUnit.getMoneyUnit());
  45.             } else {
  46.                 // 没有输出错误
  47.                 log.error("ResponseDealAdvice dealMoney error: missing havaUnit type"
  48.                           + annotation.HavaUnit());
  49.             }
  51.         }
  52.     } catch (Exception e) {
  53.         log.error("ResponseDealAdvice dealMoney error:" + e);
  54.     }
  55. }

4、统一处理money类

  1. public static MoneyVO getMoneyAndUnit(BigDecimal newMoney){
  2.     // VO类见三-α-5
  3.     MoneyVO moneyVO = new MoneyVO();
  4.     moneyVO.setMoneyUnit("元");
  5.     moneyVO.setMoneyAmount("-");
  6.     // 入参为空，直接返回
  7.     if(newMoney==null) return moneyVO;
  8.     if(newMoney.compareTo(new BigDecimal(10000))>=0){
  9.         // 值大于1w，设置单位，处理money值回填vo
  10.         moneyVO.setMoneyAmount(
  11.             newMoney.divide(BigDecimal.valueOf(10000), 
  12.                             2, BigDecimal.ROUND_HALF_UP).toString());
  13.         moneyVO.setMoneyUnit("万元");
  14.     } else if (newMoney.compareTo(new BigDecimal(1000000000)) >= 0) {
  15.         // 值大于1w，设置单位，处理money值回填vo
  16.         moneyVO.setMoneyAmount(
  17.             newMoney.divide(BigDecimal.valueOf(1000000000), 
  18.                             2, BigDecimal.ROUND_HALF_UP).toString());
  19.         moneyVO.setMoneyUnit("亿元");
  20.     } else moneyVO.setMoneyAmount(newMoney.setScale(2, BigDecimal.ROUND_HALF_UP).toString());
  21.     return moneyVO;
  22. }

5、统一处理money方法所需VO类

  1. @Getter
  2. @Setter
  3. public class MoneyVO implements Serializable {
  5.     /**
  6.      * 金额量
  7.      */
  8.     private String moneyAmount;
  10.     /**
  11.      * 金额单位
  12.      */
  13.     private String moneyUnit;
  14. }

四、辅助代码

α、统一返回类

  1. @Data
  2. public class Result<T> {
  3.     private Integer code;
  4.     private String msg;
  5.     private T data;
  7.     private Result(Integer code, String msg){
  8.         this.code = code;
  9.         this.msg = msg;
  10.     }
  12.     /**
  13.      * 成功返回，包含对象
  14.      * @param t
  15.      * @param <T>
  16.      * @return
  17.      */
  18.     public static <T> Result<T> success(T t){
  19.         Result<T> result = new Result<>(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg());
  20.         result.setData(t);
  21.         return result;
  22.     }
  24.     /**
  25.      * 成功返回，无对象
  26.      * @return
  27.      */
  28.     public static <T> Result<T> success(){
  29.         return new Result<>(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg());
  30.     }
  32.     /**
  33.      * 失败返回
  34.      * @param code
  35.      * @param msg
  36.      * @return
  37.      */
  38.     public static <T> Result<T> error(Integer code, String msg){
  39.         return new Result<>(code, msg);
  40.     }
  41. }

β、统一注解类

  1. @Target(ElementType.FIELD)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Component
  4. public @interface DealMoney {
  5.     /**
  6.      * 解决单位问题
  7.      * 默认为
  8.      * 1：金额和单位字段都填充
  9.      * 2：金额和单位合并填充金额字段
  10.      */
  11.     int HavaUnit() default 1;
  12. }

五、测试代码

α、测试DTO

  1. @Data
  2. public class TestDTO {
  3.     @DealMoney(HavaUnit = 1)
  4.     private String money;
  5.     private String moneyUnit;
  6.     private List<InnerClassDTO> aList;
  8.     @NoArgsConstructor
  9.     @Data
  10.     public static class InnerClassDTO {
  11.         @DealMoney(HavaUnit = 2)
  12.         private String innerMoney;
  13.         private String innerMoneyUnit;
  14.         private Inner2ClassDTO inner2Class;
  15.     }
  17.     @NoArgsConstructor
  18.     @Data
  19.     public static class Inner2ClassDTO {
  20.         @DealMoney(HavaUnit = 1)
  21.         private String innerMoney;
  22.         private String innerMoneyUnit;
  23.     }
  24. }

β、测试controller

  1. @RestController
  2. @RequestMapping("/test")
  3. public class TestController {
  5.     @RequestMapping("/unit")
  6.     public Result<TestDTO> test(){
  7.         TestDTO testDTO = new TestDTO();
  8.         testDTO.setMoney("20000000");
  9.         List<TestDTO.InnerClassDTO> aList = new ArrayList<>();
  10.         TestDTO.InnerClassDTO innerDTO = new TestDTO.InnerClassDTO();
  11.         innerDTO.setInnerMoney("10000000");
  12.         TestDTO.Inner2ClassDTO innner2DTO = new TestDTO.Inner2ClassDTO();
  13.         innner2DTO.setInnerMoney("5000");
  14.         innerDTO.setInner2Class(innner2DTO);
  15.         aList.add(innerDTO);
  16.         testDTO.setAList(aList);
  17.         return Result.success(testDTO);
  18.     }
  19. }

γ、测试结果

  1. {
  2.     "code": 0,
  3.     "msg": "成功",
  4.     "data": {
  5.         "money": "2000.00",
  6.         "moneyUnit": "万元",
  7.         "alist": [
  8.             {
  9.                 "innerMoney": "1000.00万元",
  10.                 "innerMoneyUnit": null,
  11.                 "inner2Class": {
  12.                     "innerMoney": "5000.00",
  13.                     "innerMoneyUnit": "元"
  14.                 }
  15.             }
  16.         ]
  17.     }
  18. }