Spring接口统一加密解密

又是分享欲爆棚的一天，实现一个接口统一加解密需求。。。

前置条件 ：

Controller 携带@RestController 或者 方法携带 @ResponseBody 注解

并且 是 body 请求 也就是application/json，接口参数携带 @RequestBody 注解

非以上条件会有一些小毛病、自行尝试！！！

注意 //TODO 的地方按需调整即可

直接上代码 ，CV 后简单修改即可使用。因为我是把所有的类都放一起了，真正使用还是看你们自己的项目结构，自行安排！

package com.hope.saas.bfs.merchant.performance.handler;

import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;

/**
 * 数据转码
 *
 * @Description 数据转码 加解密
 * @Author Mr.dan
 * @Date 2023-03-28 26:47
 */
@Slf4j
@RestControllerAdvice
public class DataTranscodingHandler implements RequestBodyAdvice, ResponseBodyAdvice {
    public @interface IgnoreTranscoding { }

    /**
     * 实现一个 HttpInputMessage
     */
    public class MyHttpInputMessage implements HttpInputMessage {
        /**
         * 请求头
         */
        private HttpHeaders httpHeaders;
        /**
         * 加密请求体
         */
        private InputStream body;
       
        public MyHttpInputMessage(HttpHeaders httpHeaders, InputStream body) {
            this.httpHeaders = httpHeaders;
            this.body = body;
        }
        @Override
        public HttpHeaders getHeaders() {
            //如果需要处理请求头在这里操作
            return this.httpHeaders;
        }
        /**
         * 重写他的 getBody 方法 提供给spring调用
         * 在这里执行你的解密操作
         *
         * @return 返回 spring 需要的输入流
         * @throws IOException
         */
        @Override
        public InputStream getBody() throws IOException {
            int available = this.body.available();
            byte[] bytes = new byte[available];
            //只要读取过 输入流就会被关闭。。。应该是为了节省空间
            log.info("读取前长度：" + this.body.available());
            body.read(bytes);
            log.info("读取后长度：" + this.body.available());
            String reqStr = new String(bytes);
            Req req = JSON.parseObject(reqStr, Req.class);
            //TODO 这一块，校验签名，时效性等等 规则按你自己的需求来（可要可不要）
            String requestId = req.getRequestId();
            String sign = req.getSign();
            Long timeStamp = req.getTimeStamp();
            //TODO data 为需要处理的参数 如果是加密的 则进行解密后传入 getInputStream
            String data = req.getData();
            return getInputStream(data);
        }
    }
    
    @Override
    public Object beforeBodyWrite(
            Object body,
            MethodParameter returnType,
            MediaType selectedContentType,
            Class selectedConverterType,
            ServerHttpRequest request,
            ServerHttpResponse response
    ) {
        log.info("》》》》》》》》》 resp.beforeBodyWrite 执行加密操作");
        //这里的Rep 代表你Controller接口统一格式的返回对象
        Rep result = (Rep) body;
        //TODO 这里执行你的加密操作 我这里仅仅做了个判断
        Object data = result.getData();
        result.setData(data == null ? "" : data);
        return body;
    }

    /**
     * 确定是否需要执行后续方法 beforeBodyRead，afterBodyRead，handleEmptyBody
     *
     * @param methodParameter 方法参数
     * @param targetType      目标类型
     * @param converterType   转换类型
     * @return
     */
    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        log.info("》》》》》》》》》 req.supports 预校验是否需要解密处理");
        //获取不到 IgnoreTranscoding 注解 则执行解密操作
        return methodParameter.getMethodAnnotation(IgnoreTranscoding.class) == null;
    }

    /**
     * 读取Body参数前
     *
     * @param inputMessage
     * @param parameter
     * @param targetType
     * @param converterType
     * @return
     * @throws IOException
     */
    @Override
    public HttpInputMessage beforeBodyRead(
            HttpInputMessage inputMessage,
            MethodParameter parameter,
            Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
        log.info("》》》》》》》》》 执行解密");
        return new MyHttpInputMessage(inputMessage.getHeaders(), inputMessage.getBody());
    }

    /**
     * 读取Body 参数后
     *
     * @param body
     * @param inputMessage
     * @param parameter
     * @param targetType
     * @param converterType
     * @return
     */
    @Override
    public Object afterBodyRead(
            Object body,
            HttpInputMessage inputMessage,
            MethodParameter parameter,
            Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType) {
        log.info("》》 req.afterBodyRead 解密后已经封装成了指定对象发送给下一个处理器: {}", body);
        return body;
    }

    /**
     * 处理实体类
     *
     * @param body
     * @param inputMessage
     * @param parameter
     * @param targetType
     * @param converterType
     * @return
     */
    @Override
    public Object handleEmptyBody(
            Object body,
            HttpInputMessage inputMessage,
            MethodParameter parameter,
            Type targetType,
            Class<? extends HttpMessageConverter<?>> converterType
    ) {
        //这里一直不触发搞不懂 可以不管
        log.info("》》 req.handleEmptyBody");
        return body;
    }

    /**
     * 响应前
     *
     * @param returnType    返回值类型
     * @param converterType
     * @return
     */
    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        log.info("》》 resp.supports 判断是否需要加密操作");
        //获取不到 IgnoreTranscoding 注解 则执行加密操作
        return returnType.getMethodAnnotation(IgnoreTranscoding.class) == null;
    }

    public InputStream getInputStream(String data) {
        return new ByteArrayInputStream(data.getBytes());
    }

    @Data
    @Builder
    @AllArgsConstructor
    @NoArgsConstructor
    public static class Rep<T> {
        /**
         * 响应码 （前端可以根据此代码判断成功与失败）
         */
        private String code;
        //提示
        private String message;
        ///携带数据
        private T data;

        /**
         * 返回成功并携带数据
         *
         * @param data
         * @param <T>
         * @return
         */
        public static <T> Rep data(T data) {
            return Rep.builder()
                    .code("200")
                    .message("成功")
                    .data(data)
                    .build();
        }

        /**
         * 返回成功不携带数据
         *
         * @return
         */
        public static Rep success() {
            return Rep.builder()
                    .code("200")
                    .message("成功")
                    .build();
        }

    }

    @Data
    public class Req {
        /**
         * 请求号 随机生成即可
         */
        private String requestId;
        /**
         * 签名串，根据 data + timeStamp 进行 SHA256 加密生成
         */
        private String sign;
        /**
         * 时间戳
         */
        private Long timeStamp;
        /**
         * 加密后的数据  将 body 参数（json串）按升序排列后 使用 publicKey 生成
         */
        private String data;
    }
}

前端请求格式