Spring Boot 接口加解密，新姿势来了！

1. 介绍

在我们日常的Java开发中，免不了和其他系统的业务交互，或者微服务之间的接口调用
如果我们想保证数据传输的安全，对接口出参加密，入参解密。
但是不想写重复代码，我们可以提供一个通用starter，提供通用加密解密功能
2. 前置知识

2.1 hutool-crypto加密解密工具
hutool-crypto提供了很多加密解密工具，包括对称加密，非对称加密，摘要加密等等，这不做详细介绍。
2.2 request流只能读取一次的问题
2.2.1 问题：

在接口调用链中，request的请求流只能调用一次，处理之后，如果之后还需要用到请求流获取数据，就会发现数据为空。
比如使用了filter或者aop在接口处理之前，获取了request中的数据，对参数进行了校验，那么之后就不能在获取request请求流了
2.2.2 解决办法

继承HttpServletRequestWrapper，将请求中的流copy一份，复写getInputStream和getReader方法供外部使用。每次调用后的getInputStream方法都是从复制出来的二进制数组中进行获取，这个二进制数组在对象存在期间一致存在。
使用Filter过滤器，在一开始，替换request为自己定义的可以多次读取流的request。
这样就实现了流的重复获取

1. InputStreamHttpServletRequestWrapper
2. package xyz.hlh.cryptotest.utils;
4. import org.apache.commons.io.IOUtils;
6. import javax.servlet.ReadListener;
7. import javax.servlet.ServletInputStream;
8. import javax.servlet.http.HttpServletRequest;
9. import javax.servlet.http.HttpServletRequestWrapper;
10. import java.io.BufferedReader;
11. import java.io.ByteArrayInputStream;
12. import java.io.ByteArrayOutputStream;
13. import java.io.IOException;
14. import java.io.InputStreamReader;
16. /**
17. * 请求流支持多次获取
18. */
19. public class InputStreamHttpServletRequestWrapper extends HttpServletRequestWrapper {
21.     /**
22.      * 用于缓存输入流
23.      */
24.     private ByteArrayOutputStream cachedBytes;
26.     public InputStreamHttpServletRequestWrapper(HttpServletRequest request) {
27.         super(request);
28.     }
30.     @Override
31.     public ServletInputStream getInputStream() throws IOException {
32.         if (cachedBytes == null) {
33.             // 首次获取流时，将流放入 缓存输入流 中
34.             cacheInputStream();
35.         }
37.         // 从 缓存输入流 中获取流并返回
38.         return new CachedServletInputStream(cachedBytes.toByteArray());
39.     }
41.     @Override
42.     public BufferedReader getReader() throws IOException {
43.         return new BufferedReader(new InputStreamReader(getInputStream()));
44.     }
46.     /**
47.      * 首次获取流时，将流放入 缓存输入流 中
48.      */
49.     private void cacheInputStream() throws IOException {
50.         // 缓存输入流以便多次读取。为了方便, 我使用 org.apache.commons IOUtils
51.         cachedBytes = new ByteArrayOutputStream();
52.         IOUtils.copy(super.getInputStream(), cachedBytes);
53.     }
55.     /**
56.      * 读取缓存的请求正文的输入流
57.      * <p>
58.      * 用于根据 缓存输入流 创建一个可返回的
59.      */
60.     public static class CachedServletInputStream extends ServletInputStream {
62.         private final ByteArrayInputStream input;
64.         public CachedServletInputStream(byte[] buf) {
65.             // 从缓存的请求正文创建一个新的输入流
66.             input = new ByteArrayInputStream(buf);
67.         }
69.         @Override
70.         public boolean isFinished() {
71.             return false;
72.         }
74.         @Override
75.         public boolean isReady() {
76.             return false;
77.         }
79.         @Override
80.         public void setReadListener(ReadListener listener) {
82.         }
84.         @Override
85.         public int read() throws IOException {
86.             return input.read();
87.         }
88.     }
90. }
91. HttpServletRequestInputStreamFilter
92. package xyz.hlh.cryptotest.filter;
94. import org.springframework.core.annotation.Order;
95. import org.springframework.stereotype.Component;
96. import xyz.hlh.cryptotest.utils.InputStreamHttpServletRequestWrapper;
98. import javax.servlet.Filter;
99. import javax.servlet.FilterChain;
100. import javax.servlet.ServletException;
101. import javax.servlet.ServletRequest;
102. import javax.servlet.ServletResponse;
103. import javax.servlet.http.HttpServletRequest;
104. import java.io.IOException;
106. import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE;
108. /**
109. * @author HLH
110. * @description:
111. *      请求流转换为多次读取的请求流 过滤器
112. * @email 17703595860@163.com
113. * @date : Created in 2022/2/4 9:58
114. */
115. @Component
116. @Order(HIGHEST_PRECEDENCE + 1)  // 优先级最高
117. public class HttpServletRequestInputStreamFilter implements Filter {
119.     @Override
120.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
122.         // 转换为可以多次获取流的request
123.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
124.         InputStreamHttpServletRequestWrapper inputStreamHttpServletRequestWrapper = new InputStreamHttpServletRequestWrapper(httpServletRequest);
126.         // 放行
127.         chain.doFilter(inputStreamHttpServletRequestWrapper, response);
128.     }
129. }

复制代码

2.3 SpringBoot的参数校验validation
Spring Boot 基础就不介绍了，推荐看这个免费教程：

https://github.com/javastacks/spring-boot-best-practice

为了减少接口中，业务代码之前的大量冗余的参数校验代码
SpringBoot-validation提供了优雅的参数校验，入参都是实体类，在实体类字段上加上对应注解，就可以在进入方法之前，进行参数校验，如果参数错误，会抛出错误BindException，是不会进入方法的。
这种方法，必须要求在接口参数上加注解@Validated或者是@Valid
但是很多清空下，我们希望在代码中调用某个实体类的校验功能，所以需要如下工具类。

1. ParamException
2. package xyz.hlh.cryptotest.exception;
4. import lombok.Getter;
6. import java.util.List;
8. /**
9. * @author HLH
10. * @description 自定义参数异常
11. * @email 17703595860@163.com
12. * @date Created in 2021/8/10 下午10:56
13. */
14. @Getter
15. public class ParamException extends Exception {
17.     private final List<String> fieldList;
18.     private final List<String> msgList;
20.     public ParamException(List<String> fieldList, List<String> msgList) {
21.         this.fieldList = fieldList;
22.         this.msgList = msgList;
23.     }
24. }
25. ValidationUtils
26. package xyz.hlh.cryptotest.utils;
28. import xyz.hlh.cryptotest.exception.CustomizeException;
29. import xyz.hlh.cryptotest.exception.ParamException;
31. import javax.validation.ConstraintViolation;
32. import javax.validation.Validation;
33. import javax.validation.Validator;
34. import java.util.LinkedList;
35. import java.util.List;
36. import java.util.Set;
38. /**
39. * @author HLH
40. * @description 验证工具类
41. * @email 17703595860@163.com
42. * @date Created in 2021/8/10 下午10:56
43. */
44. public class ValidationUtils {
46.     private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();
48.     /**
49.      * 验证数据
50.      * @param object 数据
51.      */
52.     public static void validate(Object object) throws CustomizeException {
54.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object);
56.         // 验证结果异常
57.         throwParamException(validate);
58.     }
60.     /**
61.      * 验证数据(分组)
62.      * @param object 数据
63.      * @param groups 所在组
64.      */
65.     public static void validate(Object object, Class<?> ... groups) throws CustomizeException {
67.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object, groups);
69.         // 验证结果异常
70.         throwParamException(validate);
71.     }
73.     /**
74.      * 验证数据中的某个字段(分组)
75.      * @param object 数据
76.      * @param propertyName 字段名称
77.      */
78.     public static void validate(Object object, String propertyName) throws CustomizeException {
79.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName);
81.         // 验证结果异常
82.         throwParamException(validate);
84.     }
86.     /**
87.      * 验证数据中的某个字段(分组)
88.      * @param object 数据
89.      * @param propertyName 字段名称
90.      * @param groups 所在组
91.      */
92.     public static void validate(Object object, String propertyName, Class<?> ... groups) throws CustomizeException {
94.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName, groups);
96.         // 验证结果异常
97.         throwParamException(validate);
99.     }
101.     /**
102.      * 验证结果异常
103.      * @param validate 验证结果
104.      */
105.     private static void throwParamException(Set<ConstraintViolation<Object>> validate) throws CustomizeException {
106.         if (validate.size() > 0) {
107.             List<String> fieldList = new LinkedList<>();
108.             List<String> msgList = new LinkedList<>();
109.             for (ConstraintViolation<Object> next : validate) {
110.                 fieldList.add(next.getPropertyPath().toString());
111.                 msgList.add(next.getMessage());
112.             }
114.             throw new ParamException(fieldList, msgList);
115.         }
116.     }
118. }

复制代码

2.5 自定义starter
自定义starter步骤

• 创建工厂，编写功能代码
  
• 声明自动配置类，把需要对外提供的对象创建好，通过配置类统一向外暴露
  
• 在resource目录下准备一个名为spring/spring.factories的文件，以org.springframework.boot.autoconfigure.EnableAutoConfiguration为key，自动配置类为value列表，进行注册
  

2.6 RequestBodyAdvice和ResponseBodyAdvice

• RequestBodyAdvice是对请求的json串进行处理， 一般使用环境是处理接口参数的自动解密
  
• ResponseBodyAdvice是对请求相应的jsoin传进行处理，一般用于相应结果的加密
  

3. 功能介绍

接口相应数据的时候，返回的是加密之后的数据 接口入参的时候，接收的是解密之后的数据，但是在进入接口之前，会自动解密，取得对应的数据
4. 功能细节

加密解密使用对称加密的AES算法，使用hutool-crypto模块进行实现
所有的实体类提取一个公共父类，包含属性时间戳，用于加密数据返回之后的实效性，如果超过60分钟，那么其他接口将不进行处理。
如果接口加了加密注解EncryptionAnnotation，并且返回统一的json数据Result类，则自动对数据进行加密。如果是继承了统一父类RequestBase的数据，自动注入时间戳，确保数据的时效性
如果接口加了解密注解DecryptionAnnotation，并且参数使用RequestBody注解标注，传入json使用统一格式RequestData类，并且内容是继承了包含时间长的父类RequestBase，则自动解密，并且转为对应的数据类型
功能提供Springboot的starter，实现开箱即用
5. 代码实现

https://gitee.com/springboot-hlh/spring-boot-csdn/tree/master/09-spring-boot-interface-crypto

5.1 项目结构


5.2 crypto-common

5.2.1 结构


5.3 crypto-spring-boot-starter

5.3.1 接口


5.3.2 重要代码

crypto.properties AES需要的参数配置

1. # 模式    cn.hutool.crypto.Mode
2. crypto.mode=CTS
3. # 补码方式 cn.hutool.crypto.Mode
4. crypto.padding=PKCS5Padding
5. # 秘钥
6. crypto.key=testkey123456789
7. # 盐
8. crypto.iv=testiv1234567890

复制代码

spring.factories 自动配置文件

1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
2. xyz.hlh.crypto.config.AppConfig

复制代码

CryptConfig AES需要的配置参数

1. package xyz.hlh.crypto.config;
3. import cn.hutool.crypto.Mode;
4. import cn.hutool.crypto.Padding;
5. import lombok.Data;
6. import lombok.EqualsAndHashCode;
7. import lombok.Getter;
8. import org.springframework.boot.context.properties.ConfigurationProperties;
9. import org.springframework.context.annotation.Configuration;
10. import org.springframework.context.annotation.PropertySource;
12. import java.io.Serializable;
14. /**
15. * @author HLH
16. * @description: AES需要的配置参数
17. * @email 17703595860@163.com
18. * @date : Created in 2022/2/4 13:16
19. */
20. @Configuration
21. @ConfigurationProperties(prefix = "crypto")
22. @PropertySource("classpath:crypto.properties")
23. @Data
24. @EqualsAndHashCode
25. @Getter
26. public class CryptConfig implements Serializable {
28.     private Mode mode;
29.     private Padding padding;
30.     private String key;
31.     private String iv;
33. }

复制代码

AppConfig 自动配置类

1. package xyz.hlh.crypto.config;
3. import cn.hutool.crypto.symmetric.AES;
4. import org.springframework.context.annotation.Bean;
5. import org.springframework.context.annotation.Configuration;
7. import javax.annotation.Resource;
8. import java.nio.charset.StandardCharsets;
10. /**
11. * @author HLH
12. * @description: 自动配置类
13. * @email 17703595860@163.com
14. * @date : Created in 2022/2/4 13:12
15. */
16. @Configuration
17. public class AppConfig {
19.     @Resource
20.     private CryptConfig cryptConfig;
22.     @Bean
23.     public AES aes() {
24.         return new AES(cryptConfig.getMode(), cryptConfig.getPadding(), cryptConfig.getKey().getBytes(StandardCharsets.UTF_8), cryptConfig.getIv().getBytes(StandardCharsets.UTF_8));
25.     }
27. }

复制代码

DecryptRequestBodyAdvice 请求自动解密

1. package xyz.hlh.crypto.advice;
3. import com.fasterxml.jackson.databind.ObjectMapper;
4. import lombok.SneakyThrows;
5. import org.apache.commons.lang3.StringUtils;
6. import org.springframework.beans.factory.annotation.Autowired;
7. import org.springframework.core.MethodParameter;
8. import org.springframework.http.HttpInputMessage;
9. import org.springframework.http.converter.HttpMessageConverter;
10. import org.springframework.web.bind.annotation.ControllerAdvice;
11. import org.springframework.web.context.request.RequestAttributes;
12. import org.springframework.web.context.request.RequestContextHolder;
13. import org.springframework.web.context.request.ServletRequestAttributes;
14. import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;
15. import xyz.hlh.crypto.annotation.DecryptionAnnotation;
16. import xyz.hlh.crypto.common.exception.ParamException;
17. import xyz.hlh.crypto.constant.CryptoConstant;
18. import xyz.hlh.crypto.entity.RequestBase;
19. import xyz.hlh.crypto.entity.RequestData;
20. import xyz.hlh.crypto.util.AESUtil;
22. import javax.servlet.ServletInputStream;
23. import javax.servlet.http.HttpServletRequest;
24. import java.io.IOException;
25. import java.lang.reflect.Type;
27. /**
28. * @author HLH
29. * @description: requestBody 自动解密
30. * @email 17703595860@163.com
31. * @date : Created in 2022/2/4 15:12
32. */
33. @ControllerAdvice
34. public class DecryptRequestBodyAdvice implements RequestBodyAdvice {
36.     @Autowired
37.     private ObjectMapper objectMapper;
39.     /**
40.      * 方法上有DecryptionAnnotation注解的，进入此拦截器
41.      * @param methodParameter 方法参数对象
42.      * @param targetType 参数的类型
43.      * @param converterType 消息转换器
44.      * @return true，进入，false，跳过
45.      */
46.     @Override
47.     public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
48.         return methodParameter.hasMethodAnnotation(DecryptionAnnotation.class);
49.     }
51.     @Override
52.     public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
53.         return inputMessage;
54.     }
56.     /**
57.      * 转换之后，执行此方法，解密，赋值
58.      * @param body spring解析完的参数
59.      * @param inputMessage 输入参数
60.      * @param parameter 参数对象
61.      * @param targetType 参数类型
62.      * @param converterType 消息转换类型
63.      * @return 真实的参数
64.      */
65.     @SneakyThrows
66.     @Override
67.     public Object afterBodyRead(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
69.         // 获取request
70.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
71.         ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) requestAttributes;
72.         if (servletRequestAttributes == null) {
73.             throw new ParamException("request错误");
74.         }
76.         HttpServletRequest request = servletRequestAttributes.getRequest();
78.         // 获取数据
79.         ServletInputStream inputStream = request.getInputStream();
80.         RequestData requestData = objectMapper.readValue(inputStream, RequestData.class);
82.         if (requestData == null || StringUtils.isBlank(requestData.getText())) {
83.             throw new ParamException("参数错误");
84.         }
86.         // 获取加密的数据
87.         String text = requestData.getText();
89.         // 放入解密之前的数据
90.         request.setAttribute(CryptoConstant.INPUT_ORIGINAL_DATA, text);
92.         // 解密
93.         String decryptText = null;
94.         try {
95.             decryptText = AESUtil.decrypt(text);
96.         } catch (Exception e) {
97.             throw new ParamException("解密失败");
98.         }
100.         if (StringUtils.isBlank(decryptText)) {
101.             throw new ParamException("解密失败");
102.         }
104.         // 放入解密之后的数据
105.         request.setAttribute(CryptoConstant.INPUT_DECRYPT_DATA, decryptText);
107.         // 获取结果
108.         Object result = objectMapper.readValue(decryptText, body.getClass());
110.         // 强制所有实体类必须继承RequestBase类，设置时间戳
111.         if (result instanceof RequestBase) {
112.             // 获取时间戳
113.             Long currentTimeMillis = ((RequestBase) result).getCurrentTimeMillis();
114.             // 有效期 60秒
115.             long effective = 60*1000;
117.             // 时间差
118.             long expire = System.currentTimeMillis() - currentTimeMillis;
120.             // 是否在有效期内
121.             if (Math.abs(expire) > effective) {
122.                 throw new ParamException("时间戳不合法");
123.             }
125.             // 返回解密之后的数据
126.             return result;
127.         } else {
128.             throw new ParamException(String.format("请求参数类型：%s 未继承：%s", result.getClass().getName(), RequestBase.class.getName()));
129.         }
130.     }
132.     /**
133.      * 如果body为空，转为空对象
134.      * @param body spring解析完的参数
135.      * @param inputMessage 输入参数
136.      * @param parameter 参数对象
137.      * @param targetType 参数类型
138.      * @param converterType 消息转换类型
139.      * @return 真实的参数
140.      */
141.     @SneakyThrows
142.     @Override
143.     public Object handleEmptyBody(Object body, HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
144.         String typeName = targetType.getTypeName();
145.         Class<?> bodyClass = Class.forName(typeName);
146.         return bodyClass.newInstance();
147.     }
148. }

复制代码

EncryptResponseBodyAdvice 相应自动加密

1. package xyz.hlh.crypto.advice;
3. import cn.hutool.json.JSONUtil;
4. import com.fasterxml.jackson.databind.ObjectMapper;
5. import lombok.SneakyThrows;
6. import org.apache.commons.lang3.StringUtils;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.core.MethodParameter;
9. import org.springframework.http.MediaType;
10. import org.springframework.http.ResponseEntity;
11. import org.springframework.http.converter.HttpMessageConverter;
12. import org.springframework.http.server.ServerHttpRequest;
13. import org.springframework.http.server.ServerHttpResponse;
14. import org.springframework.web.bind.annotation.ControllerAdvice;
15. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
16. import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;
17. import xyz.hlh.crypto.annotation.EncryptionAnnotation;
18. import xyz.hlh.crypto.common.entity.Result;
19. import xyz.hlh.crypto.common.exception.CryptoException;
20. import xyz.hlh.crypto.entity.RequestBase;
21. import xyz.hlh.crypto.util.AESUtil;
23. import java.lang.reflect.Type;
25. /**
26. * @author HLH
27. * @description:
28. * @email 17703595860@163.com
29. * @date : Created in 2022/2/4 15:12
30. */
31. @ControllerAdvice
32. public class EncryptResponseBodyAdvice implements ResponseBodyAdvice<Result<?>> {
34.     @Autowired
35.     private ObjectMapper objectMapper;
37.     @Override
38.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
39.         ParameterizedTypeImpl genericParameterType = (ParameterizedTypeImpl)returnType.getGenericParameterType();
41.         // 如果直接是Result，则返回
42.         if (genericParameterType.getRawType() == Result.class && returnType.hasMethodAnnotation(EncryptionAnnotation.class)) {
43.             return true;
44.         }
46.         if (genericParameterType.getRawType() != ResponseEntity.class) {
47.             return false;
48.         }
50.         // 如果是ResponseEntity<Result>
51.         for (Type type : genericParameterType.getActualTypeArguments()) {
52.             if (((ParameterizedTypeImpl) type).getRawType() == Result.class && returnType.hasMethodAnnotation(EncryptionAnnotation.class)) {
53.                 return true;
54.             }
55.         }
57.         return false;
58.     }
60.     @SneakyThrows
61.     @Override
62.     public Result<?> beforeBodyWrite(Result<?> body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
64.         // 加密
65.         Object data = body.getData();
67.         // 如果data为空，直接返回
68.         if (data == null) {
69.             return body;
70.         }
72.         // 如果是实体，并且继承了Request，则放入时间戳
73.         if (data instanceof RequestBase) {
74.             ((RequestBase)data).setCurrentTimeMillis(System.currentTimeMillis());
75.         }
77.         String dataText = JSONUtil.toJsonStr(data);
79.         // 如果data为空，直接返回
80.         if (StringUtils.isBlank(dataText)) {
81.             return body;
82.         }
84.         // 如果位数小于16，报错
85.         if (dataText.length() < 16) {
86.             throw new CryptoException("加密失败，数据小于16位");
87.         }
89.         String encryptText = AESUtil.encryptHex(dataText);
91.         return Result.builder()
92.                 .status(body.getStatus())
93.                 .data(encryptText)
94.                 .message(body.getMessage())
95.                 .build();
96.     }
97. }

复制代码

5.4 crypto-test

5.4.1 结构


5.4.2 重要代码

application.yml 配置文件

1. spring:
2.   mvc:
3.     format:
4.       date-time: yyyy-MM-dd HH:mm:ss
5.       date: yyyy-MM-dd
6.   # 日期格式化
7.   jackson:
8.     date-format: yyyy-MM-dd HH:mm:ss

复制代码

Teacher 实体类

1. package xyz.hlh.crypto.entity;
3. import lombok.AllArgsConstructor;
4. import lombok.Data;
5. import lombok.EqualsAndHashCode;
6. import lombok.NoArgsConstructor;
7. import org.hibernate.validator.constraints.Range;
9. import javax.validation.constraints.NotBlank;
10. import javax.validation.constraints.NotNull;
11. import java.io.Serializable;
12. import java.util.Date;
14. /**
15. * @author HLH
16. * @description: Teacher实体类，使用SpringBoot的validation校验
17. * @email 17703595860@163.com
18. * @date : Created in 2022/2/4 10:21
19. */
20. @Data
21. @NoArgsConstructor
22. @AllArgsConstructor
23. @EqualsAndHashCode(callSuper = true)
24. public class Teacher extends RequestBase implements Serializable {
26.     @NotBlank(message = "姓名不能为空")
27.     private String name;
28.     @NotNull(message = "年龄不能为空")
29.     @Range(min = 0, max = 150, message = "年龄不合法")
30.     private Integer age;
31.     @NotNull(message = "生日不能为空")
32.     private Date birthday;
34. }

复制代码

TestController 测试Controller
[code]package xyz.hlh.crypto.controller;import org.springframework.http.ResponseEntity;import org.springframework.validation.annotation.Validated;import org.springframework.web.bind.annotation.PostMapping;import org.springframework.web.bind.annotation.RequestBody;import org.springframework.web.bind.annotation.RestController;import xyz.hlh.crypto.annotation.DecryptionAnnotation;import xyz.hlh.crypto.annotation.EncryptionAnnotation;import xyz.hlh.crypto.common.entity.Result;import xyz.hlh.crypto.common.entity.ResultBuilder;import xyz.hlh.crypto.entity.Teacher;/** * @author HLH * @description: 测试Controller * @email 17703595860@163.com * @date : Created in 2022/2/4 9:16 */@RestControllerpublic class TestController implements ResultBuilder {    /**     * 直接返回对象，不加密     * @param teacher Teacher对象     * @return 不加密的对象     */    @PostMapping("/get")    public ResponseEntity> encrypt(@Validated @RequestBody Teacher teacher) {        return success(teacher);    }    /**     * 返回加密后的数据     * @param teacher Teacher对象     * @return 返回加密后的数据 Result格式     */    @PostMapping("/encrypt1")    @EncryptionAnnotation    public Result encrypt1(@Validated @RequestBody Teacher teacher) {        return success(teacher).getBody();    }    /**     * 返回解密后的数据     * @param teacher Teacher对象     * @return 返回解密后的数据     */    @PostMapping("/decrypt")    @DecryptionAnnotation    public ResponseEntity