SpringMVC源码学习笔记之请求处理流程
一、常用组件
1、DispatcherServlet
前端控制器，SpringMVC里最核心的组件，是整个SpringMVC请求流程的中心，主要流程都是由DispatcherServlet来调用其他组件，而且看名字就知道，它是一个Servlet
2、HandlerMapping
处理器映射器，根据请求来查找对应的处理器Handler，其实就是Controller
3、Handler（Controller）
处理器，由软件工程师开发，其实就是Controller，用于具体处理用户的请求
4、HandlerAdapter
处理器适配器，因为SpringMVC中的Handler可以是任意的形式，只要能处理请求就可以了，但是Servlet需要的处理方法的结构却是固定的，都是以request和response为参数的方法，所以如何让固定的Servlet处理方法调用灵活的Handler来进行处理呢？这就要用到HandlerAdapter了
注：网上看到一个很有意思的形容：
Handler是用来干活的工具
HandlerMapping用来根据需要干的活找到对应的工具
HandlerAdapter是使用工具干活的人
5、ViewResolver
视图解析器，根据视图名称解析成View类型的视图，View是用来渲染页面的，也就是将程序返回的数据填入模板里，生成html或者其他类型的文件，具体使用哪个模板，用什么规则填入数据就是ViewResolver要做的事，然后具体的渲染交给View去做
二、流程图
流程梳理：
1、用户通过浏览器发送请求到前端控制器（DispatcherServlet）
2、前端控制器（DispatcherServlet）将用户请求交给处理器映射器（HandlerMapping）
3-4、处理器映射器（HandlerMapping）找到负责这个请求的处理器（Handler）并和拦截器链一起封装成处理器执行链（HandlerExecutionChain）交给前端控制器（DispatcherServlet）
5、前端控制器（DispatcherServlet）会根据处理器（Handler）找到对应的处理器适配器(HandlerAdaptor)
6-9、处理器适配器(HandlerAdaptor) 会去执行具体的Controller，Controller将处理结果及要跳转的视图封装到ModelAndView返回给处理器适配器(HandlerAdaptor)，并在执行Controller前后调用拦截器链
10、处理器适配器(HandlerAdaptor) 将ModelAndView返回给前端控制器（DispatcherServlet）
11、前端控制器（DispatcherServlet）将ModelAndView交给视图解析器（ViewResolver）
12、视图解析器（ViewResolver）将ModelAndView解析为具体的视图（View）返回给前端控制器（DispatcherServlet）
13、前端控制器（DispatcherServlet）调用视图对象，让其自己 (View) 进行渲染（将模型数据填充至视图中） ，形成响应 (HttpResponse)
14、前端控制器（DispatcherServlet）将响应 (HttpResponse) 返回给浏览器
三、源码解读
1、doDispatch
首先我们要先知道SpringMVC的Servlet分为三层HttpServletBean、FrameworkServlet和DispatcherServlet，我们知道Servlet的入口是service方法，FrameworkServlet重写了service方法，我们往里跟代码，最终会来到DispatcherServlet的核心方法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);
//获取处理器,注意这里的mappedHandler里包含了handler和拦截器链
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
//找不到处理器,报404
noHandlerFound(processedRequest, response);
return;
}
//根据处理器里的handler获取对应的适配器
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
//处理last-modified请求头
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
//在处理请求前先执行拦截器的preHandle方法,这个方法会返回一个boolean类型的值
//如果是true,就交给后面的拦截器继续处理,
//如果是false就表示处理完了,顺便也把response搞定
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
//用适配器处理请求,返回ModelAndView
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//判断是否需要viewNameTranslator从request里获取view的名字
applyDefaultViewName(processedRequest, mv);
//执行拦截器的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);
}
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()) {
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}2、getHandler
//获取处理器,注意这里的mappedHandler里包含了handler和拦截器链
mappedHandler = getHandler(processedRequest);首先我们看下18行的getHandler方法，对应流程图中的2-4步
//DispatcherServlet
@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
//逐个使用HandlerMapping去获取Handler,如果获取到了就返回,没获取到就换下一个
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}这里的handlerMappings是个List集合，HandlerMapper有很多实现类，最重要的就是RequestMappingHandlerMapping和BeanNameUrlHandlerMapping，我们记住这两个类，继续看第7行getHandler，进入到AbstractHandlerMapping类里
//AbstractHandlerMapping
@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//获取handler
Object handler = getHandlerInternal(request);
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
//找到匹配的拦截器和handler一起封装成一个HandlerExecutionChain
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (logger.isTraceEnabled()) {
logger.trace("Mapped to " + handler);
}
else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
logger.debug("Mapped to " + executionChain.getHandler());
}
if (CorsUtils.isCorsRequest(request)) {
CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}核心逻辑是第6行的getHandlerInternal，getHandlerInternal是个模板方法，最终会调用子类实现，这里有两个重要的实现类，分别是AbstractHandlerMethodMapping和AbstractUrlHandlerMapping，上面我们提到HandlerMapper有两个非常主要的实现类：RequestMappingHandlerMapping和BeanNameUrlHandlerMapping，我们看看这两个类的类图
我们发现RequestMappingHandlerMapping是AbstractHandlerMethodMapping的子类，而BeanNameUrlHandlerMapping是AbstractUrlHandlerMapping的子类
RequestMappingHandlerMapping：主要用来存储RequestMapping注解相关的控制器和url的映射关系
BeanNameUrlHandlerMapping： 主要用来处理Bean name直接以 / 开头的控制器和url的映射关系。
我们最常用的其实还是RequestMappingHandlerMapping，所以我们进入AbstractHandlerMethodMapping的getHandlerInternal方法，继续看
//AbstractHandlerMethodMapping
@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
//获取requestMapping地址
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
this.mappingRegistry.acquireReadLock();
try {
//查找Handler
HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}
finally {
this.mappingRegistry.releaseReadLock();
}
}第9行核心方法进去
//AbstractHandlerMethodMapping
@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
List matches = new ArrayList<>();
//从mappingRegistry中获取命中的方法
List directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
if (directPathMatches != null) {
//寻找合适的mapping,根据属性去精确查找,最终防到matches中
addMatchingMappings(directPathMatches, matches, request);
}
if (matches.isEmpty()) {
// No choice but to go through all mappings...
addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
}
if (!matches.isEmpty()) {
Comparator comparator = new MatchComparator(getMappingComparator(request));
matches.sort(comparator);
Match bestMatch = matches.get(0);
if (matches.size() > 1) {
if (logger.isTraceEnabled()) {
logger.trace(matches.size() + " matching mappings: " + matches);
}
if (CorsUtils.isPreFlightRequest(request)) {
return PREFLIGHT_AMBIGUOUS_MATCH;
}
Match secondBestMatch = matches.get(1);
if (comparator.compare(bestMatch, secondBestMatch) == 0) {
Method m1 = bestMatch.handlerMethod.getMethod();
Method m2 = secondBestMatch.handlerMethod.getMethod();
String uri = request.getRequestURI();
throw new IllegalStateException(
"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
}
}
request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
handleMatch(bestMatch.mapping, lookupPath, request);
return bestMatch.handlerMethod;
}
else {
return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
}
} 具体看下第9行addMatchingMappings
private void addMatchingMappings(Collection mappings, List matches, HttpServletRequest request) {
for (T mapping : mappings) {
T match = getMatchingMapping(mapping, request);
if (match != null) {
matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
}
}
} 这里有个mappingRegistry很重要，mappingRegistry.getMappings，返回的是HandlerMethod的map，这一步相当于把匹配到的HandlerMethod封装到Match对象中，最后加到matches集合里，最后排序，取出第一个匹配的Handler返回
我们回到getHandler方法
//AbstractHandlerMapping
@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
//获取handler
Object handler = getHandlerInternal(request);
if (handler == null) {
handler = getDefaultHandler();
}
if (handler == null) {
return null;
}
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
//找到匹配的拦截器和handler一起封装成一个HandlerExecutionChain
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (logger.isTraceEnabled()) {
logger.trace("Mapped to " + handler);
}
else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
logger.debug("Mapped to " + executionChain.getHandler());
}
if (CorsUtils.isCorsRequest(request)) {
CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}第6行返回的就是刚才的HandlerMethod对象，然后调用getHandlerExecutionChain方法，将HandlerMethod和拦截器链封装成HandlerExecutionChain对象返回
3、HandlerAdapter.handle
//用适配器处理请求,返回ModelAndView
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());下面看第47行handle方法，点击进到实现类AbstractHandlerMethodAdapter的handle方法中
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return handleInternal(request, response, (HandlerMethod) handler);
}继续点击handleInternal进入子类RequestMappingHandlerAdapter的handleInternal方法中
//RequestMappingHandlerAdapter
@Override
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
//检查是否支持当前request的请求方式和session
checkRequest(request);
//如果需要,在同步块中执行invokeHandlerMethod。
if (this.synchronizeOnSession) {
HttpSession session = request.getSession(false);
if (session != null) {
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
//无HttpSession可用->无需互斥
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
//不需要同步会话
mav = invokeHandlerMethod(request, response, handlerMethod);
}
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
prepareResponse(response);
}
}
return mav;
}最终会调用invokeHandlerMethod方法，点击进去
//RequestMappingHandlerAdapter
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
//省略...
invocableMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
return getModelAndView(mavContainer, modelFactory, webRequest);
}
finally {
webRequest.requestCompleted();
}
}继续点击10行invokeAndHandle进到类ServletInvocableHandlerMethod中
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//重点
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
setResponseStatus(webRequest);
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
mavContainer.setRequestHandled(true);
return;
}
}
else if (StringUtils.hasText(getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
}
catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(formatErrorForReturnValue(returnValue), ex);
}
throw ex;
}
}点击5行invokeForRequest进入其父类InvocableHandlerMethod中
@Nullable
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);
}其中doInvoke方法最终会通过反射调用到Controller上的方法，我们具体看看getMethodArgumentValues方法
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
//获取Controller对应的方法所有参数,该部分在程序启动时就已经解析好了
if (ObjectUtils.isEmpty(getMethodParameters())) {
return EMPTY_ARGS;
}
MethodParameter[] parameters = getMethodParameters();
Object[] args = new Object[parameters.length];
//遍历所有参数,进行赋值
for (int i = 0; i < parameters.length; i++) {
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
args[i] = findProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
if (!this.resolvers.supportsParameter(parameter)) {
throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
}
try {
//解析参数并赋值,这里会根据参数找到对应的解析器进行解析
args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
}
catch (Exception ex) {
if (logger.isDebugEnabled()) {
String error = ex.getMessage();
if (error != null && !error.contains(parameter.getExecutable().toGenericString())) {
logger.debug(formatArgumentError(parameter, error));
}
}
throw ex;
}
}
return args;
}