从DispatcherServlet源码分析SpringMVC处理请求的流程
Posted 敲代码的小小酥
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了从DispatcherServlet源码分析SpringMVC处理请求的流程相关的知识，希望对你有一定的参考价值。
前言
DispatcherServlet是SpringMVC实现的Servlet。请求最先到达DispatcherServlet，执行doService方法，在doService方法中，引出了一系列SpringMVC的相关操作。也就是说，请求到达DispatcherServlet之前，都是走的http服务器和J2EE的规范和流程。当达到DispatcherServlet执行doService方法时，才开始走SpringMVC流程。
UML类图
SpringMVC是如何加入到Spring容器的
DispatcherServlet本质是一个Servlet。它是和HTTP服务器挂钩的。Servlet是以initServletBean方法加入到程序内存中的，所以，我们看DispatcherServlet的initServletBean方法。该方法在其父类的FrameworkServlet类中实现，代码如下:
protected final void initServletBean() throws ServletException {
getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
if (logger.isInfoEnabled()) {
logger.info("Initializing Servlet '" + getServletName() + "'");
}
long startTime = System.currentTimeMillis();
try {
this.webApplicationContext = initWebApplicationContext();
initFrameworkServlet();
}
catch (ServletException | RuntimeException ex) {
logger.error("Context initialization failed", ex);
throw ex;
}
if (logger.isDebugEnabled()) {
String value = this.enableLoggingRequestDetails ?
"shown which may lead to unsafe logging of potentially sensitive data" :
"masked to prevent unsafe logging of potentially sensitive data";
logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
"': request parameters and headers will be " + value);
}
if (logger.isInfoEnabled()) {
logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
}
}
这个方法的核心逻辑是initWebApplicationContext方法，下面，我们结合实际项目的启动和请求流程，分析后面的方法。
首先需要强调的是，当项目启动后，并不会执行initServletBean方法，而是当请求第一次发送到后台服务器时，才会进入initServletBean方法。进入initServletBean方法后，执行initWebApplicationContext方法，下面进入该方法:
protected WebApplicationContext initWebApplicationContext() {
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
WebApplicationContext wac = null;
if (this.webApplicationContext != null) {
// A context instance was injected at construction time -> use it
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
if (!cwac.isActive()) {
// The context has not yet been refreshed -> provide services such as
// setting the parent context, setting the application context id, etc
if (cwac.getParent() == null) {
// The context instance was injected without an explicit parent -> set
// the root application context (if any; may be null) as the parent
cwac.setParent(rootContext);
}
configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
// No context instance was injected at construction time -> see if one
// has been registered in the servlet context. If one exists, it is assumed
// that the parent context (if any) has already been set and that the
// user has performed any initialization such as setting the context id
wac = findWebApplicationContext();
}
if (wac == null) {
// No context instance is defined for this servlet -> create a local one
wac = createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
// Either the context is not a ConfigurableApplicationContext with refresh
// support or the context injected at construction time had already been
// refreshed -> trigger initial onRefresh manually here.
synchronized (this.onRefreshMonitor) {
onRefresh(wac);
}
}
if (this.publishContext) {
// Publish the context as a servlet context attribute.
String attrName = getServletContextAttributeName();
getServletContext().setAttribute(attrName, wac);
}
return wac;
}
首先是从servletContext中获得到了WebApplicationContext对象。通过断点，我们看WebApplicationContext对象具体内容:
webServer：里面有tomcat的相关信息。
servletContext: 有servletContext上下文对象，可以获取Servlet环境信息。
Spring容器中的BeanFactory也能获取到。获取到BeanFactory，就可以获取到Spring容器中管理的对象。
applicationListeners:获取到系统的监听者对象。
综上描述，可以知道，我们可以在WebApplicationContext中获取tomcat信息，Spring信息，监听者信息等多种信息。对于我们在调试程序和找程序对应关系方面，起到了很大的作用。
继续往下执行initServletBean方法。下一个核心方法是onRefresh方法，onRefresh方法是钩子方法，执行的是DispatcherServlet类中的onRefresh方法，参数就是获取到的WebApplicationContext对象。
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
DispatcherServlet中的onRefresh方法又调用了initStrategies方法，下面看该方法:
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
在这个方法中，做了一系列的初始化操作，我们重点看initHandlerMappings和initHandlerAdapters方法。我们之前讲过，HandlerMapping和HandlerAdapters是SpringMVC的两大核心组件。我们先看initHandlerMappings的内部方法:
private void initHandlerMappings(ApplicationContext context) {
this.handlerMappings = null;
if (this.detectAllHandlerMappings) {
// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
Map<String, HandlerMapping> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerMappings = new ArrayList<>(matchingBeans.values());
// We keep HandlerMappings in sorted order.
AnnotationAwareOrderComparator.sort(this.handlerMappings);
}
}
else {
try {
HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
this.handlerMappings = Collections.singletonList(hm);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerMapping later.
}
}
// Ensure we have at least one HandlerMapping, by registering
// a default HandlerMapping if no other mappings are found.
if (this.handlerMappings == null) {
this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
由源码可知，matchingBeans对象获得了HandlerMapping集合，我们通过断点看初始化的HandlerMapping对象有哪些:
不同的HandlerMapping对应着不同情况的映射关系，如ReuqestMappingHandlerMaping存储我们写的@Controller的映射，SimpleUrlHandlerMapping存储静态资源的映射等。
我们看initHandlerAdapters初始化HandlerAdapter的方法:
private void initHandlerAdapters(ApplicationContext context) {
this.handlerAdapters = null;
if (this.detectAllHandlerAdapters) {
// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
Map<String, HandlerAdapter> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerAdapters = new ArrayList<>(matchingBeans.values());
// We keep HandlerAdapters in sorted order.
AnnotationAwareOrderComparator.sort(this.handlerAdapters);
}
}
else {
try {
HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
this.handlerAdapters = Collections.singletonList(ha);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerAdapter later.
}
}
// Ensure we have at least some HandlerAdapters, by registering
// default HandlerAdapters if no other adapters are found.
if (this.handlerAdapters == null) {
this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
初始化了如下的HandlerAdapter：
此外，initStrategies方法中还初始化了异常处理器等诸多因素。总之，SpringMVC的大部分组件，都是在这里进行的初始化操作。初始化方法都把WebApplication当作参数传入其中，将初始化的组件传到了WebApplicationContext中。而WebApplicationContext继承了ApplicationContext。这样，SpringMVC加入了Spring容器中。这也是称SpringMVC是Spring子容器的原因。
initStrategies方法执行完后，我们回到initWebApplicationContext方法中继续往下执行，看如下代码:
if (this.publishContext) {
// Publish the context as a servlet context attribute.
String attrName = getServletContextAttributeName();
getServletContext().setAttribute(attrName, wac);
}
我们看attrName的值:
由此可见，我们可以通过servletContext的attribute属性，获得SpringMVC的容器WebApplicationContext。attribute的key是org.springframework.web.servlet.FrameworkServlet.CONTEXT.dispatcherServlet。
至此，initWebApplicationContext方法执行完成，在这个方法中，初始化完成了SpringMVC容器。方法跳回到最初的initServletBean方法中，后续没有什么重要的步骤，我们不再往下讲解。
SpringMVC如何处理发来的请求
分析完SpringMVC容器的初始化，我们来看当请求到达SpringMVC时，逻辑是什么。
请求首先到DispatcherServlet的doService方法中，代码如下:
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
logRequest(request);
// Keep a snapshot of the request attributes in case of an include,
// to be able to restore the original attributes after the include.
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap<>();
Enumeration<?> attrNames = request.getAttributeNames();
while (attrNames.hasMoreElements()) {
String attrName = (String) attrNames.nextElement();
if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
attributesSnapshot.put(attrName, request.getAttribute(attrName));
}
}
}
// Make framework objects available to handlers and view objects.
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
if (this.flashMapManager != null) {
FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
if (inputFlashMap != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
}
try {
doDispatch(request, response);
}
finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
// Restore the original attribute snapshot, in case of an include.
if (attributesSnapshot != null) {
restoreAttributesAfterInclude(request, attributesSnapshot);
}
}
}
}
可以看到，doService方法中先为request的attribute赋值了一些属性，包括SpringMVC的容器WebApplicationContext。然后，进入了核心方法doDispatch方法，我们看该方法源码:
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);
// Determine handler for the current request.
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// Determine handler adapter for the current request.
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
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;
}
}
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
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);
}
}
}
}
我们先看该方法的注
以上是关于从DispatcherServlet源码分析SpringMVC处理请求的流程的主要内容，如果未能解决你的问题，请参考以下文章
Spring MVC工作原理及源码解析DispatcherServlet实现原理及源码解析
SpringMVC DispatcherServlet执行流程及源码分析