springboot接口统一加密解密

1. 介绍2. 前置知识

2.1 hutool-crypto加密解密工具2.2 request流只能读取一次的问题

2.2.1 问题：2.2.2 解决办法 2.3 SpringBoot的参数校验validation2.5 自定义starter2.6 RequestBodyAdvice和ResponseBodyAdvice 3. 功能介绍4. 功能细节5. 代码实现

5.1 项目结构5.2 crypto-common

5.2.1 结构 5.3 crypto-spring-boot-starter

5.3.1 接口5.3.2 重要代码 5.4 crypto-test

5.4.1 结构5.4.2 重要代码

在我们日常的Java开发中，免不了和其他系统的业务交互，或者微服务之间的接口调用

如果我们想保证数据传输的安全，对接口出参加密，入参解密。

但是不想写重复代码，我们可以提供一个通用starter，提供通用加密解密功能

hutool-crypto提供了很多加密解密工具，包括对称加密，非对称加密，摘要加密等等，这不做详细介绍，可参照Hutool-crypto加密解密_HLH_2021的博客-CSDN博客，这篇文章了解此工具

在接口调用链中，request的请求流只能调用一次，处理之后，如果之后还需要用到请求流获取数据，就会发现数据为空。

比如使用了filter或者aop在接口处理之前，获取了request中的数据，对参数进行了校验，那么之后就不能在获取request请求流了

继承HttpServletRequestWrapper，将请求中的流copy一份，复写getInputStream和getReader方法供外部使用。每次调用后的getInputStream方法都是从复制出来的二进制数组中进行获取，这个二进制数组在对象存在期间一致存在。

使用Filter过滤器，在一开始，替换request为自己定义的可以多次读取流的request。

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

InputStreamHttpServletRequestWrapper

package xyz.hlh.cryptotest.utils;

import org.apache.commons.io.IOUtils;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;


public class InputStreamHttpServletRequestWrapper extends HttpServletRequestWrapper {

    
    private ByteArrayOutputStream cachedBytes;

    public InputStreamHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        if (cachedBytes == null) {
            // 首次获取流时，将流放入 缓存输入流 中
            cacheInputStream();
        }

        // 从 缓存输入流 中获取流并返回
        return new CachedServletInputStream(cachedBytes.toByteArray());
    }

    @Override
    public BufferedReader getReader() throws IOException {
        return new BufferedReader(new InputStreamReader(getInputStream()));
    }

    
    private void cacheInputStream() throws IOException {
        // 缓存输入流以便多次读取。为了方便, 我使用 org.apache.commons IOUtils
        cachedBytes = new ByteArrayOutputStream();
        IOUtils.copy(super.getInputStream(), cachedBytes);
    }

    
    public static class CachedServletInputStream extends ServletInputStream {

        private final ByteArrayInputStream input;

        public CachedServletInputStream(byte[] buf) {
            // 从缓存的请求正文创建一个新的输入流
            input = new ByteArrayInputStream(buf);
        }

        @Override
        public boolean isFinished() {
            return false;
        }

        @Override
        public boolean isReady() {
            return false;
        }

        @Override
        public void setReadListener(ReadListener listener) {

        }

        @Override
        public int read() throws IOException {
            return input.read();
        }
    }

}

HttpServletRequestInputStreamFilter

package xyz.hlh.cryptotest.filter;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import xyz.hlh.cryptotest.utils.InputStreamHttpServletRequestWrapper;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

import static org.springframework.core.Ordered.HIGHEST_PRECEDENCE;


@Component
@Order(HIGHEST_PRECEDENCE + 1)  // 优先级最高
public class HttpServletRequestInputStreamFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

        // 转换为可以多次获取流的request
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        InputStreamHttpServletRequestWrapper inputStreamHttpServletRequestWrapper = new InputStreamHttpServletRequestWrapper(httpServletRequest);

        // 放行
        chain.doFilter(inputStreamHttpServletRequestWrapper, response);
    }
}

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

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

详情参照文章：springboot参数校验validation_HLH_2021的博客-CSDN博客

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

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

ParamException

package xyz.hlh.cryptotest.exception;

import lombok.Getter;

import java.util.List;


@Getter
public class ParamException extends Exception {

    private final List fieldList;
    private final List msgList;

    public ParamException(List fieldList, List msgList) {
        this.fieldList = fieldList;
        this.msgList = msgList;
    }
}

ValidationUtils

package xyz.hlh.cryptotest.utils;

import xyz.hlh.cryptotest.exception.CustomizeException;
import xyz.hlh.cryptotest.exception.ParamException;

import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.Validator;
import java.util.linkedList;
import java.util.List;
import java.util.Set;


public class ValidationUtils {

    private static final Validator VALIDATOR = Validation.buildDefaultValidatorFactory().getValidator();

    
    public static void validate(Object object) throws CustomizeException {

        Set> validate = VALIDATOR.validate(object);

        // 验证结果异常
        throwParamException(validate);
    }

    
    public static void validate(Object object, Class ... groups) throws CustomizeException {

        Set> validate = VALIDATOR.validate(object, groups);

        // 验证结果异常
        throwParamException(validate);
    }

    
    public static void validate(Object object, String propertyName) throws CustomizeException {
        Set> validate = VALIDATOR.validateProperty(object, propertyName);

        // 验证结果异常
        throwParamException(validate);

    }

    
    public static void validate(Object object, String propertyName, Class ... groups) throws CustomizeException {

        Set> validate = VALIDATOR.validateProperty(object, propertyName, groups);

        // 验证结果异常
        throwParamException(validate);

    }

    
    private static void throwParamException(Set> validate) throws CustomizeException {
        if (validate.size() > 0) {
            List fieldList = new linkedList<>();
            List msgList = new linkedList<>();
            for (ConstraintViolation