因項目需求, 配置了多個Filter對數據進行數據過濾，並且在進入controller之前需要進行一些日志處理，日活統計，數據預處理等行為，所以需要多次從ServletRequest獲取請求體數據， 但是因為HttpServletRequest中流讀取導致的標志位的移動， 使得數據只能讀取一次，因此利用HttpServletRequestWrapper進行數據緩存。
因為我controller層預處理的邏輯是相同，所以通過@ControllerAdvice 並且實現RequestBodyAdviceAdapter類方式進行了處理，在實現類中指定了需要預處理的url路徑和復寫了beforeBodyRead方法，但是這里踩了一個小坑： 在beforeBodyRead方法中使用inputMessage.getBody().read(body)讀取的數據永遠是body數組的第一個元素，原因是在實現的RequestWrapper類中創建的ServletInputStream對象未復寫available()方法，導致調用PushbackInputStream類中available()方法時調用的是InputStream.available()方法，返回的結果是0， 而不是數組的實際大小，導致獲取數據異常。
下面記錄一下這幾個類的實現
wrapper實現，用於緩存body數據
RequestWrapper
public class RequestWrapper extends HttpServletRequestWrapper {
/**
* 參數字節數組
*/
private byte[] body;
/**
* Http請求對象
*/
private HttpServletRequest request;
public RequestWrapper(HttpServletRequest request) throws IOException {
super(request);
this.request = request;
}
/**
* 獲取輸入流， 這里先將數據讀取出來保存到body中
* @return
* @throws IOException
*/
@Override
public ServletInputStream getInputStream() throws IOException {
if (null == this.body) {
ByteArrayOutputStream outs = new ByteArrayOutputStream();
IOUtils.copy(request.getInputStream(), outs);
this.body = outs.toByteArray();
}
final ByteArrayInputStream in = new ByteArrayInputStream(body);
return new MyServletInputStream(in);
}
public static class MyServletInputStream extends ServletInputStream {
private ByteArrayInputStream stream;
public MyServletInputStream(ByteArrayInputStream stream) {
this.stream = stream;
}
@Override
public boolean isFinished() {return false;}
@Override
public boolean isReady() {return false;}
@Override
public void setReadListener(ReadListener readListener) {}
@Override
public int read() throws IOException {return stream.read(); }
@Override
public int available() throws IOException {
return stream.available();
}
}
public byte[] getRequestBody() {
return body;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(this.getInputStream()));
}
}
Filter 實現， 一般wrapper都配合wrapper實現，這里相對重要，因為需要將wrapper數據放入到filter鏈路中
ChannelFilter
public class ChannelFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
Filter.super.init(filterConfig);
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
ServletRequest requestWrapper = null;
if(servletRequest instanceof HttpServletRequest) {
requestWrapper = new RequestWrapper((HttpServletRequest) servletRequest);
}
if(requestWrapper == null) {
filterChain.doFilter(servletRequest, servletResponse);
} else {
//使用復寫后的wrapper
filterChain.doFilter(requestWrapper, servletResponse);
}
}
@Override
public void destroy() {
Filter.super.destroy();
}
}
RequestBodyAdviceAdapter 實現類，在這個地方進行數據預處理
ExtractRequest
@Slf4j
@ControllerAdvice
public class ExtractRequest extends RequestBodyAdviceAdapter {
@Override
public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
// 這里返回true 那么執行后續beforeBodyRead 方法，返回false不執行
// 這里我是依照需求， 根據了url 進行了正則判斷
String[] value = methodParameter.getContainingClass().getAnnotation(RequestMapping.class).value();
return Arrays.stream(value).anyMatch(c -> ReUtil.isMatch("/contract/.*", c));
}
@Override
public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) throws IOException {
// 獲取inputStream 中的body 的字節數組
byte[] body = new byte[inputMessage.getBody().available()];
inputMessage.getBody().read(body);
try {
// 實現自己的業務邏輯
......
} catch (Exception e) {
log.error("解析請求參數失敗：{}", e.getMessage());
}
return super.beforeBodyRead(inputMessage, parameter, targetType, converterType);
}
}
請求路徑解析
一個請求發送到tomcat,如果存在 filter那么會優先執行filter,然后才會進入servlet容器中， 我們可以看進入到servlet的前一步的org.apache.catalina.core.StandardWrapperValve的invoke方法
invoke
// StandardWrapperValve
public final void invoke(Request request, Response response)
throws IOException, ServletException {
....
// 分配一個 servlet 實例來處理這個請求
try {
if (!unavailable) {
servlet = wrapper.allocate();
}
} catch (UnavailableException e) {
......
}
// 為此請求創建過濾器鏈
ApplicationFilterChain filterChain =
ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
// 調用filter鏈
// 在這個步驟同事也調用了servlet的service
Container container = this.container;
try {
if ((servlet != null) && (filterChain != null)) {
// Swallow output if needed
if (context.getSwallowOutput()) {
try {
SystemLogHandler.startCapture();
if (request.isAsyncDispatching()) {
request.getAsyncContextInternal().doInternalDispatch();
} else {
// 在這調用了doFilter的方法
filterChain.doFilter(request.getRequest(),
response.getResponse());
}
........
}
}
doFilter方法在ApplicationFilterChain中
doFilter
// ApplicationFilterChain
public void doFilter(ServletRequest request, ServletResponse response)
throws IOException, ServletException {
......
internalDoFilter(request,response);
}
在doFilter 中調用internalDoFilter 方法， 該方法中執行了filter的具體doFilter方法， 同時也執行了servlet的service（）方法,正式進入servlet容器
internalDoFilter
// ApplicationFilterChain
private void internalDoFilter(ServletRequest request,
ServletResponse response)
throws IOException, ServletException {
// 這里執行filter
if (pos < n) {
ApplicationFilterConfig filterConfig = filters[pos++];
try {
.....
if( Globals.IS_SECURITY_ENABLED ) {
....
SecurityUtil.doAsPrivilege ("doFilter", filter, classType, args, principal);
} else {
filter.doFilter(request, response, this);
}
} catch (IOException | ServletException | RuntimeException e) {
throw e;
} catch (Throwable e) {
e = ExceptionUtils.unwrapInvocationTargetException(e);
ExceptionUtils.handleThrowable(e);
throw new ServletException(sm.getString("filterChain.filter"), e);
}
return;
}
// 在filter 執行完成后執行service()
try {
if ((request instanceof HttpServletRequest) &&
(response instanceof HttpServletResponse) &&
Globals.IS_SECURITY_ENABLED ) {
.....
SecurityUtil.doAsPrivilege("service",
servlet,
classTypeUsedInService,
args,
principal);
} else {
servlet.service(request, response);
}
.......
}
DispatcherServlet
下面我們來着重看一個類DispatcherServlet , 這個類是不是看着很眼熟， 沒錯， 就是SpringMVC 的核心前端控制器，我們看一下他的繼承關系圖
上面說到在處理完filter后進入到servlet容器， 因為我們配置了DispatcherServlet作為控制器， 首先請求會進入到HttpServlet.service() 方法，然后根據請求方式（這里根據POST方法進行說明）， 進入到DispatcherServlet的父類FrameworkServlet.doPOST(), 最后調用了DispatcherSerlvet.doService()對於數據進行處理
在doService中進行了一些web上下文的配置，屬性的緩存等request的全局屬性設置， 同時進行了請求的分發doDispatcher
doDispatch
// DispatcherServlet
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 判斷是否有文件上傳
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// 從HandlerMapping獲取處理器對象,獲取對應的HandlerExecutionChain
// HandlerExecutionChain 由處理器對象和攔截器組成，攔截器相關執行都在這個類中執行
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// 獲取HandlerAdapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
String method = request.getMethod();
boolean isGet = HttpMethod.GET.matches(method);
if (isGet || HttpMethod.HEAD.matches(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
// 如果存在攔截器， 那么會先執行攔截器的preHandler 方法
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 這里是執行handler 方法，比如接收到servlet,Controller 就執行不同的Adapter
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
// 攔截器的postHandler
applyDefaultViewName(processedRequest, mv);
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
// As of 4.3, we're processing Errors thrown from handler methods as well,
// making them available for @ExceptionHandler methods and other scenarios.
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
triggerAfterCompletion(processedRequest, response, mappedHandler,
new NestedServletException("Handler processing failed", err));
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
handler是調用的AbstractHandlerMethodAdapter.handler(), 然后又調用了RequestMappingHandlerAdapter.handleInternal(),
RequestMappingHandlerAdapter類在SpringMVC中相當重要的一個類，他內部含有大量的web基礎組件來協助完成一陣個請求處理，這個類也比較龐大， 后續再新一份新的博客進行介紹，最后在RequestMappingHandlerAdapter類的invokeHandlerMethod方法中會生成一個ServletInvocableHandlerMethod對象對請求進行處理。
在執行到controller具體的方法之前， 需要把請求的參數解析包裝成相應的實體類， 具體由InvocableHandlerMethod.getMethodArgumentValues() 方法實現, 比如解析使用了@ResquestBody方法參數的RequestResponseBodyMethodProcessor類， 利用readWithMessageConverters方法讀取和轉化參數, 繼續跟着源碼走，發現到了AbstractMessageConverterMethodArgumentResolver中，在readWithMessageConverters對數據進行了預先處理
readWithMessageConverters
// AbstractMessageConverterMethodArgumentResolver
protected <T> Object readWithMessageConverters(HttpInputMessage inputMessage, MethodParameter parameter,
Type targetType) throws IOException, HttpMediaTypeNotSupportedException, HttpMessageNotReadableException {
......
EmptyBodyCheckingHttpInputMessage message = null;
try {
message = new EmptyBodyCheckingHttpInputMessage(inputMessage);
for (HttpMessageConverter<?> converter : this.messageConverters) {
Class<HttpMessageConverter<?>> converterType = (Class<HttpMessageConverter<?>>) converter.getClass();
GenericHttpMessageConverter<?> genericConverter =
(converter instanceof GenericHttpMessageConverter ? (GenericHttpMessageConverter<?>) converter : null);
if (genericConverter != null ? genericConverter.canRead(targetType, contextClass, contentType) :
(targetClass != null && converter.canRead(targetClass, contentType))) {
if (message.hasBody()) {
// 因為之前的ExtractRequest類只實現了beforeBodyRead，就只執行該方法
HttpInputMessage msgToUse =
getAdvice().beforeBodyRead(message, parameter, targetType, converterType);
body = (genericConverter != null ? genericConverter.read(targetType, contextClass, msgToUse) :
((HttpMessageConverter<T>) converter).read(targetClass, msgToUse));
body = getAdvice().afterBodyRead(body, msgToUse, parameter, targetType, converterType);
}
else {
body = getAdvice().handleEmptyBody(null, message, parameter, targetType, converterType);
}
break;
}
}
}
catch (IOException ex) {
省略.....
}
finally {
省略.....
}
然后調用adviceBean對象執行相應的切面方法，根據源碼走到了RequestResponseBodyAdviceChain.beforeBodyRead()如下圖所示
beforeBodyRead方法中傳入的是EmptyBodyCheckingHttpInputMessage實例對象，在該實例中存在兩個屬性body，headers，而body則是一個PushbackInputStream實例對象，這是一個可回退的流， 在這個實例中把之前RequestWrapper作為in參數傳入進去， 在ExtractRequest.beforeBodyRead方法中對請求體獲取輸入流的字節數的時候就會調用in.available()方法， 這也是我之前未在MyServletInputStream中復寫available() 導致踩坑的原因。