JZTXT

Spring基于AbstractAnnotationConfigDispatcherServletInitializer的启动流程分析

发布时间 2023-11-19 20:08:50作者: 残城碎梦

Servlet3.0提供的SPI规范

从servlet3.0开始，web容器启动时为提供给第三方组件机会做一些初始化的工作，例如注册servlet或者filtes等，servlet规范中通过ServletContainerInitializer实现此功能。每个框架要使用ServletContainerInitializer就必须在对应的jar包的META-INF/services目录创建一个名为javax.servlet.ServletContainerInitializer的文件，文件内容指定具体的ServletContainerInitializer实现类，那么，当web容器启动时就会运行这个初始化器做一些
组件内的初始化工作。一般伴随着ServletContainerInitializer一起使用的还有HandlesTypes注解，通过HandlesTypes可以将感兴趣的一些类注入到ServletContainerInitializerde的onStartup方法作为参数传入。

tomcat7之后的版本都实现了servlet3.0的SPI规范。

servlet3.0之前开发一个web应用必须要配置web.xml作为web应用的入口，定义一个servlet也必须在web.xml中定义才能够被加载；servlet3.0之后，web容器（tomcat）在进行初始化时，根据SPI规范会调用实现了javax.servlet.ServletContainerInitializer接口的类的onStartup方法，servlet可以在onStartup方法中定义，这就可以省略web.xml。springboot也是基于这个原理，所以在springboot中已经看不到web.xml的踪影。

传统springMVC项目web.xml的配置方式

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
    <!--Spring 配置-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:applicationContext.xml</param-value>
    </context-param>
    
    <!--listener作用：在web应用启动的时候能够加载Spring 环境-->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!--Spring MVC 配置-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath*:springMVC.xml</param-value>
        </init-param>
        <!--web容器启动时加载这个servlet(实例化并调用init()方法)-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>*.action</url-pattern>
    </servlet-mapping>
</web-app>

基于Servlet3.0自定义Spring及SpringMVC的整合

在项目目录下添加接口配置文件

META-INF/services目录创建一个名为javax.servlet.ServletContainerInitializer的文件，文件内容指定具体的ServletContainerInitializer实现类

创建javax.servlet.ServletContainerInitializer的实现类

@HandlesTypes({WebInit.class})
public class MyServletContainerInitializer implements ServletContainerInitializer {
    /**
     * 在web容器启动时会调用onStartup方法,
     * 在调用onStartup方法之前把实现了@HandlesTypes注解中WebInit.class接口的Class对象封装成参数
     * 作为onStartup方法的参数传进来
     *
     * @param set
     * @param servletContext
     * @throws ServletException
     */
    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        System.out.println(".........start...............");
        List<WebInit> list = new ArrayList<>();
        for (Class<?> aClass : set) {
            try {
                list.add((WebInit) aClass.newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        for (WebInit webInit : list) {
            webInit.start(servletContext);
        }
    }
}

定义Webinit接口并创建实现类

public interface WebInit {
    void start(ServletContext context);
}
/**
 * 在这个类的start方法中实现spring容器环境的加载及初始化
 * 配置SpringMvc的DispatcherServlet
 */
public class MyWebInit implements WebInit {

    @Override
    public void start(ServletContext context) {
        //创建spring环境
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext();
        //ac.register(AppConfig.class);
        ac.scan("com.harvey");
        //创建servlet
        DispatcherServlet servlet = new DispatcherServlet(ac);
        //讲servlet注册到web容器中
        ServletRegistration.Dynamic springMVC = context.addServlet("springMVC", servlet);
        //配置web容器初始化完成后调用该servlet的初始化方法
        springMVC.setLoadOnStartup(1);
        //请求路径映射
        springMVC.addMapping("*.do");
    }
}

部署到tomcat后启动即可。

Spring整合Spring MVC的真实代码

 

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web;

import java.lang.reflect.Modifier;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import javax.servlet.ServletContainerInitializer;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.HandlesTypes;
import org.springframework.core.annotation.AnnotationAwareOrderComparator;
import org.springframework.lang.Nullable;
import org.springframework.util.ReflectionUtils;

@HandlesTypes({WebApplicationInitializer.class})
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    public SpringServletContainerInitializer() {
    }

    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
        List<WebApplicationInitializer> initializers = new LinkedList();
        Iterator var4;
        if (webAppInitializerClasses != null) {
            var4 = webAppInitializerClasses.iterator();

            while(var4.hasNext()) {
                Class<?> waiClass = (Class)var4.next();
                if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) && WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
                    try {
                        initializers.add((WebApplicationInitializer)ReflectionUtils.accessibleConstructor(waiClass, new Class[0]).newInstance());
                    } catch (Throwable var7) {
                        throw new ServletException("Failed to instantiate WebApplicationInitializer class", var7);
                    }
                }
            }
        }
        if (initializers.isEmpty()) {
            servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
        } else {
            servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
            AnnotationAwareOrderComparator.sort(initializers);
            var4 = initializers.iterator();
            while(var4.hasNext()) {
                WebApplicationInitializer initializer = (WebApplicationInitializer)var4.next();
                //关键代码
                initializer.onStartup(servletContext);
            }
        }
    }
}

其中WebApplicationInitializer的实现类有：

1）AbstractContextLoaderInitializer：创建根容器，createRootApplicationContext()是一个抽象方法，供子类实现

2）AbstractDispatcherServletInitializer：

① 创建一个web的ioc容器：createServletApplicationContext()，抽象方法，供子类实现

② 创建DispatcherServlet：createDispatcherServlet()

③ 将创建的DispatcherServlet添加到ServletContext中

④ getServletMappings();

3）AbstractAnnotationConfigDispatcherServletInitializer：

  • 子类通过实现其抽象方法返回注解方式的根容器和Servlet子容器，从而实现注解方式配置DispatcherServlet初始化器(SpringMVC的容器)和根容器(Spring的IOC容器)
  • 创建根容器：createRootApplicationContext()，子实现类通过实现getRootConfigClasses();方法返回一个配置类
  • 创建web的IOC容器： createServletApplicationContext();子实现类通过实现
  • getServletConfigClasses();返回一个web的IOC容器配置类

AbstractAnnotationConfigDispatcherServletInitializer应用

Servlet3.0中，容器会自动查找实现了javax.servlet.ServletContainerInitialize接口的类，如果可以发现的话，就用它来配置Servlet容器。Spring提供了实现，名为SpringServletContainerInitializer，这个类会查找实现了WebApionInitializer的类，并将配置任务交给它来完成。Spring提供了便利的WebApionInitializer实现，名为AbstractAnnotationConfigDispatcherServletInitializer。所以只要继承这个便利类，Spring会用它配置Servlet上下文。

public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return new Class<?>[] { RootConfig.class };
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        // 将DispatcherServlet映射到"/"
        return new String[] { "/" };
    }

}