问题场景：在项目开发过程中需要记录用户的操作行为，即用户请求的url和相关url中带有的请求体参数，在springboot中只能在拦截器中读取了一次，在controller获取不到参数。
经过代码排查，发现ServletInputStream的流只能读取一次，从而影响到controller层接受request内容。
解决方案：
1、声明BodyReaderHttpServletRequestWrapper类继承HttpServletRequestWrapp将请求体中的流copy一份，重写getInputStream()和getReader()方法供外部使用
package com.hffss.config;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import org.springframework.util.StreamUtils;
/**
* 从请求体中获取参数请求包装类
* @author: Mr.FangLei
* @Date: 2022/4/14 15:31
*/
public class BodyReaderHttpServletRequestWrapper extends HttpServletRequestWrapper {
private byte[] requestBody = null;//用于将流保存下来
public BodyReaderHttpServletRequestWrapper(HttpServletRequest request) throws IOException {
super(request);
requestBody = StreamUtils.copyToByteArray(request.getInputStream());
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream(requestBody);
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) {
}
};
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
}
2、自定义MyFilter继承Filter，在Filter中对request对象用包装后的request替换（可重复读取流的请求对象构造完成，但是需要在拦截器中获取，需要将包装后的请求对象放在拦截器中，由于Filter在interceptor之前执行，可以通过Filter进行实现）
package com.hffss.config;
import lombok.extern.slf4j.Slf4j;
import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.BufferedReader;
import java.io.IOException;
/**
* @author: Mr.FangLei
* @Date: 2022/4/14 15:31
*/
@Slf4j
@WebFilter(urlPatterns = "/*",filterName = "MyFilter")
public class MyFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("开始");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if (request instanceof HttpServletRequest) {
requestWrapper = new BodyReaderHttpServletRequestWrapper((HttpServletRequest) request);
}
if (requestWrapper == null) {
chain.doFilter(request, response);
} else {
System.out.println("------------------------------请求报文----------------------------------");
System.out.println(getParamsFromRequestBody((HttpServletRequest) requestWrapper));
System.out.println("------------------------------请求报文----------------------------------");
chain.doFilter(requestWrapper, response);
}
}
/* *
* 获取请求体内容
* @return
* @throws IOException
*/
private String getParamsFromRequestBody(HttpServletRequest request) throws IOException {
BufferedReader br = null;
String listString = "";
try {
br = request.getReader();
String str = "";
while ((str = br.readLine()) != null) {
listString += str;
}
} catch (IOException e) {
e.printStackTrace();
}
return listString;
}
@Override
public void destroy() {
System.out.println("destroy");
}
}
3、在拦截器中获取请求体
package com.hffss.interceptor;
import com.hffss.entity.RequestLog;
import com.hffss.thread.SaveRequestLogTask;
import com.hffss.utils.IpUtil;
import com.hffss.utils.RequestUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.MediaType;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.Date;
import java.util.concurrent.ExecutorService;
@Slf4j
public class LogInterceptor implements HandlerInterceptor {
// 请求日志实体标识
private static final String LOGGER_ENTITY = "_logger_entity";
@Resource(name = "taskExecutor")
private ExecutorService taskExecutor;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
String param = "";
if (isJson(request)) {
// param = new RequestUtils().getRequestJsonString(request);
param = getParamsFromRequestBody(request);
}
RequestLog requestLog = new RequestLog();
Integer userId = RequestUtils.getUserId(request);
String uri = request.getRequestURI();
requestLog.setUserId(userId);
requestLog.setReqIp(IpUtil.getIpAddress(request));
requestLog.setReqParam(param);
requestLog.setReqUri(uri);
requestLog.setReqTime(new Date());
request.setAttribute(LOGGER_ENTITY, requestLog);
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 {
RequestLog requestLog = (RequestLog) request.getAttribute(LOGGER_ENTITY);
requestLog.setRespTime(new Date());
requestLog.setTimeUsed(requestLog.getRespTime().getTime() - requestLog.getReqTime().getTime());
taskExecutor.execute(new SaveRequestLogTask(requestLog));
}
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;
}
/**
* 获取请求体内容
* @return
* @throws IOException
*/
private String getParamsFromRequestBody(HttpServletRequest request) throws IOException {
BufferedReader reader = request.getReader();
StringBuilder builder = new StringBuilder();
try {
String line = null;
while((line = reader.readLine()) != null) {
builder.append(line);
}
return builder.toString();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
}
4、（重点）在Application启动类中需要注入Bean
package com.hffss;
import com.hffss.config.MyFilter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.util.unit.DataSize;
import org.springframework.web.client.RestTemplate;
import javax.servlet.MultipartConfigElement;
import java.time.Duration;
@SpringBootApplication
@EnableFeignClients
@EnableAsync
@EnableScheduling
@EnableJpaAuditing
@EnableDiscoveryClient
public class RiskCommonApplication {
public static void main(String[] args) {
SpringApplication.run(RiskCommonApplication.class, args);
}
/**
* 文件上传配置
*
* @return
*/
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
// 文件最大
factory.setMaxFileSize(DataSize.ofKilobytes(1024000)); // KB,MB
// 设置总上传数据总大小
factory.setMaxRequestSize(DataSize.ofKilobytes(10240000));
return factory.createMultipartConfig();
}
@Bean
public RestTemplate restTemplate(RestTemplateBuilder restTemplateBuilder) {
return restTemplateBuilder.setConnectTimeout(Duration.ofMillis(600000)).setReadTimeout(Duration.ofMillis(600000)).build();
}
@Bean
public FilterRegistrationBean<MyFilter> Filters() {
FilterRegistrationBean<MyFilter> registrationBean = new FilterRegistrationBean<MyFilter>();
registrationBean.setFilter(new MyFilter());
registrationBean.addUrlPatterns("/*");
registrationBean.setName("MyFilter");
return registrationBean;
}
}
FilterRegistrationBean方法中，registrationBean.setName("MyFilter");中的MyFilter要与自定义的MyFilter，注解@WebFilter(urlPatterns = "/*",filterName = "MyFilter")中的filterName保持一致否则不生效
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
