• SpringBoot中接口加密解密统一处理！

    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。

    这样就实现了流的重复获取

    InputStreamHttpServletRequestWrapper

    1. package xyz.hlh.cryptotest.utils;
    2.  
    3. import org.apache.commons.io.IOUtils;
    4.  
    5. import javax.servlet.ReadListener;
    6. import javax.servlet.ServletInputStream;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletRequestWrapper;
    9. import java.io.BufferedReader;
    10. import java.io.ByteArrayInputStream;
    11. import java.io.ByteArrayOutputStream;
    12. import java.io.IOException;
    13. import java.io.InputStreamReader;
    14.  
    15. /**
    16.  * 请求流支持多次获取
    17.  */
    18. public class InputStreamHttpServletRequestWrapper extends HttpServletRequestWrapper {
    19.  
    20.     /**
    21.      * 用于缓存输入流
    22.      */
    23.     private ByteArrayOutputStream cachedBytes;
    24.  
    25.     public InputStreamHttpServletRequestWrapper(HttpServletRequest request) {
    26.         super(request);
    27.     }
    28.  
    29.     @Override
    30.     public ServletInputStream getInputStream() throws IOException {
    31.         if (cachedBytes == null) {
    32.             // 首次获取流时，将流放入 缓存输入流 中
    33.             cacheInputStream();
    34.         }
    35.  
    36.         // 从 缓存输入流 中获取流并返回
    37.         return new CachedServletInputStream(cachedBytes.toByteArray());
    38.     }
    39.  
    40.     @Override
    41.     public BufferedReader getReader() throws IOException {
    42.         return new BufferedReader(new InputStreamReader(getInputStream()));
    43.     }
    44.  
    45.     /**
    46.      * 首次获取流时，将流放入 缓存输入流 中
    47.      */
    48.     private void cacheInputStream() throws IOException {
    49.         // 缓存输入流以便多次读取。为了方便, 我使用 org.apache.commons IOUtils
    50.         cachedBytes = new ByteArrayOutputStream();
    51.         IOUtils.copy(super.getInputStream(), cachedBytes);
    52.     }
    53.  
    54.     /**
    55.      * 读取缓存的请求正文的输入流
    56.      * 
    57.      * 用于根据 缓存输入流 创建一个可返回的
    58.      */
    59.     public static class CachedServletInputStream extends ServletInputStream {
    60.  
    61.         private final ByteArrayInputStream input;
    62.  
    63.         public CachedServletInputStream(byte[] buf) {
    64.             // 从缓存的请求正文创建一个新的输入流
    65.             input = new ByteArrayInputStream(buf);
    66.         }
    67.  
    68.         @Override
    69.         public boolean isFinished() {
    70.             return false;
    71.         }
    72.  
    73.         @Override
    74.         public boolean isReady() {
    75.             return false;
    76.         }
    77.  
    78.         @Override
    79.         public void setReadListener(ReadListener listener) {
    80.  
    81.         }
    82.  
    83.         @Override
    84.         public int read() throws IOException {
    85.             return input.read();
    86.         }
    87.     }
    88.  
    89. }

    HttpServletRequestInputStreamFilter

    1. package xyz.hlh.cryptotest.filter;
    2.  
    3. import org.springframework.core.annotation.Order;
    4. import org.springframework.stereotype.Component;
    5. import xyz.hlh.cryptotest.utils.InputStreamHttpServletRequestWrapper;
    6.  
    7. import javax.servlet.Filter;
    8. import javax.servlet.FilterChain;
    9. import javax.servlet.ServletException;
    10. import javax.servlet.ServletRequest;
    11. import javax.servlet.ServletResponse;
    12. import javax.servlet.http.HttpServletRequest;
    13. import java.io.IOException;
    14.  
    15. import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE;
    16.  
    17. /**
    18.  * @author HLH
    19.  * @description:
    20.  *      请求流转换为多次读取的请求流 过滤器
    21.  * @email 17703595860@163.com
    22.  * @date : Created in 2022/2/4 9:58
    23.  */
    24. @Component
    25. @Order(HIGHEST_PRECEDENCE + 1)  // 优先级最高
    26. public class HttpServletRequestInputStreamFilter implements Filter {
    27.  
    28.     @Override
    29.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
    30.  
    31.         // 转换为可以多次获取流的request
    32.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
    33.         InputStreamHttpServletRequestWrapper inputStreamHttpServletRequestWrapper = new InputStreamHttpServletRequestWrapper(httpServletRequest);
    34.  
    35.         // 放行
    36.         chain.doFilter(inputStreamHttpServletRequestWrapper, response);
    37.     }
    38. }

    2.3 SpringBoot的参数校验validation

    为了减少接口中，业务代码之前的大量冗余的参数校验代码

    SpringBoot-validation提供了优雅的参数校验，入参都是实体类，在实体类字段上加上对应注解，就可以在进入方法之前，进行参数校验，如果参数错误，会抛出错误BindException，是不会进入方法的。

    这种方法，必须要求在接口参数上加注解@Validated或者是@Valid

    但是很多清空下，我们希望在代码中调用某个实体类的校验功能，所以需要如下工具类

    ParamException

    1. package xyz.hlh.cryptotest.exception;
    2.  
    3. import lombok.Getter;
    4.  
    5. import java.util.List;
    6.  
    7. /**
    8.  * @author HLH
    9.  * @description 自定义参数异常
    10.  * @email 17703595860@163.com
    11.  * @date Created in 2021/8/10 下午10:56
    12.  */
    13. @Getter
    14. public class ParamException extends Exception {
    15.  
    16.     private final List<String> fieldList;
    17.     private final List<String> msgList;
    18.  
    19.     public ParamException(List<String> fieldList, List<String> msgList) {
    20.         this.fieldList = fieldList;
    21.         this.msgList = msgList;
    22.     }
    23. }

    ValidationUtils

    1. package xyz.hlh.cryptotest.utils;
    2.  
    3. import xyz.hlh.cryptotest.exception.CustomizeException;
    4. import xyz.hlh.cryptotest.exception.ParamException;
    5.  
    6. import javax.validation.ConstraintViolation;
    7. import javax.validation.Validation;
    8. import javax.validation.Validator;
    9. import java.util.LinkedList;
    10. import java.util.List;
    11. import java.util.Set;
    12.  
    13. /**
    14.  * @author HLH
    15.  * @description 验证工具类
    16.  * @email 17703595860@163.com
    17.  * @date Created in 2021/8/10 下午10:56
    18.  */
    19. public class ValidationUtils {
    20.  
    21.     private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();
    22.  
    23.     /**
    24.      * 验证数据
    25.      * @param object 数据
    26.      */
    27.     public static void validate(Object object) throws CustomizeException {
    28.  
    29.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object);
    31.         // 验证结果异常
    32.         throwParamException(validate);
    33.     }
    34.  
    35.     /**
    36.      * 验证数据(分组)
    37.      * @param object 数据
    38.      * @param groups 所在组
    39.      */
    40.     public static void validate(Object object, Class<?> ... groups) throws CustomizeException {
    41.  
    42.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validate(object, groups);
    44.         // 验证结果异常
    45.         throwParamException(validate);
    46.     }
    47.  
    48.     /**
    49.      * 验证数据中的某个字段(分组)
    50.      * @param object 数据
    51.      * @param propertyName 字段名称
    52.      */
    53.     public static void validate(Object object, String propertyName) throws CustomizeException {
    54.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName);
    56.         // 验证结果异常
    57.         throwParamException(validate);
    58.  
    59.     }
    60.  
    61.     /**
    62.      * 验证数据中的某个字段(分组)
    63.      * @param object 数据
    64.      * @param propertyName 字段名称
    65.      * @param groups 所在组
    66.      */
    67.     public static void validate(Object object, String propertyName, Class<?> ... groups) throws CustomizeException {
    68.  
    69.         Set<ConstraintViolation<Object>> validate = VALIDATOR.validateProperty(object, propertyName, groups);
    71.         // 验证结果异常
    72.         throwParamException(validate);
    73.  
    74.     }
    75.  
    76.     /**
    77.      * 验证结果异常
    78.      * @param validate 验证结果
    79.      */
    80.     private static void throwParamException(Set<ConstraintViolation<Object>> validate) throws CustomizeException {
    81.         if (validate.size() > 0) {
    82.             List<String> fieldList = new LinkedList<>();
    83.             List<String> msgList = new LinkedList<>();
    84.             for (ConstraintViolation<Object> next : validate) {
    85.                 fieldList.add(next.getPropertyPath().toString());
    86.                 msgList.add(next.getMessage());
    87.             }
    88.  
    89.             throw new ParamException(fieldList, msgList);
    90.         }
    91.     }
    92.  
    93. }

    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;
    2.  
    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;
    11.  
    12. import java.io.Serializable;
    13.  
    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 {
    27.  
    28.     private Mode mode;
    29.     private Padding padding;
    30.     private String key;
    31.     private String iv;
    32.  
    33. }

    AppConfig 自动配置类

    1. package xyz.hlh.crypto.config;
    2.  
    3. import cn.hutool.crypto.symmetric.AES;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7. import javax.annotation.Resource;
    8. import java.nio.charset.StandardCharsets;
    9.  
    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 {
    18.  
    19.     @Resource
    20.     private CryptConfig cryptConfig;
    21.  
    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.     }
    26.  
    27. }

    DecryptRequestBodyAdvice 请求自动解密

    1. package xyz.hlh.crypto.advice;
    2.  
    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;
    21.  
    22. import javax.servlet.ServletInputStream;
    23. import javax.servlet.http.HttpServletRequest;
    24. import java.io.IOException;
    25. import java.lang.reflect.Type;
    26.  
    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 {
    35.  
    36.     @Autowired
    37.     private ObjectMapper objectMapper;
    38.  
    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.     }
    50.  
    51.     @Override
    52.     public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
    53.         return inputMessage;
    54.     }
    55.  
    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.         }
    75.  
    76.         HttpServletRequest request = servletRequestAttributes.getRequest();
    77.  
    78.         // 获取数据
    79.         ServletInputStream inputStream = request.getInputStream();
    80.         RequestData requestData = objectMapper.readValue(inputStream, RequestData.class);
    81.  
    82.         if (requestData == null || StringUtils.isBlank(requestData.getText())) {
    83.             throw new ParamException("参数错误");
    84.         }
    85.  
    86.         // 获取加密的数据
    87.         String text = requestData.getText();
    88.  
    89.         // 放入解密之前的数据
    90.         request.setAttribute(CryptoConstant.INPUT_ORIGINAL_DATA, text);
    91.  
    92.         // 解密
    93.         String decryptText = null;
    94.         try {
    95.             decryptText = AESUtil.decrypt(text);
    96.         } catch (Exception e) {
    97.             throw new ParamException("解密失败");
    98.         }
    99.  
    100.         if (StringUtils.isBlank(decryptText)) {
    101.             throw new ParamException("解密失败");
    102.         }
    103.  
    104.         // 放入解密之后的数据
    105.         request.setAttribute(CryptoConstant.INPUT_DECRYPT_DATA, decryptText);
    106.  
    107.         // 获取结果
    108.         Object result = objectMapper.readValue(decryptText, body.getClass());
    109.  
    110.         // 强制所有实体类必须继承RequestBase类，设置时间戳
    111.         if (result instanceof RequestBase) {
    112.             // 获取时间戳
    113.             Long currentTimeMillis = ((RequestBase) result).getCurrentTimeMillis();
    114.             // 有效期 60秒
    115.             long effective = 60*1000;
    116.  
    117.             // 时间差
    118.             long expire = System.currentTimeMillis() - currentTimeMillis;
    119.  
    120.             // 是否在有效期内
    121.             if (Math.abs(expire) > effective) {
    122.                 throw new ParamException("时间戳不合法");
    123.             }
    124.  
    125.             // 返回解密之后的数据
    126.             return result;
    127.         } else {
    128.             throw new ParamException(String.format("请求参数类型：%s 未继承：%s", result.getClass().getName(), RequestBase.class.getName()));
    129.         }
    130.     }
    131.  
    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;
    2.  
    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;
    22.  
    23. import java.lang.reflect.Type;
    24.  
    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;
    36.  
    37.     @Override
    38.     public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
    39.         ParameterizedTypeImpl genericParameterType = (ParameterizedTypeImpl)returnType.getGenericParameterType();
    40.  
    41.         // 如果直接是Result，则返回
    42.         if (genericParameterType.getRawType() == Result.class && returnType.hasMethodAnnotation(EncryptionAnnotation.class)) {
    43.             return true;
    44.         }
    45.  
    46.         if (genericParameterType.getRawType() != ResponseEntity.class) {
    47.             return false;
    48.         }
    49.  
    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.         }
    56.  
    57.         return false;
    58.     }
    59.  
    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();
    66.  
    67.         // 如果data为空，直接返回
    68.         if (data == null) {
    69.             return body;
    70.         }
    71.  
    72.         // 如果是实体，并且继承了Request，则放入时间戳
    73.         if (data instanceof RequestBase) {
    74.             ((RequestBase)data).setCurrentTimeMillis(System.currentTimeMillis());
    75.         }
    76.  
    77.         String dataText = JSONUtil.toJsonStr(data);
    78.  
    79.         // 如果data为空，直接返回
    80.         if (StringUtils.isBlank(dataText)) {
    81.             return body;
    82.         }
    83.  
    84.         // 如果位数小于16，报错
    85.         if (dataText.length() < 16) {
    86.             throw new CryptoException("加密失败，数据小于16位");
    87.         }
    88.  
    89.         String encryptText = AESUtil.encryptHex(dataText);
    90.  
    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;
    2.  
    3. import lombok.AllArgsConstructor;
    4. import lombok.Data;
    5. import lombok.EqualsAndHashCode;
    6. import lombok.NoArgsConstructor;
    7. import org.hibernate.validator.constraints.Range;
    8.  
    9. import javax.validation.constraints.NotBlank;
    10. import javax.validation.constraints.NotNull;
    11. import java.io.Serializable;
    12. import java.util.Date;
    13.  
    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 {
    25.  
    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;
    33.  
    34. }

    TestController 测试Controller

    1. package xyz.hlh.crypto.controller;
    2.  
    3. import org.springframework.http.ResponseEntity;
    4. import org.springframework.validation.annotation.Validated;
    5. import org.springframework.web.bind.annotation.PostMapping;
    6. import org.springframework.web.bind.annotation.RequestBody;
    7. import org.springframework.web.bind.annotation.RestController;
    8. import xyz.hlh.crypto.annotation.DecryptionAnnotation;
    9. import xyz.hlh.crypto.annotation.EncryptionAnnotation;
    10. import xyz.hlh.crypto.common.entity.Result;
    11. import xyz.hlh.crypto.common.entity.ResultBuilder;
    12. import xyz.hlh.crypto.entity.Teacher;
    13.  
    14. /**
    15.  * @author HLH
    16.  * @description: 测试Controller
    17.  * @email 17703595860@163.com
    18.  * @date : Created in 2022/2/4 9:16
    19.  */
    20. @RestController
    21. public class TestController implements ResultBuilder {
    22.  
    23.     /**
    24.      * 直接返回对象，不加密
    25.      * @param teacher Teacher对象
    26.      * @return 不加密的对象
    27.      */
    28.     @PostMapping("/get")
    29.     public ResponseEntity<Result<?>> get(@Validated @RequestBody Teacher teacher) {
    30.         return success(teacher);
    31.     }
    32.  
    33.     /**
    34.      * 返回加密后的数据
    35.      * @param teacher Teacher对象
    36.      * @return 返回加密后的数据 ResponseBody<Result>格式
    37.      */
    38.     @PostMapping("/encrypt")
    39.     @EncryptionAnnotation
    40.     public ResponseEntity<Result<?>> encrypt(@Validated @RequestBody Teacher teacher) {
    41.         return success(teacher);
    42.     }
    43.  
    44.     /**
    45.      * 返回加密后的数据
    46.      * @param teacher Teacher对象
    47.      * @return 返回加密后的数据 Result格式
    48.      */
    49.     @PostMapping("/encrypt1")
    50.     @EncryptionAnnotation
    51.     public Result<?> encrypt1(@Validated @RequestBody Teacher teacher) {
    52.         return success(teacher).getBody();
    53.     }
    54.  
    55.     /**
    56.      * 返回解密后的数据
    57.      * @param teacher Teacher对象
    58.      * @return 返回解密后的数据
    59.      */
    60.     @PostMapping("/decrypt")
    61.     @DecryptionAnnotation
    62.     public ResponseEntity<Result<?>> decrypt(@Validated @RequestBody Teacher teacher) {
    63.         return success(teacher);
    64.     }
    65.  
    66. }
  • 相关阅读:
    mac搭建redis集群
    C++类与对象（下）
    初探JVM
    python opencv2滚轮快速切换图片
    【QT小记】QT中信号和槽的基本使用
    MySQL常见知识点（面试题）总结
    数字电路和模拟电路-9时序逻辑电路、计数器和寄存器
    初识EasyAR
    金仓数据库 KingbaseGIS 使用手册（8.11. 栅格处理函数）
    C++中cin输入空格
  • 原文地址：https://blog.csdn.net/m0_71777195/article/details/127960267