文档章节

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

水门-kay
 水门-kay
发布于 2016/04/02 19:18
字数 2866
阅读 1412
收藏 6

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月写于武汉)

© 著作权归作者所有

水门-kay
粉丝 459
博文 19
码字总数 59660
作品 0
杭州
后端工程师
私信 提问
Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密...

小致Daddy
2018/08/03
16K
1
springmvc源码解析合集

更多精彩源码解析文章请关注”天河聊架构“微信公众号。 springmvc源码解析之组件介绍 springmvc源码解析之配置加载SpringServletContainerInitializer springmvc源码解析之配置加载Context...

天河2018
03/27
157
0
Spring 源码分析(四) ——MVC(四)核心逻辑

DispatcherServlet 的设计 Spring MVC 的本质其实就是一个 Servlet,而上一篇提到了 DispatcherServlet,我们知道 Spring MVC 真正的逻辑其实是在 DispatcherServlet 中进行的,而 Dispatch...

水门-kay
2016/03/28
1K
0
手把手教你搭建SpringMVC——最小化配置

为什么需要Spring MVC 最开始接触网页的时候,是纯的html/css页面,那个时候还是用Dreamweaver来绘制页面。 随着网站开发的深入,开始学习servlet开发,记得最痛苦的就是servlet返回网页的内...

青夜之衫
2017/12/05
0
0
spring源码-bean之初始化-1

  一、spring的IOC控制反转:控制反转——Spring通过一种称作控制反转(IOC)的技术促进了松耦合。当应用了IOC,一个对象依赖的其它对象会通过被动的方式传递进来,而不是这个对象自己创建...

小不点丶
2018/08/09
0
0

没有更多内容

加载失败,请刷新页面

加载更多

OSChina 周日乱弹 —— 我,小小编辑,食人族酋长

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @宇辰OSC :分享娃娃的单曲《飘洋过海来看你》: #今日歌曲推荐# 《飘洋过海来看你》- 娃娃 手机党少年们想听歌,请使劲儿戳(这里) @宇辰OSC...

小小编辑
今天
687
10
MongoDB系列-- SpringBoot 中对 MongoDB 的 基本操作

SpringBoot 中对 MongoDB 的 基本操作 Database 库的创建 首先 在MongoDB 操作客户端 Robo 3T 中 创建数据库: 增加用户User: 创建 Collections 集合(类似mysql 中的 表): 后面我们大部分都...

TcWong
今天
39
0
spring cloud

一、从面试题入手 1.1、什么事微服务 1.2、微服务之间如何独立通讯的 1.3、springCloud和Dubbo有哪些区别 1.通信机制:DUbbo基于RPC远程过程调用;微服务cloud基于http restFUL API 1.4、spr...

榴莲黑芝麻糊
今天
25
0
Executor线程池原理与源码解读

线程池为线程生命周期的开销和资源不足问题提供了解决方 案。通过对多个任务重用线程,线程创建的开销被分摊到了多个任务上。 线程实现方式 Thread、Runnable、Callable //实现Runnable接口的...

小强的进阶之路
昨天
74
0
maven 环境隔离

解决问题 即 在 resource 文件夹下面 ,新增对应的资源配置文件夹,对应 开发,测试,生产的不同的配置内容 <resources> <resource> <directory>src/main/resources.${deplo......

之渊
昨天
72
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部