SpringMVC源码(二):MVC容器启动

  SpringMVC是一个基于Java实现了MVC设计模式的请求驱动类型的轻量级Web框架,SpringMVC是在Spring框架的基础上做的拓展。

一、分析思路

  在使用配置文件的方式设置SpringMVC的时候,都会配置web.xml,下面我们看看web.xml内容:

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
   <!--Spring配置文件-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-config.xml</param-value>
    </context-param>

    <servlet>
        <servlet-name>mvc-test</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--SpringMVC配置文件-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
        <async-supported>true</async-supported>
    </servlet>

    <servlet-mapping>
        <servlet-name>mvc-test</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
</web-app>

web.xml文件的内容包括:

  1、Spring的相关bean配置文件;

  2、SpringMVC的相关bean配置文件;

  3、Servlet配置;

  4、监听器配置。

1.1、两个IOC容器

  在SpringMVC中包含两个容器,Spring容器和SpringMVC的容器,Spring作为父容器,SpringMVC作为子容器。为什么要单独为SpringMVC创建一个容器呢?为SpringMVC创建一个容器是为了与Spring的容器做隔离,SpringMVC容器有其特定的功能,并且可以继承Spring父容器,用父容器相关的bean。

1.2、容器启动入口

1.2.1、Spring父容器启动入口

  在Tomcat启动后,通过配置的容器加载监听器ContextLoaderListener#contextInitialized会优先加载Spring的配置,创建好Spring父容器,ContextLoaderListener#contextInitialized为Spring父容器启动入口,ContextLoaderListener#contextInitialized是在Tomcat源码中调用的,在Tomcat源码中再做详细分析。

1.2.2、SpringMVC容器启动入口

  在创建SpringMVC容器时,需优先加载SpringMVC的配置文件,在web.xml文件中,SpringMVC配置文件设置在Servlet标签下,因此需要先创建好对应的Servlet对象,加载到SpringMVC的配置文件后,创建MVC容器。

  MVC容器启动与Servlet相关,Servlet的生命周期中有三个重要的方法: init() -> service() -> destory()。MVC容器启动是否在init() - Servlet的初始化中的呢?

  在web.xml中servlet标签配置的DispatcherServlet及相关父类中是否有init()方法,在DispatcherServlet父类HttpServletBean中,可以找到init()初始化方法。在初始化方法中,通过调用FrameworkServlet#initServletBean()创建MVC容器。

二、SpringMVC容器启动流程图

2.1、Spring父容器启动流程

  ContextLoaderListener#contextInitialized方法作为切入点分析:
 
   

2.2、SpringMVC容器启动流程

  Spring父容器的启动,通过监听器可以完成,那么SpringMVC容器的启动,又是在哪里切入的呢?首先在配置文件web.xml中,分析出SpringMVC本质上是一个Servlet,那么必然要遵守Sevlet的生命周期,在Servlet生命周期中最重要的三个方法init()、doService()、destory()。

 
  

  对于SpringMVC的分析配置文件中的DispatcherServlet中做进一步的分析,DispatcherServlet类图结构如下:

 

  依照类图,按从子类到父类的顺序,找到init()方法,可在HttpServletBean中找到init()方法,执行流程如下

    

三、SpringMVC容器启动核心源码

3.1、Spring容器启动

  容器加载监听器中,容器初始化完成操作,ContextLoaderListener#contextInitialized 核心伪代码:

1 // 初始化web应用父容器
2 @Override
3 public void contextInitialized(ServletContextEvent event) {
4    // 初始化web应用父容器
5    initWebApplicationContext(event.getServletContext());
6 }

  初始化Web应用上下文环境,Spring父容器的处理, ContextLoaderListener#initWebApplicationContext核心伪代码:

// 容器属性
@Nullable
private WebApplicationContext context;

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
   // 初始化Spring容器日志打印
   servletContext.log("Initializing Spring root WebApplicationContext");
   // 记录Spring父容器启动开始时间
   long startTime = System.currentTimeMillis();

   // 初始化context,首次执行获取到一个root webApplicationcontext
   if (this.context == null) {
     this.context = createWebApplicationContext(servletContext);
   }
   // 若当前容器是ConfigurableWebApplicationContext类型
   if (this.context instanceof ConfigurableWebApplicationContext) {
     ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
     // 若容器未被激活
     if (!cwac.isActive()) {
        // 当前容器父容器为空,判断是否为当前容器设置了父容器
        if (cwac.getParent() == null) {
           // 获取当前容器的父容器,并设置父子依赖
           ApplicationContext parent = loadParentContext(servletContext);
           cwac.setParent(parent);
        }
        // 创建容器并刷新
        configureAndRefreshWebApplicationContext(cwac, servletContext);
     }
   }
   // 将创建的context对象记录在servletContext中,创建并且准备好了spring容器
   servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
   
   // 返回创建好的context
   return this.context;
}

  创建web应用上下文对象,通过反射实现,ContextLoader#createWebApplicationContext 核心伪代码:

1 //  创建Spring父容器对象
2 protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
3    // 获取contextClass的Class对象
4    Class<?> contextClass = determineContextClass(sc);
5    
6    // 实例化容器对象
7    return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
8 }

  加载Spring配置文件,并刷新父容器,ContextLoader#configureAndRefreshWebApplicationContext 核心伪代码:

 1 // 刷新容器
 2 protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
 3    // 为Spring容器设置Servlet上下文
 4    wac.setServletContext(sc);
 5    // 获取Spring父容器的配置,用于刷新Spring容器
 6    String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
 7    if (configLocationParam != null) {
 8       wac.setConfigLocation(configLocationParam);
 9    }
10    
11    // 刷新Spring父容器
12    wac.refresh();
13 }

  加载Spring的配置文件,用于Spring父容器的刷新操作。

  wac.refresh();步骤会进入到SpringIOC启动流程中,AbstractApplicationContext#refresh(),可查看Spring源码分析系列,此处不再赘述。

3.2、SpringMVC容器启动

  MVC容器刷新入口遵循Servlet的生命周期,HttpServletBean#init() 核心伪代码:
 1 public final void init() throws ServletException {
 2 
 3    // 将servlet中配置的init-param参数封装到pvs变量中,获取SpringMVC的配置文件
 4    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
 5    if (!pvs.isEmpty()) {
 6        // 将当前的servlet对象转化成BeanWrapper对象,从而能够以spring的方法来将pvs注入到该beanWrapper中
 7        BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
 8        ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
 9        // 注册自定义属性编辑器,一旦有Resource类型的属性,将会使用ResourceEditor进行解析
10        bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
11        // 模板方法,可以在子类调用,做一些初始化工作,bw代表的是DispatcherServlet
12        initBeanWrapper(bw);
13        // 以spring的方式来将pvs注入到该beanWrapper对象中,将配置的初始化值(contextConfigLocation)设置到DispatcherServlet
14        bw.setPropertyValues(pvs, true);
15    }
16    // 模板方法,子类初始化的入口方法,查看FrameworkServlet#initServletBean方法
17    initServletBean();
18 }

1、SpringMVC容器配置文件获取

  获取SpringMVC的配置文件,用于刷新MVC容器做的准备工作。

 

2、servlet对象的封装

  将当前的servlet对象转化成BeanWrapper对象,从而能够以spring的方法来将pvs注入到该beanWrapper中

3、注册定义属性编辑器

  注册自定义属性编辑器,一旦有Resource类型的属性,将会使用ResourceEditor进行解析

4、加载初始化配置

  以spring的方式来将pvs注入到该beanWrapper对象中,将配置的初始化值(contextConfigLocation)设置到DispatcherServlet

5、SpringMVC容器启动

  初始化Servlet相关bean,FrameworkServlet#initServletBean 核心伪代码

 1 // 初始化Servlet相关的bean
 2 protected final void initServletBean() throws ServletException {
 3    // 记录开启时间
 4    long startTime = System.currentTimeMillis();
 5       
 6    // 创建或刷新WebApplicationContext实例并对servlet功能所使用的变量进行初始化
 7    this.webApplicationContext = initWebApplicationContext();
 8    
 9    // 模板方法,空实现,留给子类扩展
10    initFrameworkServlet();
11 }

5.1、初始化SpringMVC容器

  创建并刷新SpringMVC容器,FrameworkServlet#initWebApplicationContext 核心伪代码

 1 protected WebApplicationContext initWebApplicationContext() {
 2    // 获得根webApplicationContext对象,Spring父容器
 3    WebApplicationContext rootContext =
 4          WebApplicationContextUtils.getWebApplicationContext(getServletContext());
 5    // 声明webApplicationContext wac对象,用于SpringMVC子容器
 6    WebApplicationContext wac = null;
 7 
 8    // 当前面两种方式都无效的情况下会创建一个webApplicationContext对象,一般情况下都是使用这样的方式
 9    if (wac == null) {
10       // 创建并刷新SpringMVC容器
11       wac = createWebApplicationContext(rootContext);
12    }
13    
14    // 将applicationContext设置到servletContext中
15    if (this.publishContext) {
16       String attrName = getServletContextAttributeName();
17       getServletContext().setAttribute(attrName, wac);
18    }
19 
20    return wac;
21 }
1、获取Spring父容器
2、创建并刷新SpringMVC容器

  FrameworkServlet#createWebApplicationContext 核心伪代码

 1 protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
 2     
 3    // 获取servlet的初始化参数contextClass,如果没有配置默认为XmlWebApplicationContext.class
 4    Class<?> contextClass = getContextClass();
 5    
 6    // 通过反射方式实例化contextClass
 7    ConfigurableWebApplicationContext wac =
 8          (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
 9 
10    // parent为在ContextLoaderListener中创建的实例,在ContextLoaderListener加载的时候初始化的WebApplicationContext类型实例
11    wac.setParent(parent);
12    
13    // 获取contextConfigLocation属性,配置在servlet初始化参数中
14    String configLocation = getContextConfigLocation();
15    if (configLocation != null) {
16       // 将设置的contextConfigLocation参数传给wac,默认传入WEB-INFO/servletName-servlet.xml
17       wac.setConfigLocation(configLocation);
18    }
19    // 配置和初始化wac
20    configureAndRefreshWebApplicationContext(wac);
21 
22    return wac;
23 }
1、获取MVC容器的Class对象,并通过反射实例化MVC容器对象;
2、为MVC容器设置Spring父容器;
       0
3、获取SpringMVC配置文件,为MVC容器刷新做准备
     0
4、配置并刷新MVC容器

  FrameworkServlet#configureAndRefreshWebApplicationContext 核心伪代码

 1 // 配置并刷新MVC容器
 2 protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
 3     
 4    // 添加监听器sourceFilteringListener到wac中,实际监听的是ContextRefreshListener所监听的事件,监听ContextRefreshedEvent事件,
 5    // 当接收到消息之后会调用onApplicationEvent方法,调用onRefresh方法,并将refreshEventReceived标志设置为true,表示已经refresh过
 6    wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
 7 
 8    // 获取环境对象并且添加相关的属性
 9    ConfigurableEnvironment env = wac.getEnvironment();
10    if (env instanceof ConfigurableWebEnvironment) {
11       ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
12    }
13    
14    // 刷新wac,从而初始化wac
15    wac.refresh();
16 }

  MVC容器刷新流程与Spring容器舒新流程相同,都是执行AbstractApplicationContext#refresh()方法。

3、MVC容器内置九大组件

  之前在分析Spring的源码中,创建剩余单例对象的方法是 finishBeanFactoryInitialization(beanFactory);,在MVC执行完此方法后,MVC容器内置的九大组件,并未被创建。

由此大胆猜测下,MVC的九大组件是在完成MVC容器刷新后,创建出来的,也就是在容器刷新的最后一个方法finishRefresh()中,到底是不是呢?我们接着往下分析。

MVC容器刷新时的处理,AbstractApplicationContext#finishRefresh()核心伪代码:

1 // 完成容器刷新时的处理
2 protected void finishRefresh() {
3    // ...
4    // 新建ContextRefreshedEvent事件对象,将其发布到所有监听器。
5    publishEvent(new ContextRefreshedEvent(this));
6    //...
7 }

  AbstractApplicationContext#publishEvent()发布事件核心伪代码:

 1 // 将给定事件发布到所有监听器
 2 protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
 3  
 4    // 装饰事件作为一个应用事件,如果有必要
 5    ApplicationEvent applicationEvent;
 6    // 如果event是ApplicationEvent的实例
 7    if (event instanceof ApplicationEvent) {
 8       // 将event强转为ApplicationEvent对象
 9       applicationEvent = (ApplicationEvent) event;
10    }
11   
12    // 多播applicationEvent到适当的监听器
13    getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
14    
15     // ...
16 }

1、事件强转为applicationEvent类型;

2、通过多播器广播事件

  SimpleApplicationEventMulticaster#multicastEvent 核心伪代码

 1 public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
 2     
 3    // 如果事件类型eventType不为null就引用eventType;否则将event转换为ResolvableType对象再引用
 4    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
 5    // 获取此多播器的当前任务线程池
 6    Executor executor = getTaskExecutor();
 7    // getApplicationListeners方法是返回与给定事件类型匹配的应用监听器集合
 8    // 遍历获取所有支持event的监听器
 9    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
10       //回调listener的onApplicationEvent方法,传入event
11       invokeListener(listener, event);
12    }
13 }
 

3、调用事件处理监听器,处理MVC容器刷新完成发布的事件

  SimpleApplicationEventMulticaster#doInvokeListener 核心伪代码

1 / /回调listener的onApplicationEvent方法
2 // 传入event:contextrefreshListener:onapplicaitonEvent:FrameworkServlet.this.onApplicationEvent()
3 private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
4     // 处理事件        
5     listener.onApplicationEvent(event);
6 }

 

3.1、通过多播器广播事件

  FrameworkServlet#onApplicationEvent 核心伪代码

1 public void onApplicationEvent(ContextRefreshedEvent event) {
2    // 标记 refreshEventReceived 为true
3    this.refreshEventReceived = true;
4    synchronized (this.onRefreshMonitor) {
5       // 处理事件中的 ApplicationContext 对象,空实现,子类DispatcherServlet会实现
6       onRefresh(event.getApplicationContext());
7    }
8 }

 

3.2、初始化九大组件

  MVC容器刷新完成初始化完成,初始化策略,DispatcherServlet#onRefresh 核心伪代码

 
1 protected void onRefresh(ApplicationContext context) {
2    // ...
3    initStrategies(context);
4 }

  初始化MVC容器九大组件,DispatcherServlet#initStrategies 核心伪代码

 1 // 初始化MVC组件
 2 protected void initStrategies(ApplicationContext context) {
 3    // 初始化 MultipartResolver:主要用来处理文件上传.如果定义过当前类型的bean对象,那么直接获取,如果没有的话,可以为null
 4    initMultipartResolver(context);
 5    // 初始化 LocaleResolver:主要用来处理国际化配置,基于URL参数的配置(AcceptHeaderLocaleResolver),
 6    // 基于session的配置(SessionLocaleResolver),基于cookie的配置(CookieLocaleResolver)
 7    initLocaleResolver(context);
 8    // 初始化 ThemeResolver:主要用来设置主题Theme
 9    initThemeResolver(context);
10    // 初始化 HandlerMapping:映射器,用来将对应的request跟controller进行对应
11    initHandlerMappings(context);
12    // 初始化 HandlerAdapter:处理适配器,主要包含Http请求处理器适配器,简单控制器处理器适配器,注解方法处理器适配器
13    initHandlerAdapters(context);
14    // 初始化 HandlerExceptionResolver:基于HandlerExceptionResolver接口的异常处理
15    initHandlerExceptionResolvers(context);
16    // 初始化 RequestToViewNameTranslator:当controller处理器方法没有返回一个View对象或逻辑视图名称,
17    // 并且在该方法中没有直接往response的输出流里面写数据的时候,spring将会采用约定好的方式提供一个逻辑视图名称
18    initRequestToViewNameTranslator(context);
19    // 初始化 ViewResolver: 将ModelAndView选择合适的视图进行渲染的处理器
20    initViewResolvers(context);
21    // 初始化 FlashMapManager: 提供请求存储属性,可供其他请求使用
22    initFlashMapManager(context);
23 }

  MVC的web应用上下文刷新成功后,Spring父容器、MVC容器就已经完成了启动。

 
posted @ 2023-02-10 20:23  无虑的小猪  阅读(452)  评论(0编辑  收藏  举报