最近在写日志管理，想着使用拦截器加注解的方式，但是遇到了一个问题，就是如果使用@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;
}
}
