springboot项目，构建可重复读取inputStream的request, 创建RepeatedlyRequestWrapper类_springboot inputstream

作者：小丑西瓜9 | 2024-05-07 19:34:08

踩

springboot inputstream

1 问题

如果使用原生的 HttpServletRequest ，只能读取一次，
如果想要二次读取就会报错。 因此需要能够重复读取 
InputStream 的方法。

springboot项目 HttpServletRequest 
getRequest().getInputStream()或getReader()
只能读取一次read closed

我在项目中使用controller中方法进行接收数据的时候需要加上\
@RequestBody注解接收这种数据,使用POJO对象进行接收,
但是我的项目需要为这个方法增加LogAspect的功能,
这就要求我需要获取到RequestBody中的数据,
但是一个request数据只能读取一次,在方法内部已经读取过了,不能在LogAspect中再次读取

(试过Filter的方法,但是会对原项目中的Filter有冲突)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2 解决

2.1 解决方法一

在Controller的方法中增加参数HttpServletRequest request,使用request.setAttribute()将对象重新放入到request中,在Aspect中使用getAttribute()进行获取就可以避免getInputStream()这个方法出bug了

这种方法很简单，就是使用了之后再赋值回去；
就是从request拿出东西使用之后，再将拿出来的东西放到request里面

2.2 解决方法二

使用过滤器，重写HttpServletRequest ，里面增加缓冲，记录已读取的内容。

具体实现方法是

1 写一个过滤器类

在这里插入图片描述
里面的代码是

package com.ruoyi.common.filter;

import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.springframework.http.MediaType;
import com.ruoyi.common.utils.StringUtils;

/**
 * Repeatable 过滤器
 * 构建可重复读取inputStream的request
 * @author jing
 */
public class RepeatableFilter implements Filter
{
    @Override
    public void init(FilterConfig filterConfig) throws ServletException
    {

    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException
    {
        ServletRequest requestWrapper = null;
//        APPLICATION_JSON_VALUE = "application/json";
        if (request instanceof HttpServletRequest
                && StringUtils.startsWithIgnoreCase(request.getContentType(), MediaType.APPLICATION_JSON_VALUE))
        {
            requestWrapper = new RepeatedlyRequestWrapper((HttpServletRequest) request, response);
        }
        if (null == requestWrapper)
        {
            chain.doFilter(request, response);
        }
        else
        {
            chain.doFilter(requestWrapper, response);
        }
    }

    @Override
    public void destroy()
    {

    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

在这个过滤器里面就会判断，看request请求是不是json,如果是，就将里面的东西进行缓存，不是就直接放行

缓存的逻辑是重新写在另一个文件里面

在这里插入图片描述

package com.ruoyi.common.filter;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import com.ruoyi.common.utils.http.HttpHelper;

/**
 * 构建可重复读取inputStream的request
 * 如果使用原生的 HttpServletRequest ，
 * 只能读取一次，如果想要二次读取就会报错。 因此需要能够重复读取 InputStream 的方法。
 * request的inputStream只能被读取一次，
 * 多次读取将报错，那么如何才能重复读取呢？答案之一是：增加缓冲，记录已读取的内容。
 * @author ruoyi
 */
public class RepeatedlyRequestWrapper extends HttpServletRequestWrapper
{
//    将request 里面的东西 缓存到这个数组里面
    private final byte[] body;

    public RepeatedlyRequestWrapper(HttpServletRequest request, ServletResponse response) throws IOException
    {
        super(request);
        request.setCharacterEncoding("UTF-8");
        response.setCharacterEncoding("UTF-8");

        body = HttpHelper.getBodyString(request).getBytes("UTF-8");
    }

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

    @Override
    public ServletInputStream getInputStream() throws IOException
    {
        final ByteArrayInputStream bais = new ByteArrayInputStream(body);
        return new ServletInputStream()
        {
            @Override
            public int read() throws IOException
            {
                return bais.read();
            }

            @Override
            public int available() throws IOException
            {
                return body.length;
            }

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

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

            @Override
            public void setReadListener(ReadListener readListener)
            {

            }
        };
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

第二步，写一个过滤器的配置类就可以了