最近在写日志管理，想着使用拦截器加注解的方式，但是遇到了一个问题，就是如果使用@RequestBody注解接收的参数只能读取一次，造成了我在拦截器中如果接收了参数，在Controller层就接收不到了，为了解决这个问题，在网上查了方法。自定义一个MyRequestWrapper 继承 HttpServletRequestWrapper不多说，看代码：
package cn.huimin100.cms.handler;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import java.io.*;
/**
* 与HttpServletRequestWrapperFilter配合使用，保证@RequestBody注解的参数可以读取两次
* 因为要在拦截器中获取参数
*/
public class MyRequestWrapper extends HttpServletRequestWrapper {
private final String body;
public MyRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
StringBuilder stringBuilder = new StringBuilder();
BufferedReader bufferedReader = null;
try {
InputStream inputStream = request.getInputStream();
if (inputStream != null) {
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();
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes());
ServletInputStream servletInputStream = new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
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;
}
}
需要结合过滤器使用：
package cn.huimin100.cms.handler;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;
/**
* 该过滤器与MyRequestWrapper配合使用，可以让@RequestBody注解的参数至少可以读取两次，
* 从而使得在拦截器中可以获取@RequestBody注解的参数。
*/
@WebFilter(filterName="HttpServletRequestWrapperFilter",urlPatterns="/*")
public class HttpServletRequestWrapperFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
ServletRequest requestWrapper= null;
if(request instanceof HttpServletRequest){
requestWrapper = new MyRequestWrapper((HttpServletRequest) request);
}
if(null == requestWrapper){
filterChain.doFilter(request,servletResponse);
}else{
filterChain.doFilter(requestWrapper,servletResponse);
}
}
@Override
public void destroy() {
}
}
拦截器中这样获取参数
package
cn.huimin100.cms.handler
;
import
cn.huimin100.cms.config.
LogAnnotation
;
import
cn.huimin100.cms.mapper.newcms.ActionLogsMapper
;
import
cn.huimin100.cms.pojo.po.ActionLogs
;
import
cn.huimin100.cms.util.DateUtil
;
import
com.alibaba.fastjson.JSONObject
;
import
org.apache.commons.lang.time.DateFormatUtils
;
import
org.slf4j.Logger
;
import
org.slf4j.LoggerFactory
;
import
org.springframework.beans.factory.annotation.
Autowired
;
import
org.springframework.web.method.HandlerMethod
;
import
org.springframework.web.servlet.handler.HandlerInterceptorAdapter
;
import
javax.servlet.http.HttpServletRequest
;
import
javax.servlet.http.HttpServletResponse
;
import
java.lang.reflect.Method
;
import
java.util.Date
;
import
java.util.Map
;
/**
* 在读取@RequestBody注解的参数的时候，需要配合MyRequestWrapper使用
* 一遍保证这些参数可以在Controller层再次读取
*/
public class
LogManageInterceptor
extends
HandlerInterceptorAdapter {
private final
Logger
logger
= LoggerFactory.
getLogger
(LogManageInterceptor.
class
)
;
@Autowired
private
ActionLogsMapper
logMapper
;
public static final
String
USER_NAME
=
"user__name"
;
public static final
String
BRANCH_ID
=
"branch__id"
;
public static final
String
USER_ID
=
"user__id"
;
@Override
public boolean
preHandle
(HttpServletRequest request
,
HttpServletResponse response
,
Object handler)
throws
Exception {
if
(handler
instanceof
HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler
;
Method method = handlerMethod.getMethod()
;
LogAnnotation
annotation = method.getAnnotation(
LogAnnotation
.
class
)
;
if
(annotation !=
null
){
try
{
ActionLogs log =
new
ActionLogs()
;
//操作类型
log.setAction(annotation.action().getCode())
;
//操作目标方法
log.setCategory(annotation.targetMethod().getCode())
;
//操作人姓名
log.setActionTime(DateFormatUtils.
format
(
new
Date()
,
DateUtil.
DATETIME_DEFAULT_FORMAT
))
;
log.setIsmiddlemode(
2
)
;
Map<String
,
String[]> parameterMap = request.getParameterMap()
;
if
(parameterMap ==
null
|| parameterMap.isEmpty()){
MyRequestWrapper myRequestWrapper =
new
MyRequestWrapper((HttpServletRequest) request)
;
String body = myRequestWrapper.getBody()
;
JSONObject jsonObject = JSONObject.
parseObject
(body)
;
log.setOperator(jsonObject.getString(
USER_NAME
))
;
log.setOperatorId(jsonObject.getInteger(
USER_ID
))
;
log.setBranchId(jsonObject.getInteger(
BRANCH_ID
))
;
}
else
{
log.setOperator(request.getParameter(
USER_NAME
))
;
log.setOperatorId(Integer.
valueOf
(request.getParameter(
USER_ID
)))
;
log.setBranchId(Integer.
valueOf
(request.getParameter(
BRANCH_ID
)))
;
}
logMapper
.insertSelective(log)
;
}
catch
(Exception e){
logger
.error(
"记录操作日志错误 e:{}"
,
e)
;
}
}
}
return true;
}
}
