SpringBoot 实现拦截器HandlerInterceptor发生 Stream closed异常

现在有个需求：基于SpringBoot搭建的Web项目，加入日志记录功能，将每个用户的操作日志记录下来。

需求so easy......

强大的SpringBoot 改造实现非常的方便：

1：定义拦截日志的注解

public enum  OperationTypeEnum {
    LOGIN,
    REGISTER,
    ADD,
    EDIT,
    DELETE,
    PAGE,
    VIEW
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAnnotation {

    String message();

    OperationTypeEnum opt();
}

2：实现HandlerInterceptor接口

@Slf4j
public class LogHandlerInterceptor implements HandlerInterceptor {

    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            LogAnnotation annotation = ((HandlerMethod) handler).getMethodAnnotation(LogAnnotation.class);
            if (null != annotation) {
                String message = annotation.message();
                String name = annotation.opt().name();
                String method = request.getMethod();
                String param;
                if (!StringUtils.equalsIgnoreCase(HttpMethod.GET.name(), method)) {
                    param = HttpHelper.getBodyString(request);
                } else {
                    Map<String, String[]> parameterMap = request.getParameterMap();
                    param = objectMapper.writeValueAsString(parameterMap);
                }
                log.info(">>> 用户执行了【{}】操作，消息内容：{}，参数列表：{}", name, message, param);
            }
        }
        // 只打印日志，所以永远返回true，不做拦截
        return true;
    }
}

 

public class HttpHelper {
    public static String getBodyString(HttpServletRequest request) {
        StringBuilder sb = new StringBuilder();
        try (
                InputStream inputStream = request.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName("UTF-8")))
        ) {
            String line;
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

3：注册拦截器

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // addPathPatterns("/**") 表示拦截所有的请求
        registry.addInterceptor(new LogHandlerInterceptor()).addPathPatterns("/**");
    }
}

4：需要拦截的method加入注解

@RestController
public class LoginController {

    @Autowired
    private LoginService loginService;

    @LogAnnotation(opt = OperationTypeEnum.LOGIN, message = "用户登录")
    @PostMapping("/login")
    public void login(@RequestBody LoginRequest loginRequest, HttpServletRequest request) {
       ........
    }

    @LogAnnotation(opt = OperationTypeEnum.VIEW, message = "获取防重请求的token")
    @GetMapping("/login/token")
    public ResponseEntity<String> loginToken(HttpServletRequest request) {
       .......
    }
}

快速编码完成。。。

启动。。。

测试。。。。

post ： http://localhost:8080/login

返回异常：

{
    "timestamp": "2019-05-21T03:15:50.188+0000",
    "status": 400,
    "error": "Bad Request",
    "message": "I/O error while reading input message; nested exception is java.io.IOException: Stream closed",
    "path": "/login"
}

查看控制台确实打印了日志：

2019-05-21 11:15:50.162  INFO 53324 --- [nio-8080-exec-2] c.e.c.web.log.LogHandlerInterceptor      : >>> 用户执行了【LOGIN】操作，消息内容：用户登录，参数列表：{  "appId": "1111111111",  "appName": "111111",  "autoCode": "111111111",  "code": "111111",  "deviceInfo": "111111111",  "deviceNo": "123456",  "deviceType": "111111",  "gameVersion": "1111111111",  "loginType": "3",  "msgcodeBizKey": "11111111",  "mulatorFlag": "1111111111",  "password": "111111111",  "registerSource": "111111",  "sessionId": "11111111111",  "timeStamp": "11111",  "userName": "admin",  "version": "11111"}
 

-------------------------------------------------------------------------------------------------------------------------------------------------------

貌似一个日志打印的功能也没那么容易实现

根据返回的异常信息

I/O error while reading input message; nested exception is java.io.IOException: Stream closed

可以推测出系统操作了一个被关闭的流对象

关键在哪里操作了呢？

找到一篇介绍的很清楚的文章：

https://blog.csdn.net/qq_21358931/article/details/82251246

问题简单总结就是：流只能用一次，用过之后，就不能再取数据了

问题是找到了，怎么解决呢。。。。

文章给出的解决方案是:

自己实现一个HttpServletRequestWrapper并覆盖其方法，在这个类中缓存request流，后续的request对象操作都是操作这个封装的Request对象

开始动手修改代码：

将LogHandlerInterceptor.preHandle()修改为：

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    if (handler instanceof HandlerMethod) {
        LogAnnotation annotation = ((HandlerMethod) handler).getMethodAnnotation(LogAnnotation.class);
        if (null != annotation) {
            RequestReaderHttpServletRequestWrapper requestWrapper = new RequestReaderHttpServletRequestWrapper(request);
            String message = annotation.message();
            String name = annotation.opt().name();
            String method = request.getMethod();
            String param;
            if (!StringUtils.equalsIgnoreCase(HttpMethod.GET.name(), method)) {
                param = HttpHelper.getBodyString(requestWrapper);
            } else {
                Map<String, String[]> parameterMap = request.getParameterMap();
                param = objectMapper.writeValueAsString(parameterMap);
            }
            log.info(">>> 用户执行了【{}】操作，消息内容：{}，参数列表：{}", name, message, param);
        }
    }
    // 只打印日志，所以永远返回true，不做拦截
    return true;
}

创建文件：

public class RequestReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {

    private final byte[] body;

    public RequestReaderHttpServletRequestWrapper(HttpServletRequest request) {
        super(request);
        body = HttpHelper.getBodyString(request).getBytes(Charset.forName("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 boolean isFinished() {
                return false;
            }

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

            @Override
            public void setReadListener(ReadListener readListener) {

            }
        };
    }
}

 

启动。。。测试。。。

返现问题依旧。。。。（最终的解决方案就是这个，只是页面没有更清楚的解释。。。一时没想出这个问题）

经过分析后，这种改造后面的request操作不会使用封装的RequestReaderHttpServletRequestWrapper对象，因为没有任何一个地方将这个封装对象传递下去。

经过和同事沟通这个事情后，他给的一个解决方案，自定义一个Filter，在Filter中处理Request对象

半信半疑的代码修改：

public class HttpServletRequestReplacedFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        if (request instanceof HttpServletRequest) {
            ServletRequest requestWrapper = new RequestReaderHttpServletRequestWrapper((HttpServletRequest) request);
            //获取请求中的流，将取出来的字符串，再次转换成流，然后把它放入到新request对象中。
            // 在chain.doFiler方法中传递新的request对象
            chain.doFilter(requestWrapper, response);
            return;
        }
        chain.doFilter(request, response);
    }
}

--------------------------------------------------------------------------------------------------

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Bean
    public FilterRegistrationBean httpServletRequestReplacedFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new HttpServletRequestReplacedFilter());
        // /* 是全部的请求拦截，和Interceptor的拦截地址/**区别开
        registration.addUrlPatterns("/*");
        registration.setName("httpServletRequestReplacedFilter");
        registration.setOrder(1);
        return registration;
    }


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // addPathPatterns("/**") 表示拦截所有的请求，
        // excludePathPatterns("/login", "/register") 表示除了登陆与注册之外
        registry.addInterceptor(new LogHandlerInterceptor()).addPathPatterns("/**");
    }
}

修改LogHandlerInterceptor

@Slf4j
public class LogHandlerInterceptor implements HandlerInterceptor {

    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            LogAnnotation annotation = ((HandlerMethod) handler).getMethodAnnotation(LogAnnotation.class);
            if (null != annotation) {
                String message = annotation.message();
                String name = annotation.opt().name();
                String method = request.getMethod();
                String param;
                if (!StringUtils.equalsIgnoreCase(HttpMethod.GET.name(), method)) {
                    param = HttpHelper.getBodyString(request);
                } else {
                    Map<String, String[]> parameterMap = request.getParameterMap();
                    param = objectMapper.writeValueAsString(parameterMap);
                }
                log.info(">>> 用户执行了【{}】操作，消息内容：{}，参数列表：{}", name, message, param);
            }
        }
        // 只打印日志，所以永远返回true，不做拦截
        return true;
    }
}

 

修改好后启动测试，成功运行，问题解决

下面我们来分析原因：

分析拦截器（Interceptor）和过滤器（Filter）的区别：https://www.cnblogs.com/junzi2099/p/8022058.html

可以看出Filter在Interceptor之前执行，所以在Filter中处理好HttpServletRequest对象，后续的Interceptor都是使用包装后的HttpServletRequest对象，所以问题可以解决

 

 

记录此次的解决思路，希望能帮到更多的朋友