核心思路

1. 拦截每次请求 所以要么在拦截器 要么在过滤器中做 (正常来说 其实只能在过滤器做)
2. 修改request中的参数
3. 把修改后的参数设置回去(难点）

spring&servelt基础

每个http请求都是访问了一个servlet，servlet有过滤器filter的概念。

在spring框架中 其实就是封装了一个DispatcherServlet，并且实现了各种过滤器和拦截器。

在过滤器中，有很重要的一个步骤：
传递过滤链，用通俗的话解释就是 当前过滤器的一顿操作 不能阻碍了其它过滤器的执行，所以需要将request和response传递给下一个过滤器

filterChain.doFilter(request, response);

所以我们在过滤器中进行解密，并将request的值修改后传递，这样可以保证每个过滤器拿到的都是解密后的值。

如果是在拦截器里面做，那可能在过滤器就出现了报错（取决于过滤器自定义的功能复不复杂 有没有涉及参数解密）, 我们避免节外生枝 本文都是在过滤器里面进行解密。

核心接口类

1. HttpServletRequestWrapper
   这里补充一个基础知识，流读了一遍之后就不能再读取了，所以需要通过这个包装类，使得流可以重复使用

2. ServletInputStream
   与HttpServletRequestWrapper的子类配合使用 重写读取流的方法

3. OncePerRequestFilter
   拦截每次请求的过滤器

(注：本文代码是demo 不推荐复制即用，最好需要有自己的理解)

@Configuration
public class DecryptRequestFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest  request, HttpServletResponse  response, FilterChain chain)
            throws IOException, ServletException {
        // 包装请求对象
        CustomHttpServletRequestWrapper wrappedRequest = new CustomHttpServletRequestWrapper(request);
        // 继续过滤链，使用包装后的请求对象
        chain.doFilter(wrappedRequest, response);
    }

}

import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletRequestWrapper;
import org.apache.catalina.util.ParameterMap;
import org.springframework.web.servlet.HandlerMapping;

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
public class CustomHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private  byte[] body;
    private final Map<String, String[]> params = new HashMap<>();
    private final Map<String, String> pathVariables = new HashMap<>();

    public CustomHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        // 读取并缓存请求体内容
        String s = new String(readBytes(request.getInputStream()), StandardCharsets.UTF_8);
        // 这里模拟的body解密
        String replace = s.replace("孟秋", "大孟秋");
        body = replace.getBytes(StandardCharsets.UTF_8);

        ParameterMap<String, String[]> parameterMap = (ParameterMap<String, String[]>) request.getParameterMap();
        parameterMap.setLocked(false);
        for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
        	// 取值
            String[] value = entry.getValue();
            String s1 = value[0];
            
		    // 模拟解密
            parameterMap.put(entry.getKey(), new String[]{"解密参数"});
        }
        parameterMap.setLocked(true);
        this.params.putAll(decryptParams(parameterMap));
        // spring自带的是PathVariableMethodArgumentResolver类来处理 但是它不让重写
 // PathVariables 解密暂时还没做 这里只是取值了， 暂没考虑如何解密并设置回去
        decryptPathVariables((Map<String, String>) request.getAttribute(HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE));
    }

    private byte[] readBytes(InputStream inputStream) throws IOException {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int length;
        while ((length = inputStream.read(buffer)) != -1) {
            byteArrayOutputStream.write(buffer, 0, length);
        }
        return byteArrayOutputStream.toByteArray();
    }


    private Map<String, String[]> decryptParams(Map<String, String[]> parameterMap) {
        // 解密逻辑
        return parameterMap; // 示例
    }

    private void decryptPathVariables(Map<String, String> pathVariables) {
        if (pathVariables == null) {
            return;
        }
        pathVariables.entrySet().forEach(
                item ->{
                    // 解密逻辑
                    this.pathVariables.put(item.getKey(),item.getValue()+"解密");
                }
        );
    }

    @Override
    public String getParameter(String name) {
        String[] paramArray = params.get(name);
        return paramArray != null && paramArray.length > 0 ? paramArray[0] : null;
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        return params;
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] parameterValues = super.getParameterValues(name);
		// 模拟get请求(query请求 即form表单提交)的解密
        return new String[]{"加密"};
    }

    @Override
    public Enumeration<String> getAttributeNames() {
        return super.getAttributeNames();
    }

    @Override
    public Object getAttribute(String name) {
        return super.getAttribute(name);
    }

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

    @Override
    public ServletInputStream getInputStream() throws IOException {
        String s = new String(body, StandardCharsets.UTF_8);
        System.out.println(s);
        return new CachedBodyServletInputStream(body);
    }

    @Override
    public String getRequestURI() {
        String uri = super.getRequestURI();
        for (Map.Entry<String, String> entry : pathVariables.entrySet()) {
            uri = uri.replace("{" + entry.getKey() + "}", entry.getValue());
        }
        return uri;
    }
}

body解密核心原理讲解

核心:

1. request.getInputStream的流缓存起来
2. 改写缓存流的内容 实现解密
3. 重写了HttpServletRequestWrapper类的getInputStream方法 该方法就是获取我们缓存起来的流 这样在controller层 @RequestBody获取的就是我们的缓存流（解密后的流）对应的内容

get解密核心原理讲解

get比body难一些，踩的坑也不少

先将参数取出来
(代码片段截取的上文代码)

       ParameterMap<String, String[]> parameterMap = (ParameterMap<String, String[]>) request.getParameterMap();

如果这个时候我们直接遍历map 并重新put修改值 是会报错的

      for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
      		// 取值
            String[] value = entry.getValue();
            String s1 = value[0];
            
			 // 这里是模拟解密
            parameterMap.put(entry.getKey(), new String[]{"解密参数"});
        }

会报错不支持操作 not supportException,如果这时候放弃就大意了，我们跟进源码看看为什么抛异常：

可以看到 如果locked 则会抛出异常，而它又提供了一个public的setLocked的类

所以这就是为什么代码中 会有这一行

   parameterMap.setLocked(false);

我们先把锁打开后，往map里面修改了内容，还需要把锁关上, 我们看ParameterMap类的源码也能看到 它有很多地方是通过判断是否锁了 我们不能改变原来的逻辑。

	// 修改完map后重新上锁
   parameterMap.setLocked(true);

如果我们的controller是 :

@GetMapping
public void test(Request request)

那么直接request.getParameterMap就可以获取解密后的参数了

众所周知 我们都用了spring/springboot 早就不太可能这么写丑陋代码了，更多时候是如下：

@GetMapping
public void test(String name)

这个时候会发现 明明reqeust的parameterMap被修改了，但是name参数竟然还是原始的值！
这个时候就需要打个断点调试了，博主经过调试后发现 最后是动态代理传的参改变了，servlet到controller层的过程中 虽然一开始确实是传的reqeust 但在某一步时 它去获取了parameterValues ！

parameterMap变量位于org.apache.catalina.connector.Request类

而parameterValues变量位于org.apache.tomcat.util.http.Parameters类

(上面两个源码类都是基于springboot3版本自带的tomcat包，springboot2可能会有差异，博主推测都可以从RequestFacade类作为入口看)

所以我们需要在HttpServletRequestWrapper的子类 CustomHttpServletRequestWrapper 中重写parameterValues方法

(避免数据不一致情况下 我们map和values方法都将解密数据放进去)