背景：
在使用SSM（你问我什么叫SSM，我一拳锤爆你的狗头）做开发的时候，经常会使用@RequestBody注解，这个注解是非常的好用。但是如果你想在请求参数传到后台的时候做一个参数检验，当然可以！使用SpringMVC的拦截器，在拦截器里把request的数据读取出来不就行了！！，但是在使用了拦截器的时候会出现一个问题！！！！你在拦截器读取了request的数据，在Controller里面@RequestBody注解获取Json就会失败就读取不到数据！！！！那就是RequestBody是流的形式读取的，流读取一次就没有了！！
为什么使用RequestBody只能读取一遍请求数据流？
那是因为流对应的是数据，数据放在内存中，有的是部分放在内存中。read 一次标记一次当前位置（mark position），第二次read就从标记位置继续读（从内存中copy）数据。 所以这就是为什么读了一次第二次是空了。 怎么让它不为空呢？只要inputstream 中的pos 变成0就可以重写读取当前内存中的数据。javaAPI中有一个方法public void reset() 这个方法就是可以重置pos为起始位置，但是不是所有的IO读取流都可以调用该方法！ServletInputStream是不能调用reset方法，这就导致了只能调用一次getInputStream()。
解决办法：重写HttpServletRequestWrapper方法
这种方法就是通过重写HttpServletRequestWrapper把request的保存下来，然后通过过滤器保存下来的request在填充进去，这样就可以多次读取request了
1.重写HttpServletRequestWrapper
package com.qxh.admin.supplychain.interceptor.wrapper;
import org.apache.commons.lang3.StringUtils;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
public class RequestReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
private final String body;
public RequestReaderHttpServletRequestWrapper(HttpServletRequest request, String charset) throws IOException {
super(request);
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = null;
try {
InputStream inputStream = request.getInputStream();
if (inputStream != null) {
if (StringUtils.isNotBlank(charset)) {
bufferedReader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
} else {
bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
}
char[] charBuffer = new char[128];
int bytesRead = -1;
while ((bytesRead = bufferedReader.read(charBuffer)) > 0) {
stringBuilder.append(charBuffer, 0, bytesRead);
}
} else {
stringBuilder.append("");
}
} catch (IOException ex) {
throw ex;
} finally {
if (bufferedReader != null) {
try {
bufferedReader.close();
} catch (IOException ex) {
throw ex;
}
}
}
body = stringBuilder.toString();
}
public RequestReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
this(request, null);
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
ServletInputStream servletInputStream = new ServletInputStream() {
public boolean isFinished() {
return false;
}
public boolean isReady() {
return false;
}
/*public void setReadListener(ReadListener readListener) {
}*/
public int read() throws IOException {
return byteArrayInputStream.read();
}
};
return servletInputStream;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(this.getInputStream()));
}
public String getBody() {
return this.body;
}
}
2.拦截器RecordLogHandlerInterceptor
package com.qxh.admin.supplychain.interceptor;
import com.qxh.admin.common.vo.LoginUser;
import com.qxh.admin.supplychain.interceptor.wrapper.RequestReaderHttpServletRequestWrapper;
import com.qxh.admin.supplychain.service.IRecordlogService;
import com.qxh.admin.supplychain.vo.Admin;
import com.qxh.admin.utils.LoginUtil;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 日志记录拦截器
*/
@Component
public class RecordLogHandlerInterceptor implements HandlerInterceptor {
//忽略参数
private final String[] IGNORE_ATTRIBUTES = new String[]{"password", "enPassword", "rePassword"};
private Logger log = LoggerFactory.getLogger(this.getClass());
// 请求路径和表名映射
private static Map<String, String> pathTablenameMap = new HashMap<>();
static {
pathTablenameMap.put("category", "品牌分类");
pathTablenameMap.put("partner", "合伙人");
pathTablenameMap.put("goodsCategory", "商品分类");
pathTablenameMap.put("goods", "商品");
pathTablenameMap.put("order", "订单");
pathTablenameMap.put("supplier", "供应商");
}
@Autowired
private IRecordlogService recordlogService;
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
}
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
try {
log.debug("-----------recordlog interceptor afterCompletion-------");
String body = null;
if (request instanceof RequestReaderHttpServletRequestWrapper) {
// 拦截器中只获取，需要转码
RequestReaderHttpServletRequestWrapper myRequestWrapper = new RequestReaderHttpServletRequestWrapper((HttpServletRequest) request, "UTF-8");
body = myRequestWrapper.getBody();
log.info("-------------recordLog body:" + body);
}
// 获取并拼接请求参数
StringBuffer parameter = new StringBuffer();
Map<String, String[]> parameterMap = request.getParameterMap();
if (parameterMap != null && !parameterMap.isEmpty()) {
for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
String key = entry.getKey();
if (!ArrayUtils.contains(IGNORE_ATTRIBUTES, key)) {
String[] parameterValues = entry.getValue();
if (parameterValues != null) {
for (String parameterValue : parameterValues) {
parameter.append(key);
parameter.append("=");
parameter.append(parameterValue);
parameter.append("&");
}
}
}
}
}
if (StringUtils.isNotBlank(body)) {
parameter.append(body);
}
// System.out.println("---------request.getServletContext().getContextPath():" + request.getServletContext().getContextPath());
// System.out.println("---------request.getServerName():" + request.getServerName());
// System.out.println("---------request.getServletPath():" + request.getServletPath());
// System.out.println("---------request.getContextPath():" + request.getContextPath());
// System.out.println("---------request.getPathInfo():" + request.getPathInfo());
// 根据请求路径获取表名和动作
String originalRequestPath = request.getRequestURI();
String requestPath = originalRequestPath;
if (requestPath.charAt(requestPath.length() - 1) == '/') {
requestPath = requestPath.substring(0, requestPath.length() - 1);
}
if (requestPath.startsWith("/supplychain")) {
requestPath = requestPath.substring("/supplychain".length());
} else if (requestPath.startsWith("supplychain")) {
requestPath = requestPath.substring("supplychain".length());
}
if (requestPath.charAt(0) == '/') {
requestPath = requestPath.substring(1);
}
List<String> list = Arrays.asList(requestPath.split("/"));
String moduleAliasName = list.get(0);
String moduleName = pathTablenameMap.get(moduleAliasName);
//获取当前登录人的id，如果未登录则默认为null
// 赋值创建人信息
Admin admin = new Admin();
LoginUser loginUser = LoginUtil.getLoginUser(request);
if (null != loginUser) {
admin.setId(loginUser.getId());
admin.setName(loginUser.getUserName());
}
recordlogService.save(admin, originalRequestPath, parameter.toString(), moduleName, moduleAliasName);
} catch (Exception e) {
e.printStackTrace();
log.error("记录日志出错!", e.fillInStackTrace());
}
}
}
3.在spring-mvc.xml声明springMVC的拦截器
4.过滤器HttpServletFilter类
package com.qxh.admin.supplychain.filter;
import com.qxh.admin.supplychain.interceptor.wrapper.RequestReaderHttpServletRequestWrapper;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
public class HttpServletRequestReplacedFilter implements Filter {
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if(request instanceof HttpServletRequest &&
(null == request.getParameterMap() || request.getParameterMap().isEmpty())) {
requestWrapper = new RequestReaderHttpServletRequestWrapper((HttpServletRequest) request);
}
//获取请求中的流如何，将取出来的字符串，再次转换成流，然后把它放入到新request对象中。
// 在chain.doFiler方法中传递新的request对象
if(requestWrapper == null) {
chain.doFilter(request, response);
} else {
chain.doFilter(requestWrapper, response);
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}
5.在web.xml中注册过滤器
<filter>
<filter-name>requestFilter</filter-name>
<filter-class>com.qxh.admin.supplychain.filter.HttpServletRequestReplacedFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>requestFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>经过测试完全可以并且不出现其他错误。
参考：https://blog.csdn.net/qq_35192741/article/details/88392140
2243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
