利用HttpServletRequestWrapper来支持可重复读取HttpServletRequest中的请求输入流且不影响Controller层的参数获取

已于 2023-02-22 10:03:26 修改
阅读量3.6k 收藏 7
点赞数
文章标签： java 后端 spring boot
于 2021-01-20 18:22:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LSL1618/article/details/112907142
版权

HttpServletRequest中的请求输入流不可重复读取的原因就不叙述了，一堆搜索结果随便看，解决方案有2种，1是使用Spring MVC自带的类ContentCachingRequestWrapper，2是自定义请求包装器，方案2请看如下步骤正文：

1. 定义请求包装器，继承于 HttpServletRequestWrapper


import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.MediaType;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;

import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.*;

/**
 * 自定义请求包装器，用于存储请求body数据，以解决请求输入流只能读取一次的问题
 */
@Slf4j
public class MyRequestWrapper extends HttpServletRequestWrapper {

    public static final Charset defaultCharset = StandardCharsets.UTF_8;

    private final Charset charset;

    private final byte[] bodyBytes;

    private final MultiValueMap<String, String> formParameters;

    public MyRequestWrapper(HttpServletRequest request) throws IOException {
        super(request);
        String charEncode = request.getCharacterEncoding();
        String contentType = request.getContentType();
        if (StringUtils.isNotBlank(charEncode)) {
            charset = Charset.forName(charEncode);
        } else if (StringUtils.isNotBlank(contentType)
                && contentType.contains("charset=")) {
            charset = Charset.forName(contentType.substring(contentType.indexOf("=") + 1));
        } else {
            charset = defaultCharset;
        }
        bodyBytes = handleInputStream(request.getInputStream());
        if (StringUtils.isNotBlank(contentType)
                && contentType.contains(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
            formParameters = handleFormParameters();
        } else {
            formParameters = new LinkedMultiValueMap(0);
        }
    }

    private byte[] handleInputStream(InputStream inputStream) throws IOException {
        /*BufferedInputStream bis = new BufferedInputStream(inputStream);
        byte[] buffer = new byte[1024];
        int volume;
        byte[] target = new byte[0];
        while ((volume = bis.read(buffer)) != -1) {
            target = ArrayUtils.addAll(target, buffer);
        }
        bis.close();*/
        StringBuffer sb = new StringBuffer();
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream, charset));
        String line;
        while ((line = br.readLine()) != null) {
            sb.append(line);
        }
        br.close();
        byte[] target = sb.toString().getBytes(charset);
        return target;
    }

    public String getBody() {
        return new String(bodyBytes, this.charset);
    }

    /**
     * 参照HttpPutFormContentFilter
     */
    private MultiValueMap<String, String> handleFormParameters() throws UnsupportedEncodingException {
        String[] pairs = tokenizeToStringArray(getBody(), "&", true, true);
        MultiValueMap<String, String> result = new LinkedMultiValueMap(pairs.length);
        String[] var8 = pairs;
        int var9 = pairs.length;

        for(int var10 = 0; var10 < var9; ++var10) {
            String pair = var8[var10];
            int idx = pair.indexOf(61);
            if (idx == -1) {
                result.add(URLDecoder.decode(pair, charset.name()), null);
            } else {
                String name = URLDecoder.decode(pair.substring(0, idx), charset.name());
                String value = URLDecoder.decode(pair.substring(idx + 1), charset.name());
                result.add(name, value);
            }
        }

        return result;
    }

    private String[] tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens) {
        if (str == null) {
            return new String[0];
        } else {
            StringTokenizer st = new StringTokenizer(str, delimiters);
            ArrayList<String> tokens = new ArrayList<>();

            while(true) {
                String token;
                do {
                    if (!st.hasMoreTokens()) {
                        return tokens.toArray(new String[0]);
                    }

                    token = st.nextToken();
                    if (trimTokens) {
                        token = token.trim();
                    }
                } while(ignoreEmptyTokens && token.length() <= 0);

                tokens.add(token);
            }
        }
    }

    @Override
    public ServletInputStream getInputStream() throws IOException {
        ByteArrayInputStream inputStream = new ByteArrayInputStream(bodyBytes);
        return new ServletInputStream() {
            @Override
            public boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }

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

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

    @Override
    public String getParameter(String name) {
        String queryStringValue = super.getParameter(name);
        String formValue = this.formParameters.getFirst(name);
        return queryStringValue != null ? queryStringValue : formValue;
    }

    @Override
    public Map<String, String[]> getParameterMap() {
        Map<String, String[]> result = new LinkedHashMap();
        Enumeration names = this.getParameterNames();

        while(names.hasMoreElements()) {
            String name = (String)names.nextElement();
            result.put(name, this.getParameterValues(name));
        }

        return result;
    }

    @Override
    public Enumeration<String> getParameterNames() {
        Set<String> names = new LinkedHashSet();
        names.addAll(Collections.list(super.getParameterNames()));
        names.addAll(this.formParameters.keySet());
        return Collections.enumeration(names);
    }

    @Override
    public String[] getParameterValues(String name) {
        String[] parameterValues = super.getParameterValues(name);
        List<String> formParam = this.formParameters.get(name);
        if (formParam == null) {
            return parameterValues;
        } else if (parameterValues != null && this.getQueryString() != null) {
            List<String> result = new ArrayList(parameterValues.length + formParam.size());
            result.addAll(Arrays.asList(parameterValues));
            result.addAll(formParam);
            return result.toArray(new String[0]);
        } else {
            return formParam.toArray(new String[0]);
        }
    }

}

2. 定义过滤器，用于将 HttpServletRequest 对象替换成自定义请求包装器 MyRequestWrapper 对象


import lombok.extern.slf4j.Slf4j;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

/**
 * 在过滤器中将 HttpServletRequest 对象替换成自定义请求包装器 MyRequestWrapper 对象
 */
@Slf4j
public class MyRequestWrapperFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        log.debug("执行HttpServletRequestWrapper包装器替换");
        MyRequestWrapper requestWrapper = new MyRequestWrapper((HttpServletRequest) servletRequest);
        filterChain.doFilter(requestWrapper, servletResponse);
    }

    @Override
    public void destroy() {

    }
}

3. 定义拦截器，提前获取请求body数据


import com.alibaba.fastjson.JSON;
import com.me.config.filter.MyRequestWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.util.WebUtils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;

@Slf4j
public class AccessInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        Map<String, String[]> parameterMap;
        String body;
        /*if (request instanceof MyRequestWrapper) {
            MyRequestWrapper requestWrapper = (MyRequestWrapper) request;
            body = requestWrapper.getBody();
            parameterMap = requestWrapper.getParameterMap();
        } else {
            body = "";
            parameterMap = request.getParameterMap();
        }*/
        MyRequestWrapper requestWrapper = WebUtils.getNativeRequest(request, MyRequestWrapper.class);
        if (requestWrapper != null) {
            body = requestWrapper.getBody();
            parameterMap = requestWrapper.getParameterMap();
        } else {
            body = StringUtils.EMPTY;
            parameterMap = request.getParameterMap();
        }
        log.info("clientURL----->{}", request.getRemoteAddr());
        log.info("requestURL----->{} {}", request.getMethod(), request.getRequestURL().toString());
        log.info("parameterMap----->{}", JSON.toJSONString(parameterMap));
        log.info("requestBody----->{}", body);
        return true;
    }
}

4. 在配置类中注册过滤器与拦截器，使其生效


import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.filter.CorsFilter;
import org.springframework.web.servlet.config.annotation.*;

@Slf4j
@Configuration
public class BaseConfig extends WebMvcConfigurationSupport {

	@Bean
	public MyRequestWrapperFilter getMyRequestWrapperFilter() {
		return new MyRequestWrapperFilter();
	}

	@Bean
	public FilterRegistrationBean someFilterRegistration() {
		FilterRegistrationBean registration = new FilterRegistrationBean();
		registration.setFilter(getMyRequestWrapperFilter());
		registration.addUrlPatterns("/*");
		registration.setName("myInputStreamFilter");
		// 设置过滤器执行优先级，数值越小优先级越高
		// 当前只要保证Filter过滤器在Interceptor拦截器之前执行即可，所以设置为最低优先级
		registration.setOrder(Ordered.LOWEST_PRECEDENCE);
		return registration;
	}

	@Bean
	public AccessInterceptor getAccessInterceptor() {
		return new AccessInterceptor();
	}

	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		registry.addInterceptor(getAccessInterceptor())
				.addPathPatterns("/**")
				.excludePathPatterns("/static/**");
    }

	/**
	 * 解决跨域问题
	 */
	@Override
	public void addCorsMappings(CorsRegistry registry) {
		registry.addMapping("/**")
				.allowedOrigins("*")
				.allowedHeaders("Content-Type,X-Requested-With,Cookies,Cookie,X-Auth-Token,token,auth,Authorization")
				.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
				.allowCredentials(true)
				.maxAge(3600);
	}
	@Bean
	public CorsFilter corsFilter() {
		UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
		CorsConfiguration corsConfiguration = new CorsConfiguration();
		// 请求常用的三种配置，*代表允许所有，当时你也可以自定义属性（比如header只能带什么，method只能是post方式等等）
		corsConfiguration.addAllowedOrigin("*");
		corsConfiguration.addAllowedHeader("Content-Type,X-Requested-With,Cookies,Cookie,X-Auth-Token,token,auth,Authorization");
		corsConfiguration.addAllowedMethod("GET,POST,PUT,DELETE,OPTIONS");
		corsConfiguration.setAllowCredentials(true);
		corsConfiguration.setMaxAge(3600L);
		source.registerCorsConfiguration("/**", corsConfiguration);
		return new CorsFilter(source);
	}

}

5. 定义Controller类，这里就不贴源码了，与正常写法无差异。

总结：最主要的在于请求包装器 MyRequestWrapper 中对输入流的处理和存储以及重写获取参数的几个方法，再加上过滤器中的请求包装器替换来保证后续输入流和参数的正常可重复获取。

SHI0ELD
关注
【SpringBoot】68、SpringBoot解决HttpServletRequest中输入流不能重复读的问题
Asurplus
06-21 20万+
Java 中的输入流 InputStream 的 read() 方法中有一个标志位 postion，标志当前流读取到的位置，每读取一次，位置就会移动一次，如果读到最后，InputStream.read() 方法会返回-1，标志已经读取完了，如果想再次读取，可以调用 inputstream.reset() 方法，position 就会移动到上次调用 mark 的位置，mark 默认是 0，所以就能从头再读了。...
使用 HttpServletRequestWrapper 重复读取 HttpServletRequest（多次读取 request 请求）
HeatDeath的博客
05-16 6327
今天尝试在切面中读取 request 请求，校验请求的参数，解析异常则报错 但是，在 切面读取了一次 request 后，再到 controller 的时候，request 就变成了空的 找了一圈找到这种方法，通过继承 HttpServletRequestWrapper ，来操作 HttpServletRequest package xxxxx; import org.apache.comm...
为什么过滤器需要一个 Wrapper 来 extends HttpServletRequestWrapper
心有—林夕的博客
03-05 1123
允许我们在不修改原始请求对象的情况下对请求进行增强或处理。这使得它非常适合在过滤器中使用，特别是在需要拦截请求并处理安全问题（如 XSS、SQL 注入等）时。通过继承，我们可以灵活地修改请求数据、实现跨请求的安全措施，同时保持代码的清晰和可维护性。
使用HttpServletRequestWrapper解决web项目request数据流无法重复读取的问题
dream_xin2013的专栏
01-26 1400
在做web项目开发时，我们有时候需要做一些前置的拦截判断处理，比如非法参数校验，防攻击拦截，统一日志处理等，而请求参数如果是form表单提交还好处理；对于json这种输入流的数据就会有问题，统一处理如果读取了数据流就会将流进行关闭，这就会导致接下来的业务处理无法读取数据流。封装成这个类就是为了解决需要重复读取输入流的地方就使用这个包装类替换原有的request对象。
HttpServletRequest重复读取
Quan_qqqq的博客
09-01 704
背景概述 最近公司要求在之前的项目APP接口里面加入端口校验功能，实现起来很简单，就是通过添加拦截器的方式，在interceptor中读取端口参数，校验该端口在配置文件中是否有存在，存在返回已占用，请重新输入，不存在就添加该服务。 接口中主要是json格式，其对应的是payload请求，不可以通过request的getParameter()方法直接获取，需要通过getRead或者getInputStream方法获取流，通过流读取body，将body转化成JsonObject来获取。读取之后就出现了下面的错误
HttpServletRequestWrapper 用法
fishhappy365的专栏
10-10 976
Servlet规范中所引入的filter令人心动不已，因为它引入了一个功能强大的拦截模式。Filter是这样一种Java对象，它能在request到达servlet的服务方法之前拦截HttpServletRequest对象，而在服务方法转移控制后又能拦截HttpServletResponse对象。你可以使用filter来实现特定的任务，比如验证用户输入，以及压缩web内容。但你拟富有成效地使用过滤...
RequestWrapper实现输入流多次读
cg_Amaz1ng的博客
09-28 1041
import lombok.extern.slf4j.Slf4j; import javax.servlet.ReadListener; import javax.servlet.ServletInputStream; import javax.servlet.ServletRequest; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import ..
spring应用中多次读取http post方法中的流遇到的问题
08-26
通过这种方式，我们可以在Filter中记录请求参数，同时不影响Controller对请求体的访问。这样，即使在原始请求流被消费后，我们仍然可以多次读取请求体中的数据。 总结来说，处理Spring应用中多次读取HTTP POST方法...
SpringBoot项目拦截器中通过流获取Request请求对象中的参数后，控制器中@RequestBody注解参数获取不到
qq_30401609的博客
09-18 2万+
一、场景     第一次搭建项目开发环境，需要在项目中实现日志拦截器，用来获取用户请求参数日志，以便在后期维护中出现BUG时能够快速定位错误发生的场景。请求参数一般通过GET和POST方式进行传递，GET请求参数获取通过request.getParameterMap()获取。而POST请求参数则采用request.getInputStream()获取。 二、错误   在实现中发现如果通过流获...
重复读取 request 流数据
路的尽头在哪
10-16 1536
前言 2021.10.15 起因是在项目中，我自己习惯都是在拦截器中拿参数、打日志。 但是一个接口对接方比较独特，参数都写在 request流 里面 也是第一次遇到。 但是问题是，request 流中的数据，只能被读取一次，现在日志打印读取了，后面 controller 里就没有了。 问题复现 接口接收数据对象： @Data public class QueryDTO { public String id; public Integer type; } 接口方法： @RestCont
Spring Boot接口验签(拦截器实现&解决Post请求body的输入流只能读取一次问题)
聚沙成塔
11-12 1万+
SpringBoot集成拦截器-接口签名的统一验证 demo-web module添加拦截器实现类，接口验签使用MD5 package com.springboot.demo.web.interceptor; import com.google.gson.Gson; import com.springboot.demo.common.constants.Constants; import com...
使用HttpServletRequestWrapper在filter修改request参数
04-12
NULL 博文链接：https://rensanning.iteye.com/blog/1706208
HttpServletRequestWrapper
05-08
这是一个关于HttpServletRequestWrapper使用的列子，工作需要，所以传上来的。
XssHttpServletRequestWrapper.java
12-03
XssHttpServletRequestWrapper.java
HttpServletRequestWrapper处理request数据流多次读取问题
奋斗不息
05-31 2651
HttpServletRequestWrapper处理request数据流多次读取问题
SpringBoot - HttpServletRequest 请求重复读取解决方案
陆克和他的那些代码
07-15 3352
注意：HttpServletRequest 请求中的 body 内容仅能调用 request.getInputStream()， request.getReader() 和request.getParameter("key") 方法读取一次，重复读取会报 java.io.IOException: Stream closed 异常。 原来两个同名参数的值都能在后台拿到，难怪request.getParamterMap()方法的返回值类型是Map，第二个String[]数组...
HttpServletRequestWrapper 实现xss注入
yinni11的博客
12-04 2108
自定义一个wapper 实现 HttpServletRequestWrapper package cn.baozun.crm.task.filter; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; /** * * &lt;p&gt;xs...
springboot通过HttpServletRequestWrapper获取所有请求参数
热门推荐
OceanSky的专栏
08-26 2万+
springboot通过拦截器获取参数有两种方式，一种通过request.getParameter获取Get方式传递的参数，另外一种是通过request.getInputStream或reques.getReader获取通过POST/PUT/DELETE/PATCH传递的参数； 1.拦截器获取参数有哪些方式 @PathVariable注解是REST风格url获取参数的方式，只能用在GET请求类型，通过getParameter获取参数 @RequestParam注解支持GET和POST/PUT/DELE.
HttpServletRequestWrapper的使用与原理
li12412414的博客
05-08 4030
HttpServletRequestWrapper 实现了 HttpServletRequest 接口，可以让开发人员很方便的改造发送给 Servlet 的请求.HttpServletRequest 对参数值的获取实际调的是org.apache.catalina.connector.Request没有提供对应的set方法修改属性所以不能对前端传来的参数进行修改，实际场所像过滤xss攻击，取认证token统一去除token前缀等需要进行请求参数的处理。
filterChain.doFilter报参数解析出错
最新发布
04-03
### Spring Boot 中 Filter Chain 参数解析异常的解决方案 在使用 `filterChain.doFilter` 调用时，如果遇到参数解析错误的问题，通常是因为请求体已经被上游的过滤器读取过一次，而 HTTP 请求中的输入流只能被读取一次。一旦输入流被消耗掉，后续的责任链（如 Controller 或其他过滤器）就无法再次访问该数据。 以下是针对这一问题的具体分析和解决方案： #### 1. **问题原因** HTTP 协议规定，请求体的内容是以流的形式传输的，这种流是一次性的资源。当某个组件（例如自定义过滤器）尝试读取请求体时，会将流完全消费掉[^3]。因此，在调用 `filterChain.doFilter(request, response)` 后续环节中，由于请求体已被清空，可能导致参数解析失败或其他逻辑异常。 --- #### 2. **解决方案** ##### 方法一：封装可重复读取的 Request 对象 可以通过创建一个包装类来实现对原始 `HttpServletRequest` 的增强功能，使其支持多次读取请求体。具体做法如下： ```java import javax.servlet.ReadListener; import javax.servlet.ServletInputStream; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletRequestWrapper; import java.io.*; public class MultiReadRequestWrapper extends HttpServletRequestWrapper { private byte[] requestBody; public MultiReadRequestWrapper(HttpServletRequest request) throws IOException { super(request); // 将请求体转换为字节数组以便于重用 InputStream inputStream = request.getInputStream(); this.requestBody = IOUtils.toByteArray(inputStream); // 使用 Apache Commons IO 工具库简化操作 } @Override public ServletInputStream getInputStream() throws IOException { final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.requestBody); return new ServletInputStream() { @Override public boolean isFinished() { return false; } @Override public boolean isReady() { return true; } @Override public void setReadListener(ReadListener readListener) {} @Override public int read() throws IOException { return byteArrayInputStream.read(); } }; } @Override public BufferedReader getReader() throws IOException { return new BufferedReader(new InputStreamReader(getInputStream())); } } ``` 上述代码实现了对原生 `HttpServletRequest` 的扩展，允许其请求体能够被多次读取[^4]。 --- ##### 方法二：调整过滤器顺序 某些情况下，可能不需要修改核心逻辑，而是通过调整过滤器执行顺序解决问题。例如，确保 JWT 校验等敏感操作优先完成后再进入业务逻辑层。可以在配置文件中指定过滤器的加载顺序： ```xml <filter> <filter-name>CustomJwtFilter</filter-name> <filter-class>com.example.CustomJwtFilter</filter-class> </filter> <filter-mapping> <filter-name>CustomJwtFilter</filter-name> <url-pattern>/api/*</url-pattern> <!-- 设置较低的 priority 值 --> <dispatcher>PRIORITY</dispatcher> </filter-mapping> ``` 注意这里的 `<dispatcher>` 属性可以根据实际需求设置为 REQUEST、FORWARD 等不同类型的分发方式[^2]。 --- ##### 方法三：避免提前读取请求体 如果不是必要场景，则应尽量减少直接读取请求体的行为。对于简单的验证任务（比如路径匹配或者头部信息检查），可以直接基于现有字段完成判断而不涉及复杂的数据结构解析过程[^1]。 --- ### 总结 综合来看，“封装可重复读取的 Request 对象”的方法最为通用且灵活，适用于大多数需要频繁访问请求内容的应用场合；而对于特定环境下的优化则可以选择适当调整过滤器注册位置或行为策略。最终目标都是保障整个 Web 应用流程顺畅运转的同时满足安全性和功能性要求。 ---
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值