SpringBoot源码分析（请求部分）_springboot解析请求行代码_Rex·Lin的博客-CSDN博客
SpringBoot一个请求的处理全过程_springboot 请求处理流程_骑个小蜗牛的博客-CSDN博客
https://www.cnblogs.com/yaphetsfang/articles/12552322.html
1.1容器及内部组件关系图
1.2 请求详细流程图
1.3 请求流程解读（FilterChain之后）
1、Tomcat线程接受到请求，经过一系列调用后，调用到ApplicationFilterChain的doFilter方法。过滤器链ApplicationFilterChain.doFilter方法内部调用internalDoFilter方法，依次执行每个过滤器Filter的doFilter。
2、过滤器链的所有Filter.doFilter方法执行完毕，经过一系列调用后，调用到DispatcherServlet的doDispatch方法。doDispatch方法的主要流程：
①、DispatcherServlet的getHandler方法：得到处理执行器链（包含处理器和拦截器链）。
②、DispatcherServlet的getHanlderAdapter方法：得到处理器适配器。
③、HandlerExecutionChain的applyPreHandle方法：执行执行器链中的所有拦截器Interceptor的preHanlde。
④、AbstracthandlerMethodAdapter的handle方法：该方法办好路径映射、参数绑定（参数解析、参数转换、参数校验）、调用具体的控制器方法、返回值处理（含信息转换）等操作。
handle方法：调用RequestMappingHandlerAdapter 的hanldeInternal方法，handleInternal方法再调用RequestMappingHandlerAdapter#invokeHanlderMethod方法 。
invokeHanlderMethod方法：
一、 RequestMappingHandlerAdapter的createInvocableHanldeMethod方法：注册参数解析器、返回值处理、信息转化器等到ServletInvoableHanlderMethod对象实例中。
二、调用ServletInvocableHandlerMethod#invokeAndHandle方法。
invokeAndHandle方法：
①、调用InvocableHandlerMethod#invokeForRequest方法。invokeForRequest方法调用 InvocableHandlerMethod#doInvoke方法。
doInvoke方法：
1、调用InvocableHanlderMethod的getMethodArgumentValues方法：路径映射、参数绑定（参数解析、参数转换、参数校验）。
2、调用Method#invoke方法，内部调用DelegatingMethodAccessorImpl#invoke方法，内部调用NativeMethodAccessorImpl#invoke方法，内部调用具体的Controller的具体方法，得到响应结果。
②、调用HandlerMethodReturnValueHanlderComposite的handleReturnValue方法：返回值处理（含信息转换）。
⑤、HandlerExecutionChain的applyPostHandle方法：执行执行器链中的所有拦截器Interceptor的postHanlde。
⑥、调用DispatcherServlet的processDispatchResult方法。
1、调用DispatcherServlet的processHandlerException方法：异常处理（获取合适的异常解析器处理异常信息，@ControllerAdvice全局异常处理和自定义异常解析器都是在这一步执行的）。
2、调用DispatcherServlet的render方法：视图解析渲染。
3、调用HandlerExecutionChain的triggerAfterCompletion方法：执行执行器链中的所有拦截方法afterCompletion。
3、控制权交回ApplicationFilterChain ， 继续执行过滤器链的所有doFIlter之后的代码。
2、源码解析
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);
// 得到处理执行器链（包含处理器和连接器链）
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// 得到处理器适配器.
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
......
// 执行 执行器链中的所有拦截器Interceptor的preHandle
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 路径映射、参数绑定（参数解析、参数转换、参数校验）、调用具体控制器的具体方法、返回值处理（含信息转换）等操作。
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
applyDefaultViewName(processedRequest, mv);
// 执行执行器链中所有拦截器Interceptor的postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
// 异常处理、视图渲染、执行器链中所有拦截方法afterCompletion
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
......
}
/**
* org.springframework.web.servlet.DispatcherServlet#getHandler
* this.handlerMappings再Spring中已经预定了5个常用的请求处理器：
* 1、RequestMappingHandlerMapping:用于请求，保存了所有@RequestMapping和handler的映射规则；
* 2、WelcomePageHandlerMapping:用于处理欢迎页；
* 3、BeanNameUrlHandlerMapping:处理容器中以/开头的bean;
* 4、RouterFunctionMapping:处理RouterFunction发起的请求;
* 5、SimpleUrlHandlerMapping:处理请求的映射关系。
*/
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}/**
* org.springframework.web.servlet.DispatcherServlet#getHandlerAdapter
* 预定义了常用的适配器：
* 1、RequestMappingHandlerAdapter:支持方法上标注@RequestMapping
* 2、HandlerFunctionAdapter:支持函数式编程
* 3、HttpRequesthandlerAdapter:http请求处理适配器
* 4、SimpleControllerHandlerAdapter:简单控制器处理器适配器。
*
*/
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
if (this.handlerAdapters != null) {
for (HandlerAdapter adapter : this.handlerAdapters) {
// 遍历系统中的适配器，看看哪种支持处理当前请求的handler
if (adapter.supports(handler)) {
return adapter;
}
}
}
throw new ServletException("No adapter for handler [" + handler +
"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
HandlerInterceptor[] interceptors = getInterceptors();
if (!ObjectUtils.isEmpty(interceptors)) {
for (int i = 0; i < interceptors.length; i++) {
HandlerInterceptor interceptor = interceptors[i];
if (!interceptor.preHandle(request, response, this.handler)) {
triggerAfterCompletion(request, response, null);
return false;
}
this.interceptorIndex = i;
}
}
return true;
}/**
* org.springframework.web.servlet.DispatcherServlet#doDispatch
*/
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
/**
* org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter#handle
*/
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return handleInternal(request, response, (HandlerMethod) handler);
}
/**
* org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#handleInternal
*/
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
checkRequest(request);
// Execute invokeHandlerMethod in synchronized block if required.
if (this.synchronizeOnSession) {
HttpSession session = request.getSession(false);
if (session != null) {
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No HttpSession available -> no mutex necessary
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No synchronization on session demanded at all...
mav = invokeHandlerMethod(request, response, handlerMethod);
}
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
prepareResponse(response);
}
}
return mav;
}
/**
* org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter#invokeHandlerMethod
*/
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
......
invocableMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
return getModelAndView(mavContainer, modelFactory, webRequest);
}
finally {
webRequest.requestCompleted();
}
}
/**
* org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod#invokeAndHandle
*/
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//参数解析、调用目标方法、得到返回值
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
......
//处理返回值
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
......
}
/**
* org.springframework.web.method.support.InvocableHandlerMethod#invokeForRequest
*/
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Arguments: " + Arrays.toString(args));
}
/**
* 调用目标方法
*
*/
return doInvoke(args);
}
/**
* org.springframework.web.method.support.InvocableHandlerMethod#getMethodArgumentValues
*/
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
......
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
......
try {
// 解析指定参数
args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
}
......
}
return args;
}
/**
* org.springframework.web.method.support.HandlerMethodArgumentResolverComposite#resolveArgument
* 找到合适的参数解析器 HandlerMethodArgumentResolver
*
*/
public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
// 获取参数解析器
HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
if (resolver == null) {
throw new IllegalArgumentException("Unsupported parameter type [" +
parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
}
// 解析方法的参数
return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
}
参数解析器HandlerMethodArgumentResolver：预定义了27种
返回值处理器：
视图解析器
651
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
