java输入错误重新输入无法获取_解决HttpServletRequest的输入流只能读取一次的问题...

背景

通常对安全性有要求的接口都会对请求参数做一些签名验证，而我们一般会把验签的逻辑统一放到过滤器或拦截器里，这样就不用每个接口都去重复编写验签的逻辑。

在一个项目中会有很多的接口，而不同的接口可能接收不同类型的数据，例如表单数据和json数据，表单数据还好说，调用request的getParameterMap就能全部取出来。而json数据就有些麻烦了，因为json数据放在body中，我们需要通过request的输入流去读取。

但问题在于request的输入流只能读取一次不能重复读取，所以我们在过滤器或拦截器里读取了request的输入流之后，请求走到controller层时就会报错。而本文的目的就是介绍如何解决在这种场景下遇到HttpServletRequest的输入流只能读取一次的问题。

注：本文代码基于SpringBoot框架

HttpServletRequest的输入流只能读取一次的原因

我们先来看看为什么HttpServletRequest的输入流只能读一次，当我们调用getInputStream()方法获取输入流时得到的是一个InputStream对象，而实际类型是ServletInputStream，它继承于InputStream。

InputStream的read()方法内部有一个postion，标志当前流被读取到的位置，每读取一次，该标志就会移动一次，如果读到最后，read()会返回-1，表示已经读取完了。如果想要重新读取则需要调用reset()方法，position就会移动到上次调用mark的位置，mark默认是0，所以就能从头再读了。调用reset()方法的前提是已经重写了reset()方法，当然能否reset也是有条件的，它取决于markSupported()方法是否返回true。

InputStream默认不实现reset()，并且markSupported()默认也是返回false，这一点查看其源码便知：

/**

* Repositions this stream to the position at the time the

* mark method was last called on this input stream.

*

*

The general contract of reset is:

*

*

*

If the method markSupported returns

* true, then:

*

*

• If the method mark has not been called since

  * the stream was created, or the number of bytes read from the stream

  * since mark was last called is larger than the argument

  * to mark at that last call, then an

  * IOException might be thrown.

  *

  *

• If such an IOException is not thrown, then the

  * stream is reset to a state such that all the bytes read since the

  * most recent call to mark (or since the start of the

  * file, if mark has not been called) will be resupplied

  * to subsequent callers of the read method, followed by

  * any bytes that otherwise would have been the next input data as of

  * the time of the call to reset.

*

*

If the method markSupported returns

* false, then:

*

*

• The call to reset may throw an

  * IOException.

  *

  *

• If an IOException is not thrown, then the stream

  * is reset to a fixed state that depends on the particular type of the

  * input stream and how it was created. The bytes that will be supplied

  * to subsequent callers of the read method depend on the

  * particular type of the input stream.

*

*

The method reset for class InputStream

* does nothing except throw an IOException.

*

* @exception IOException if this stream has not been marked or if the

* mark has been invalidated.

* @see java.io.InputStream#mark(int)

* @see java.io.IOException

*/

public synchronized void reset() throws IOException {

throw new IOException("mark/reset not supported");

}

/**

* Tests if this input stream supports the mark and

* reset methods. Whether or not mark and

* reset are supported is an invariant property of a

* particular input stream instance. The markSupported method

* of InputStream returns false.

*

* @return true if this stream instance supports the mark

* and reset methods; false otherwise.

* @see java.io.InputStream#mark(int)

* @see java.io.InputStream#reset()

*/

public boolean markSupported() {

return false;

}

我们再来看看ServletInputStream，可以看到该类没有重写mark()，reset()以及markSupported()方法：

/*

* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements. See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License. You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

package javax.servlet;

import java.io.IOException;

import java.io.InputStream;

/**

* Provides an input stream for reading binary data from a client request,

* including an efficient readLine method for reading data one line

* at a time. With some protocols, such as HTTP POST and PUT, a

* ServletInputStream object can be used to read data sent from the

* client.

*

* A ServletInputStream object is normally retrieved via the

* {@link ServletRequest#getInputStream} method.

*

* This is an abstract class that a servlet container implements. Subclasses of

* this class must implement the java.io.InputStream.read() method.

*

* @see ServletRequest

*/

public abstract class ServletInputStream extends InputStream {

/**

* Does nothing, because this is an abstract class.

*/

protected ServletInputStream() {

// NOOP

}

/**

* Reads the input stream, one line at a time. Starting at an offset, reads

* bytes into an array, until it reads a certain number of bytes or reaches

* a newline character, which it reads into the array as well.

*

* This method returns -1 if it reaches the end of the input stream before

* reading the maximum number of bytes.

*

* @param b

* an array of bytes into which data is read

* @param off

* an integer specifying the character at which this method

* begins reading

* @param len

* an integer specifying the maximum number of bytes to read

* @return an integer specifying the actual number of bytes read, or -1 if

* the end of the stream is reached

* @exception IOException

* if an input or output exception has occurred

*/

public int readLine(byte[] b, int off, int len) throws IOException {

if (len <= 0) {

return 0;

}

int count = 0, c;

while ((c = read()) != -1) {

b[off++] = (byte) c;

count++;

if (c == '\n' || count == len) {

break;

}

}

return count > 0 ? count : -1;

}

/**

* Has the end of this InputStream been reached?

*

* @return true if all the data has been read from the stream,

* else false

*

* @since Servlet 3.1

*/

public abstract boolean isFinished();

/**

* Can data be read from this InputStream without blocking?

* Returns If this method is called and returns false, the container will

* invoke {@link ReadListener#onDataAvailable()} when data is available.

*

* @return true if data can be read without blocking, else

* false

*

* @since Servlet 3.1

*/

public abstract boolean isReady();

/**

* Sets the {@link ReadListener} for this {@link ServletInputStream} and

* thereby switches to non-blocking IO. It is only valid to switch to

* non-blocking IO within async processing or HTTP upgrade processing.

*

* @param listener The non-blocking IO read listener

*

* @throws IllegalStateException If this method is called if neither

* async nor HTTP upgrade is in progress or

* if the {@link ReadListener} has already

* been set

* @throws NullPointerException If listener is null

*

* @since Servlet 3.1

*/

public abstract void setReadListener(ReadListener listener);

}

综上，InputStream默认不实现reset的相关方法，而ServletInputStream也没有重写reset的相关方法，这样就无法重复读取流，这就是我们从request对象中获取的输入流就只能读取一次的原因。

使用HttpServletRequestWrapper + Filter解决输入流不能重复读取问题

既然ServletInputStream不支持重新读写，那么为什么不把流读出来后用容器存储起来，后面就可以多次利用了。那么问题就来了，要如何存储这个流呢？

所幸JavaEE提供了一个 HttpServletRequestWrapper类，从类名也可以知道它是一个http请求包装器，其基于装饰者模式实现了HttpServletRequest界面，部分源码如下：

package javax.servlet.http;

import java.io.IOException;

import java.util.Collection;

import java.util.Enumeration;

import java.util.Map;

import javax.servlet.ServletException;

import javax.servlet.ServletRequestWrapper;

/**

* Provides a convenient implementation of the HttpServletRequest interface that

* can be subclassed by developers wishing to adapt the request to a Servlet.

* This class implements the Wrapper or Decorator pattern. Methods default to

* calling through to the wrapped request object.

*

* @see javax.servlet.http.HttpServletRequest

* @since v 2.3

*/

public class HttpServletRequestWrapper extends ServletRequestWrapper implements

HttpServletRequest {

/**

* Constructs a request object wrapping the given request.

*

* @param request The request to wrap

*

* @throws java.lang.IllegalArgumentException

* if the request is null

*/

public HttpServletRequestWrapper(HttpServletRequest request) {

super(request);

}

private HttpServletRequest _getHttpServletRequest() {

return (HttpServletRequest) super.getRequest();

}

/**

* The default behavior of this method is to return getAuthType() on the

* wrapped request object.

*/

@Override

public String getAuthType() {

return this._getHttpServletRequest().getAuthType();

}

/**

* The default behavior of this method is to return getCookies() on the

* wrapped request object.

*/

@Override

public Cookie[] getCookies() {

return this._getHttpServletRequest().getCookies();

}

从上图中的部分源码可以看到，该类并没有真正去实现HttpServletRequest的方法，而只是在方法内又去调用HttpServletRequest的方法，所以我们可以通过继承该类并实现想要重新定义的方法以达到包装原生HttpServletRequest对象的目的。

首先我们要定义一个容器，将输入流里面的数据存储到这个容器里，这个容器可以是数组或集合。然后我们重写getInputStream方法，每次都从这个容器里读数据，这样我们的输入流就可以读取任意次了。

具体的实现代码如下：

package com.example.wrapperdemo.controller.wrapper;

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 java.io.*;

import java.nio.charset.Charset;

/**

* @author 01

* @program wrapper-demo

* @description 包装HttpServletRequest，目的是让其输入流可重复读

* @create 2018-12-24 20:48

* @since 1.0

**/

@Slf4j

public class RequestWrapper extends HttpServletRequestWrapper {

/**

* 存储body数据的容器

*/

private final byte[] body;

public RequestWrapper(HttpServletRequest request) throws IOException {

super(request);

// 将body数据存储起来

String bodyStr = getBodyString(request);

body = bodyStr.getBytes(Charset.defaultCharset());

}

/**

* 获取请求Body

*

* @param request request

* @return String

*/

public String getBodyString(final ServletRequest request) {

try {

return inputStream2String(request.getInputStream());

} catch (IOException e) {

log.error("", e);

throw new RuntimeException(e);

}

}

/**

* 获取请求Body

*

* @return String

*/

public String getBodyString() {

final InputStream inputStream = new ByteArrayInputStream(body);

return inputStream2String(inputStream);

}

/**

* 将inputStream里的数据读取出来并转换成字符串

*

* @param inputStream inputStream

* @return String

*/

private String inputStream2String(InputStream inputStream) {

StringBuilder sb = new StringBuilder();

BufferedReader reader = null;

try {

reader = new BufferedReader(new InputStreamReader(inputStream, Charset.defaultCharset()));

String line;

while ((line = reader.readLine()) != null) {

sb.append(line);

}

} catch (IOException e) {

log.error("", e);

throw new RuntimeException(e);

} finally {

if (reader != null) {

try {

reader.close();

} catch (IOException e) {

log.error("", e);

}

}

}

return sb.toString();

}

@Override

public BufferedReader getReader() throws IOException {

return new BufferedReader(new InputStreamReader(getInputStream()));

}

@Override

public ServletInputStream getInputStream() throws IOException {

final ByteArrayInputStream inputStream = new ByteArrayInputStream(body);

return new ServletInputStream() {

@Override

public int read() throws IOException {

return inputStream.read();

}

@Override

public boolean isFinished() {

return false;

}

@Override

public boolean isReady() {

return false;

}

@Override

public void setReadListener(ReadListener readListener) {

}

};

}

}

除了要写一个包装器外，我们还需要在过滤器里将原生的HttpServletRequest对象替换成我们的RequestWrapper对象，代码如下：

package com.example.wrapperdemo.controller.filter;

import com.example.wrapperdemo.controller.wrapper.RequestWrapper;

import lombok.extern.slf4j.Slf4j;

import javax.servlet.*;

import javax.servlet.http.HttpServletRequest;

import java.io.IOException;

/**

* @author 01

* @program wrapper-demo

* @description 替换HttpServletRequest

* @create 2018-12-24 21:04

* @since 1.0

**/

@Slf4j

public class ReplaceStreamFilter implements Filter {

@Override

public void init(FilterConfig filterConfig) throws ServletException {

log.info("StreamFilter初始化...");

}

@Override

public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {

ServletRequest requestWrapper = new RequestWrapper((HttpServletRequest) request);

chain.doFilter(requestWrapper, response);

}

@Override

public void destroy() {

log.info("StreamFilter销毁...");

}

}

然后我们就可以在拦截器中愉快的获取json数据也不慌controller层会报错了：

package com.example.wrapperdemo.controller.interceptor;

import com.example.wrapperdemo.controller.wrapper.RequestWrapper;

import lombok.extern.slf4j.Slf4j;

import org.springframework.http.MediaType;

import org.springframework.web.servlet.HandlerInterceptor;

import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

/**

* @author 01

* @program wrapper-demo

* @description 签名拦截器

* @create 2018-12-24 21:08

* @since 1.0

**/

@Slf4j

public class SignatureInterceptor implements HandlerInterceptor {

@Override

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

log.info("[preHandle] executing... request uri is {}", request.getRequestURI());

if (isJson(request)) {

// 获取json字符串

String jsonParam = new RequestWrapper(request).getBodyString();

log.info("[preHandle] json数据 : {}", jsonParam);

// 验签逻辑...略...

}

return true;

}

@Override

public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

}

@Override

public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

}

/**

* 判断本次请求的数据类型是否为json

*

* @param request request

* @return boolean

*/

private boolean isJson(HttpServletRequest request) {

if (request.getContentType() != null) {

return request.getContentType().equals(MediaType.APPLICATION_JSON_VALUE) ||

request.getContentType().equals(MediaType.APPLICATION_JSON_UTF8_VALUE);

}

return false;

}

}

编写完以上的代码后，还需要将过滤器和拦截器在配置类中进行注册才会生效，过滤器配置类代码如下：

package com.example.wrapperdemo.config;

import com.example.wrapperdemo.controller.filter.ReplaceStreamFilter;

import org.springframework.boot.web.servlet.FilterRegistrationBean;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import javax.servlet.Filter;

/**

* @author 01

* @program wrapper-demo

* @description 过滤器配置类

* @create 2018-12-24 21:06

* @since 1.0

**/

@Configuration

public class FilterConfig {

/**

* 注册过滤器

*

* @return FilterRegistrationBean

*/

@Bean

public FilterRegistrationBean someFilterRegistration() {

FilterRegistrationBean registration = new FilterRegistrationBean();

registration.setFilter(replaceStreamFilter());

registration.addUrlPatterns("/*");

registration.setName("streamFilter");

return registration;

}

/**

* 实例化StreamFilter

*

* @return Filter

*/

@Bean(name = "replaceStreamFilter")

public Filter replaceStreamFilter() {

return new ReplaceStreamFilter();

}

}

拦截器配置类代码如下：

package com.example.wrapperdemo.config;

import com.example.wrapperdemo.controller.interceptor.SignatureInterceptor;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.web.servlet.config.annotation.InterceptorRegistry;

import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**

* @author 01

* @program wrapper-demo

* @description

* @create 2018-12-24 21:16

* @since 1.0

**/

@Configuration

public class InterceptorConfig implements WebMvcConfigurer {

@Bean

public SignatureInterceptor getSignatureInterceptor(){

return new SignatureInterceptor();

}

/**

* 注册拦截器

*

* @param registry registry

*/

@Override

public void addInterceptors(InterceptorRegistry registry) {

registry.addInterceptor(getSignatureInterceptor())

.addPathPatterns("/**");

}

}

接下来我们就可以测试一下在拦截器中读取了输入流后在controller层是否还能正常接收数据，首先定义一个实体类，代码如下：

package com.example.wrapperdemo.param;

import lombok.AllArgsConstructor;

import lombok.Builder;

import lombok.Data;

import lombok.NoArgsConstructor;

/**

* @author 01

* @program wrapper-demo

* @description

* @create 2018-12-24 21:11

* @since 1.0

**/

@Data

@Builder

@NoArgsConstructor

@AllArgsConstructor

public class UserParam {

private String userName;

private String phone;

private String password;

}

然后写一个简单的Controller，代码如下：

package com.example.wrapperdemo.controller;

import com.example.wrapperdemo.param.UserParam;

import org.springframework.web.bind.annotation.PostMapping;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**

* @author 01

* @program wrapper-demo

* @description

* @create 2018-12-24 20:47

* @since 1.0

**/

@RestController

@RequestMapping("/user")

public class DemoController {

@PostMapping("/register")

public UserParam register(@RequestBody UserParam userParam){

return userParam;

}

}

启动项目，请求结果如下，可以看到controller正常接收到数据并返回了

站在巨人的肩膀上摘苹果: