Spring 源码分析(四) ——MVC(五)初始化阶段

原创
2016/04/02 19:18
阅读数 1.8K

DispatcherServlet 的初始化

        Spring MVC 是基于 Servlet 功能实现的,通过实现 Servlet 接口的 DispatcherServlet 来封装其核心功能实现,通过将请求分派给处理程序,同时带有可配置的处理程序映射、视图解析、本地语言、主题解析以及上载文件支持。下面是 DispatcherServlet 的继承图:

        servlet 初始化阶段会调用其 init 方法,所以我们首先要查看在 DispatcherServlet 中是否重写了 init 方法。我们在其父类 HttpServletBean 中找到了该方法。

HttpServletBean.java

public final void init() throws ServletException {
   if (logger.isDebugEnabled()) {
      logger.debug("Initializing servlet '" + getServletName() + "'");
   }

   // Set bean properties from init parameters.
   try {
      // 解析 init-param 并封装只 pvs 中
      PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
      // 将当前的这个 Servlet 类转化为一个 BeanWrapper,从而能够以 Spring 的方法来对 init-param 的值进行注入
      BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
      ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
      // 注册自定义属性编辑器,一旦遇到 Resource 类型的属性将会使用 ResourceEditor 进行解析
      bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
      // 空实现,留给子类覆盖
      initBeanWrapper(bw);
      // 属性注入
      bw.setPropertyValues(pvs, true);
   }
   catch (BeansException ex) {
      logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
      throw ex;
   }

   // Let subclasses do whatever initialization they like.
   initServletBean();

   if (logger.isDebugEnabled()) {
      logger.debug("Servlet '" + getServletName() + "' configured successfully");
   }
}

        初始化的主要过程时序图如下:

        DipatcherServlet 的初始化过程主要是通过将当前的 servlet 类型实例转换为 BeanWrapper 类型实例,以便使用 Spring 中提供的注入功能进行对应属性的注入。这些属性如 contextAttribute、contextClass、nameSpace、contextConfigLocation 等,都可以在 web.xml 文件中以初始化参数的方式配置在 servlet 的声明中。DispatcherServlet 继承自 FrameworkServlet,FrameworkServlet 类上包含对应的同名属性,Spring 会保证这些参数被注入到对应的值中。属性注入主要包含以下几个步骤:

        1.封装及验证初始化参数

            ServletConfigPropertyValues 除了封装属性外还有对属性验证的功能。

HttpServletBean.java

public ServletConfigPropertyValues(ServletConfig config, Set<String> requiredProperties)
   throws ServletException {

   Set<String> missingProps = (requiredProperties != null && !requiredProperties.isEmpty()) ?
         new HashSet<String>(requiredProperties) : null;

   Enumeration<String> en = config.getInitParameterNames();
   while (en.hasMoreElements()) {
      String property = en.nextElement();
      Object value = config.getInitParameter(property);
      addPropertyValue(new PropertyValue(property, value));
      if (missingProps != null) {
         missingProps.remove(property);
      }
   }

   // Fail if we are still missing properties.
   if (missingProps != null && missingProps.size() > 0) {
      throw new ServletException(
         "Initialization from ServletConfig for servlet '" + config.getServletName() +
         "' failed; the following required properties were missing: " +
         StringUtils.collectionToDelimitedString(missingProps, ", "));
   }
}

        从代码中得知,封装属性主要是对初始化的参数进行封装,也就是 servlet 中配置的 <init-param> 中配置的封装。当然,用户可以通过对 requiredProperties 参数的初始化来强制验证某些属性的必然性,这样,在属性封装的过程中,一旦检测到 requiredProperties 中的属性没有指定初始值,就会抛出异常。

        2.将当前 servlet 实例转化成 BeanWrapper 实例

            PropertyAccessorFactory.forBeanPropertyAccess 是Spring 中提供的工具方法,主要用于将指定实例转化为 Spring 中可以处理的 BeanWrapper 类型的实例。

        3.注册相对于 Resource 的属性编辑器

            属性编辑器,我们在上文中已经介绍并且分析过其原理,这里使用属性编辑器的目的是在对当前实例(DispatcherServlet)属性注入过程中一旦遇到 Resource 类型的属性就会使用 ResourceEditor 去解析。

        4.属性注入

            BeanWrapper 为 Spring 中的方法,支持 Spring 的自动注入。其实我们最常用的属性注入无非是 contextAttribute、contextClass、nameSpace、contextConfigLocation 等属性。

        5.servletBean 的初始化

            在 ContextLoaderListener 加载的时候已经创建了 WebApplicationContext 实例,而在这个函数中最重要的就是对这个实例进行进一步的补充初始化。

            继续查看 initServletBean()。父类 FrameworkServlet 覆盖了 HttpServletBean 中的 initServletBean 函数,如下:

FrameworkServlet.java

@Override
protected final void initServletBean() throws ServletException {
   getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
   if (this.logger.isInfoEnabled()) {
      this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
   }
   long startTime = System.currentTimeMillis();

   try {
      this.webApplicationContext = initWebApplicationContext();
      // 设计为子类覆盖
      initFrameworkServlet();
   }
   catch (ServletException ex) {
      this.logger.error("Context initialization failed", ex);
      throw ex;
   }
   catch (RuntimeException ex) {
      this.logger.error("Context initialization failed", ex);
      throw ex;
   }

   if (this.logger.isInfoEnabled()) {
      long elapsedTime = System.currentTimeMillis() - startTime;
      this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +
            elapsedTime + " ms");
   }
}

        上面的函数设计了计时器来统计初始化的执行时间,而且提供了一个扩展方法 initFrameworkServlet() 用于子类的覆盖操作,而作为关键的初始化逻辑实现委托给了 initWebApplicationContext();


WebApplicationContext 的初始化

        initWebApplicationContext 函数

        initWebApplicationContext 函数的主要工作就是创建或刷新 WebApplicationContext 实例并对 servlet 功能所使用的组件进行初始化。

FrameworkServlet.java

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
      // context 实例在构造函数中被注入
      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
      // 根据 contextAttribute 属性加载 WebApplicationContext
      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.
      onRefresh(wac);
   }

   if (this.publishContext) {
      // Publish the context as a servlet context attribute.
      String attrName = getServletContextAttributeName();
      getServletContext().setAttribute(attrName, wac);
      if (this.logger.isDebugEnabled()) {
         this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
               "' as ServletContext attribute with name [" + attrName + "]");
      }
   }

   return wac;
}

        对于本函数中的初始化主要包含以下几个部分:

            1. 寻找或创建 WebApplicationContext 实例。

            2. WebApplicationContext 的配置。

            3. WebApplicationContext 的刷新。


        寻找或创建 WebApplicationContext 实例

        WebApplicationContext 的寻找及创建包括以下几个步骤。

        (1)通过构造函数的注入进行初始化。

        当进入 initWebApplicationContext 函数后通过判断 this.webApplicationContext != null 后,便可以确定 this.webApplicationContext 是否是通过构造函数来初始化的。可是有读者可能会有疑问,在 initServletBean 函数中明明是把创建好的实例记录在了 this.webApplicationContext 中:

this.webApplicationContext = initWebApplicationContext();

        何以判定这个参数是通过构造函数初始化,而不是通过上一次的函数返回值初始化呢?如果存在这个问题,那么就是读者忽略一个问题了:在 Web 中包含 SpringWeb 的核心逻辑的 DispatcherServlet 只可以被声明为一次,在 Spring 中已经存在验证,所以这就确保了如果 this.webApplicationContext != null,则可以直接判定 this.webApplicationContext 已经通过构造函数初始化。

        (2)通过 contextAttribute 进行初始化

        通过在 web.xml 文件中配置的 servlet 参数 contextAttribute 来查找 ServletContext 中对应的属性,默认为 WebApplicationContext.class.getName() + ".ROOT",也就是在 ContextLoaderListener 加载时会创建 WebApplicationContext 实例,并将实例以 WebApplicationContext.class.getName() + ".ROOT" 为 key 放入 ServletContext 中,当然读者可以重写初始化逻辑使用自己创建的 WebApplicationContext,并在 servlet 的配置中通过初始化参数 contextAttribute 指定 key。

FrameworkServlet.java

protected WebApplicationContext findWebApplicationContext() {
   String attrName = getContextAttribute();
   if (attrName == null) {
      return null;
   }
   WebApplicationContext wac =
         WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);
   if (wac == null) {
      throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");
   }
   return wac;
}

        (3)重新创建 WebApplicationContext 实例。

        如果通过以上两种方式并没有找到任何突破,那就没办法了,只能在这里重新创建新的实例了。

FrameworkServlet.java

protected WebApplicationContext createWebApplicationContext(WebApplicationContext parent) {
   return createWebApplicationContext((ApplicationContext) parent);
}

protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
   // 获取 servlet 的初始化参数 contextClass,如果没有配置默认为 XMLWebApplicationContext.Class
   Class<?> contextClass = getContextClass();
   if (this.logger.isDebugEnabled()) {
      this.logger.debug("Servlet with name '" + getServletName() +
            "' will try to create custom WebApplicationContext context of class '" +
            contextClass.getName() + "'" + ", using parent context [" + parent + "]");
   }
   if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
      throw new ApplicationContextException(
            "Fatal initialization error in servlet with name '" + getServletName() +
            "': custom WebApplicationContext class [" + contextClass.getName() +
            "] is not of type ConfigurableWebApplicationContext");
   }
   // 通过反射方式实例化 contextClass
   ConfigurableWebApplicationContext wac =
         (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

   // parent 为在 ContextLoaderListener 中创建的实例
   // 在 ContextLoaderListener 加载的时候初始化的 WebApplicationContext 类型实例
   wac.setEnvironment(getEnvironment());
   wac.setParent(parent);
   // 获取 contextConfigLocation 属性,配置在 servlet 初始化参数中
   wac.setConfigLocation(getContextConfigLocation());

   // 初始化 Spring 环境包括加载配置文件等
   configureAndRefreshWebApplicationContext(wac);

   return wac;
}


        WebApplicationContext 的配置

        无论是通过构造函数注入还是单独创建,都免不了会调用 configureAndRefreshWebApplicationContext 方法来对已经创建的 WebApplicationContext 实例进行配置及刷新,那么这个步骤又做哪些工作呢?

FrameworkServlet.java

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
   if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
      // The application context id is still set to its original default value
      // -> assign a more useful id based on available information
      if (this.contextId != null) {
         wac.setId(this.contextId);
      }
      else {
         // Generate default id...
         wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
               ObjectUtils.getDisplayString(getServletContext().getContextPath()) + "/" + getServletName());
      }
   }

   wac.setServletContext(getServletContext());
   wac.setServletConfig(getServletConfig());
   wac.setNamespace(getNamespace());
   wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

   // The wac environment's #initPropertySources will be called in any case when the context
   // is refreshed; do it eagerly here to ensure servlet property sources are in place for
   // use in any post-processing or initialization that occurs below prior to #refresh
   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
   }

   postProcessWebApplicationContext(wac);
   applyInitializers(wac);
   // 加载配置文件及整合 parent 到 wac
   wac.refresh();
}

        无论调用方式如何变化,只要是使用 AlicationContext 所提供的功能最后都免不了使用公共父类 AbstractApplicationContext 提供的 refresh() 进行配置文件加载。


        WebApplicationContext 的刷新

        onRefresh 是 FrameworkServlet 类中提供的模板方法,在其子类 DispatcherServlet 中进行了重写,主要用于刷新 Spring 在 Web 功能实现中所必须使用的组件。下面我们会介绍它们的初始化过程以及使用场景,而至于具体的使用细节会在稍后的章节中再做详细介绍。

DispatcherServlet.java

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

protected void initStrategies(ApplicationContext context) {
   // 1.初始化 MultipartResolver
   initMultipartResolver(context);
   // 2.初始化 LocaleResolver
   initLocaleResolver(context);
   // 3.初始化 ThemeResolver
   initThemeResolver(context);
   // 4.初始化 HandlerMappings
   initHandlerMappings(context);
   // 5.初始化 HandlerAdapters
   initHandlerAdapters(context);
   // 6.初始化 HandlerExceptionResolvers
   initHandlerExceptionResolvers(context);
   // 7.初始化 RequestToViewNameTranslator
   initRequestToViewNameTranslator(context);
   // 8.初始化 ViewResolvers
   initViewResolvers(context);
   // 9.初始化 FlashMapManager
   initFlashMapManager(context);
}

        initStrategies 的具体内容非常简单,就是初始化的 9 个组件。 


HandlerMapping 的初始化

        对于具体的初始化过程,根据上面的方法名称,很容易理解。以 HandlerMapping 为例来说明这个 initHandlerMappings() 过程。这里的 Mapping 关系的作用是,为 HTTP 请求找到相应的 Controller 控制器,从而利用这些控制器 Controller 去完成设计好的数据处理工作。HandlerMappings 完成对 MVC 中 Controller 的定义和配置,只不过在 Web 这个特定的应用环境中,这些控制器是与具体的 HTTP 请求相对应的。DispatcherServlet 中 HandlerMappings 初始化过程的具体实现。在 HandlerMapping 初始化的过程中,把在 Bean 配置文件中配置好的 handlerMapping 从 Ioc 容器中取得。

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

   // 这里导入所有的 HandlerMapping Bean,这些 Bean 可以在当前的 DispatcherServlet 的
   // Ioc 容器中,也可能在其双亲上下文中
   // 这个 detectAllHandlerMappings 的默认值设为 true,即默认地从所有的 Ioc 容器中取
   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<HandlerMapping>(matchingBeans.values());
         // We keep HandlerMappings in sorted order.
         AnnotationAwareOrderComparator.sort(this.handlerMappings);
      }
   }
   else {
      // 可以根据名称从当前的 Ioc 容器中通过 getBean 获取 handlerMapping
      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.
   // 如果没有找到 handerMappings,那么需要为 servlet 设定默认的 handlerMappings,这些默认
   // 值可以设置在 DispatcherServlet.properties 中
   if (this.handlerMappings == null) {
      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
      if (logger.isDebugEnabled()) {
         logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
      }
   }
}

        经过以上的读取过程,handlerMapping 变量就已经获取了在 BeanDefinition 中配置好的映射关系。其他的初始化过程和 handlerMapping 比较类似,都是自己从 Ioc 容器中读入配置,所以这里的 MVC 初始化过程是建立在 Ioc 容器已经初始化完成的基础上的。



——水门(2016年3月写于武汉)

展开阅读全文
4
6 收藏
分享
加载中
更多评论
打赏
0 评论
6 收藏
4
分享
返回顶部
顶部