DispatcherServlet 初始化

在一个简单的Spring MVC项目中，需要web.xml配置DispatcherServlet

<!--配置DispatcherServlet-->
<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring/spring-*.xml</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <!--默认匹配所有请求-->
    <url-pattern>/</url-pattern>
</servlet-mapping>

contextConfigLocation 指定spring配置文件位置，除此之外无其他加载Spring ApplicationContex配置的代码。那么Spring ApplicationContext的加载肯定是随着 DispatcherServlet 初始化而加载，并且使用的是此contextConfigLocation 指定的配置文件位置。

看看DispatcherServlet继承结构

image

在Servlet中有一个init方法，执行servlet初始化操作，在子类 HttpServletBean 中进行重写此方法，并调用initServletBean()方法完成环境的加载，initServletBean在子类中通过重写，完成bean加载任务。

HttpServletBean.init()：

@Override
    public final void init() throws ServletException {
        // Set bean properties from init parameters.
        // 将web.xml配置的属性设置到dispatcherServlet的属性中，除了contextConfigLocation属性，
        // 在DispatcherServlet的构造函数注释中还说明有contextClass、contextInitializerClasses
        ...

        // Let subclasses do whatever initialization they like.
        // 空方法，子类重写，完成bean加载任务
        initServletBean();
    }

在子类FrameworkServlet中重写initServletBean()方法，完成创建WebApplicationContext。

FrameworkServlet.initServletBean()：

@Override
protected final void initServletBean() throws ServletException {
    //log
    ...
    this.webApplicationContext = initWebApplicationContext();
    initFrameworkServlet();
    //log
    ...
}

initFrameworkServlet()是个空方法，子类也并未重写，这里主要是initWebApplicationContext()，初始化WebApplicationContext。

FrameworkServlet.initWebApplicationContext()：

// 初始化并发布此servlet的WebApplicationContext。
// 真正创建context的工作委派给createWebApplicationContext方法。
protected WebApplicationContext initWebApplicationContext() {
   // 查找rootContext，并设置当前servlet的parent
   ...
   if (wac == null) {
      //查找是否手动设置过context
      wac = findWebApplicationContext();
   }
   if (wac == null) {
      // No context instance is defined for this servlet -> create a local one
      // 创建context
      wac = createWebApplicationContext(rootContext);
   }

   if (!this.refreshEventReceived) {
      // 刷新applicationContext，和ConfigurableApplicationContext.refresh() 方法类似，
      // 完成servlet 的 handlerMapping、viewResolver等获取
      onRefresh(wac);
   }

   if (this.publishContext) {
      // 将context作为servlet上下文属性发布。
       String attrName = getServletContextAttributeName();
       getServletContext().setAttribute(attrName, wac);
   }

   return wac;
}

重点在于创建createWebApplicationContext()和onRefresh()，先看createWebApplicationContext方法

FrameworkServlet.createWebApplicationContext(@Nullable ApplicationContext parent)：

// 实例化此 servlet 的 WebApplicationContext，之前有提到，在web.xml配置文件中可以配置 contextClass，
// 如果未配置则使用默认的 XmlWebApplicationContext，此处，自定义的额contexClass需要实现
// ConfigurableWebApplicationContext 接口
protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
   // web.xml 配置，默认 XmlWebApplicationContext
   Class<?> contextClass = getContextClass();
    ...
   // 实例化 ApplicationContext
   ConfigurableWebApplicationContext wac =
         (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

   wac.setEnvironment(getEnvironment());
   wac.setParent(parent);
   // web.xml 配置，spring 配置位置
   String configLocation = getContextConfigLocation();
   if (configLocation != null) {
      wac.setConfigLocation(configLocation);
   }
   // 加载并刷新，这里完成 IOC 容器的装载
   configureAndRefreshWebApplicationContext(wac);

   return wac;
}

FrameworkServlet.configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac)：

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
   ...
   wac.setServletContext(getServletContext());
   wac.setServletConfig(getServletConfig());
   wac.setNamespace(getNamespace());
   // 设置listener使得context刷新，servlet也跟着刷新
   wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

   // 为 post-processing or initialization 初始化配置属性
   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
   }

   postProcessWebApplicationContext(wac);
   // 这里会取之前提到的，在web.xml中配置的 contextInitializerClasses 初始化context
   // contextInitializerClasses 需实现 ApplicationContextInitializer 接口
   applyInitializers(wac);
   // context refresh 初始化容器、事件监听、source等
   wac.refresh();
}

至此容器初始化完成，但是容器与 servlet 之间并未关联起来，现在回到FrameworkServlet.initWebApplicationContext()方法，

protected WebApplicationContext initWebApplicationContext() {
   
   if (wac == null) {
      wac = createWebApplicationContext(rootContext);
   }

   if (!this.refreshEventReceived) {
      // context不是ConfigurableApplicationContext或者已经刷新过，则手动刷新，将容器中相关的handlerMapping、viewResolver关联到servlet
      onRefresh(wac);
      // 之前 configureAndRefreshWebApplicationContext 方法中配置listener可以监听context的刷新事件，并自动调用servlet 的 onRefresh 方法
   }

   return wac;
}

DispatcherServlet.onRefresh(ApplicationContext context)：

@Override
protected void onRefresh(ApplicationContext context) {
   initStrategies(context);
}

/**
 * Initialize the strategy objects that this servlet uses.
 * <p>May be overridden in subclasses in order to initialize further strategy objects.
 */
protected void initStrategies(ApplicationContext context) {
    // 文件上传
   initMultipartResolver(context);
    // 多语言
   initLocaleResolver(context);
    // 组图
   initThemeResolver(context);
    // handlerMapping
   initHandlerMappings(context);
    // handlerAdapter
   initHandlerAdapters(context);
    // 异常
   initHandlerExceptionResolvers(context);
    // 请求 -> 视图
   initRequestToViewNameTranslator(context);
    // 视图解析
   initViewResolvers(context);
    // flashMapManager
   initFlashMapManager(context);
}

这几个方法都是从容器中将所需要的相应的bean放到 DispatcherServlet中，以下属性中：

private MultipartResolver multipartResolver;
private LocaleResolver localeResolver;
private ThemeResolver themeResolver;
private List<HandlerMapping> handlerMappings;
private List<HandlerAdapter> handlerAdapters;
private List<HandlerExceptionResolver> handlerExceptionResolvers;
private RequestToViewNameTranslator viewNameTranslator;
private FlashMapManager flashMapManager;
private List<ViewResolver> viewResolvers;

这样容器中的bean就可以为 DispatcherServlet 所用了。这里以initHandlerMappings(ApplicationContext context)为例

private void initHandlerMappings(ApplicationContext context) {
   this.handlerMappings = null;

   //将ApplicationContext中HandlerMappings找出来并放在handlerMappings中
   ...

   // 确保至少有一个HandlerMapping, 否则配置一个默认的HandlerMapping
   if (this.handlerMappings == null) {
      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
      }
   }
}

在未找到 HandlerMapping 时，会在配置文件中读取默认配置，默认的配置在DispatcherServlet.properties中，可以看到默认的HandlerMapping有两个

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
   org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

同理我们的DispatcherServlet也拿到了其他的 bean，至此，servlet环境是初始化完成了，接下来看DispatcherServlet怎么处理请求的。

DispatcherServlet 处理请求

在处理请求之前先看一下Spring MVC处理请求的流程：

image

DispatcherServlet接收到请求后，将Request交由 HandlerMapping 查找相应的 Controller ，然后由HandlerAdapter去执行具体的 Controller 的方法，处理返回 ModelAndView ，然后根据视图名称查找页面，此后就是页面渲染，返回页面了。

DispatcherServlet 中处理Http请求的方法，doGet、doPost等，都是由父类 FrameworkServlet 实现 ，最终调用到 DispatcherServlet.doDispatch() 方法，这个是真正处理请求的方法。

DispatcherServlet.doDispatch() ：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    ...
    // 确定当前请求的handler。
    mappedHandler = getHandler(processedRequest);
    // 确定当前请求的handler adapter。
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    // PreHandle （interceptor.preHandle），预拦截器
    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        return;
    }
    // 实际调用处理程序。
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    // 确定视图名称
    applyDefaultViewName(processedRequest, mv);
    // 后拦截器
    mappedHandler.applyPostHandle(processedRequest, response, mv);
    // 处理视图 
    processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    ...
}

这里看重点看一下getHandler方法

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   for (HandlerMapping hm : this.handlerMappings) {
      HandlerExecutionChain handler = hm.getHandler(request);
      if (handler != null) {
         return handler;
      }
   }
   return null;
}

这里遍历handlerMappings 直到能根据request匹配到handler，getHandler 方法的实现在AbstractHandlerMapping 类中

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
   // 获取handler
   Object handler = getHandlerInternal(request);
   if (handler == null) {
      handler = getDefaultHandler();
   }
   if (handler == null) {
      return null;
   }
   // 实现 Controller 接口的controller
   // Bean name or resolved handler?
   if (handler instanceof String) {
      String handlerName = (String) handler;
      handler = obtainApplicationContext().getBean(handlerName);
   }

   // 根据 handler 生成 ExecutionChain ，主要是添加拦截器
   HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
   // Cors
   if (CorsUtils.isCorsRequest(request)) {
      CorsConfiguration globalConfig = this.globalCorsConfigSource.getCorsConfiguration(request);
      CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
      CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
      executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
   }
   return executionChain;
}

关于获取handler，这里以 RequestMappingHandlerMapping 的实现讲解，因为RequestMappingHandlerMapping 是匹配 @Controller注解的controller，日常使用较多。RequestMappingHandlerMapping 使用的父类AbstractHandlerMethodMapping 的 getHandlerInternal方法。

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
   String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);

   this.mappingRegistry.acquireReadLock();
   try {
      HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
      return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
   }
   finally {
      this.mappingRegistry.releaseReadLock();
   }
}

调用lookupHandlerMethod()方法获取 HandlerMethod，这个 HandlerMethod 就是具体需要执行的某个 controller 中的某个方法，只要反射调用其中的 method 就能获得调用结果。

lookupHandlerMethod()是怎么获得 HandlerMethod 的呢？该方法主要是根据AbstractHandlerMethodMapping内部的变量 MappingRegistry mappingRegistry 获取的，在 MappingRegistry 内部，我们可看到如下变量

private final Map<T, MappingRegistration<T>> registry = new HashMap<>();
private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();
private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();
private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

也就是说 HandlerMapping 中已经有了 请求路径 -> handler 的映射的集合，只要根据相应的方法获取即可。那么问题来了，如果我们写一个@Controller 注解的 controller，那这个 controller 是如何处理被映射到 HandlerMapping 中的呢？

HandlerMapping 注册请求映射

RequestMappingHandlerMapping实现的接口中，其中一个是InitializingBean，在 Bean 实例化的过程中有一步便是检测是否有InitializingBean接口，若有，则执行其afterPropertiesSet方法。（单一Bean的实例化主要在AbstractAutowireCapableBeanFactory#doCreateBean方法）。那么回到RequestMappingHandlerMapping的afterPropertiesSet()方法，该方法主要是调用AbstractHandlerMethodMapping的initHandlerMethods()方法完成请求映射。

// AbstractHandlerMethodMapping#initHandlerMethods
protected void initHandlerMethods() {
   String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
         BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
         getApplicationContext().getBeanNamesForType(Object.class));

   // 遍历所有的bean name
   for (String beanName : beanNames) {
      if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
         Class<?> beanType = null;
         try {
            beanType = getApplicationContext().getType(beanName);
         }
         catch (Throwable ex) {
         }
         // 判断是否为Handler，RequestMappingHandlerMapping是根据是否有Controller或RequestMapping注解
         if (beanType != null && isHandler(beanType)) {
            // 根据beanName，装载handlerMethod
            detectHandlerMethods(beanName);
         }
      }
   }
   handlerMethodsInitialized(getHandlerMethods());
}
// RequestMappingHandlerMapping#isHandler，根据是否有Controller或RequestMapping注解
protected boolean isHandler(Class<?> beanType) {
    return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
            AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}
// AbstractHandlerMethodMapping#detectHandlerMethods
protected void detectHandlerMethods(final Object handler) {
    // handlerType，可能为proxy
    Class<?> handlerType = ...
    // 实际类型
    final Class<?> userType = ClassUtils.getUserClass(handlerType);

    // 找到 Medhod -> RequestMappingInfo的映射，RequestMappingHandlerMapping会根据是否有RequestMapping注解判断
    Map<Method, T> methods = ...
        
    for (Map.Entry<Method, T> entry : methods.entrySet()) {
        Method invocableMethod = AopUtils.selectInvocableMethod(entry.getKey(), userType);
        T mapping = entry.getValue();
        // 注册到 mappingRegistry 中
        registerHandlerMethod(handler, invocableMethod, mapping);
    }
}

那么至此，整个 spring mvc 初始化、处理请求的流程也就结束了。

结语

DispatcherServlet 的初始化会伴随Spring 容器的初始化，并获取容器中的bean完成servlet处理请求所需要的配置装载。最后以一张流程图总结

image