Spring MVC启动原理详解(上)

ゝ一世哀愁。 2023-10-01 10:00 12阅读 0赞

在[《从Servlet到Spring MVC》][Servlet_Spring MVC]中，介绍了基于xml配置使用的方式，但我们我现在用的更多的基于注解零配置的方式，尤其是在使用SpringBoot的时候，只需要引入web的start包即可，这边文章前面会简单介绍一下Spring MVC零配置的的使用，然后详细分析Spring MVC启动的原理，可以更加深入理解为什么只需要简单的配置，就可以提供强大的功能

### 一、零配置Spring MVC实现 ###

在之前，先简单介绍一下Spring MVC是如何整合Spring的，在Spring MVC的官网，提供了一张父子容器的图：

![image-20211217145748662][]

从上面这张图可以清晰的看到，在Spring MVC整合Spring中，其实是由两个容器组成的，其中下面的根容器就是Spring自身的容器，而上面的容器，是Spring MVC特有的容器，那为什么要这么设计呢？只是用一个容器不行吗

其实这种设计方法最大的考量兼容第三方MVC框架，比如以前常用的Struts框架，MVC容器用于存放Controller、视图解析器、处理器映射器这样的Bean，而提供服务的Bean由下层的Spring容器来管理，实现了解耦。但在SpringBoot中就不再使用父子容器，SpringBoot作为一个集成的解决方法，就是使用SpringMVC来作为Web框架，不需要再兼容其他第三方框架，那么直接使用是一个容器就可以了。

既然由两个容器，那么两个容器再启动时，就会用到不同的配置来加载Bean，所有使用零配置实现SpringMVC时首先就要定义两个配置文件

#### 1.1 定义配置文件 ####

定义根容器的配置类，不扫描@Controller注解的类和子容器的配置类

@Configuration
    @ComponentScan(basePackages = "com.lizhi",excludeFilters = {
        
          @ComponentScan.Filter(type = FilterType.ANNOTATION,value={
        Controller.class}),
          @ComponentScan.Filter(type = ASSIGNABLE_TYPE,value =WebAppConfig.class ),
    })
    public class RootConfig {
        
    
    }

定义子容器的配置类，只扫描有@RestController和@Controller注解的类，同时需要添加@EnableWebMvc注解

子容器的配置类，可以实现WebMvcConfigurer接口，该接口中提供了添加拦截器、资源处理器、参数解析器等的扩展，下面我们只配置添加一个拦截器

@Configuration
    @ComponentScan(basePackages = {
        "com.lizhi"},includeFilters = {
        
        @ComponentScan.Filter(type = FilterType.ANNOTATION,value = {
        RestController.class, Controller.class})
    },useDefaultFilters =false)
    @EnableWebMvc 
    public class WebAppConfig implements WebMvcConfigurer{
        
    
        /**
        * 配置拦截器
        * @return
        */
        @Bean
        public LizhiInterceptor lizhiInterceptor() {
        
            return new LizhiInterceptor();
        }
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
        
            registry.addInterceptor(lizhiInterceptor()).addPathPatterns("/*");
        }
    }
    
    public class LizhiInterceptor implements HandlerInterceptor {
        
    
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        
            System.out.println("Interceptor....preHandle");
            return true;
        }
    }

#### 1.2 实现初始化器接口 ####

上面定义完了配置类，但是并没有配置这两个配置类该给哪个容器用，所以，接下来就是要去实现AbstractAnnotationConfigDispatcherServletInitializer抽象类，定义每个容器启动时加载的类

在创建容器时，可以通过下面的方法，来获取配置类进行解析

public class LizhiStarterInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
        
    
       // IOC 父容器的启动类
       @Override
       protected Class<?>[] getRootConfigClasses() {
        
          return new Class[]{
        RootConfig.class};
       }
    
       // IOC子容器配置 web容器配置
       @Override
       protected Class<?>[] getServletConfigClasses() {
        
          return new Class[]{
        WebAppConfig.class};
       }
    
       // 我们前端控制器DispatcherServlet的拦截路径
       @Override
       protected String[] getServletMappings() {
        
          return new String[]{
        "/"};
       }
    }

### 二、Spring MVC容器启动灵魂 —SPI ###

在使用Spring MVC整合Spring的时候，我们没有像执行main()方法一样去手动创建Spring的容器，那么Spring的容器又是在什么时候创建的，这就要说到Java强大的扩展机制 ——SPI(Service Provider Interface))，翻译过来就是服务提供商接口，那SPI是如何用的呢？

#### 2.1 Java扩展机制SPI ####

按照Java的SPI规范，我们只要在META-INF/services目录创建一个文件，文件名就是服务提供商提供的接口名，而文件内容就是实现这个接口的类的全限定名，然后Java在运行时候，可以通过ServiceLoader来加载这些类，这种方法提供了良好的扩展，下面代码示例SPI的使用：

定义一个接口：

public interface Search {
        
        public List<String> searchDoc(String keyword);   
    }

定义两个接口的实现类：

public class FileSearch implements Search{
        
        @Override
        public List<String> searchDoc(String keyword) {
        
            System.out.println("文件搜索 "+keyword);
            return null;
        }
    }

public class DatabaseSearch implements Search{
        
        @Override
        public List<String> searchDoc(String keyword) {
        
            System.out.println("数据搜索 "+keyword);
            return null;
        }
    }

然后在META-INF/services目录下创建一个接口权限名的文件：

![image-20211217154234161.png][]

文件内容如下：

com.lizhi.FileSearch
    com.lizhi.DatabaseSearch

测试方法：ServiceLoader的load()方法会拿到接口对应的文件里面的实现类，然后在iterator的next()方法中，会去实例化这些实现类，这就是Java SPI的使用

public class TestCase {
        
        public static void main(String[] args) {
        
            ServiceLoader<Search> s = ServiceLoader.load(Search.class);
            Iterator<Search> iterator = s.iterator();
            while (iterator.hasNext()) {
        
                Search search =  iterator.next();
                search.searchDoc("hello world");
            }
        }
    }

**注：数据库连接的依赖包中，比如mysql-connector-java-5.1.44.jar，也有利用这种SPI机制来加载驱动**

#### 2.2 Servlet规范中的SPI ####

在Servlet3.1的规范中，明确指出Web容器需要支持对javax.servlet.ServletContainerInitailizer接口的扩展，Web容器(Tomcat)在启动的的时候，会根据META-INF/services目录中的文件内容，去加载所有ServletContainerInitailizer的实现类，然后调用它们的onStartup()方法

public interface ServletContainerInitializer {
        
    
        public void onStartup(Set<Class<?>> c, ServletContext ctx)
            throws ServletException; 
    }

而Spring MVC中就定义了一个实现该接口的类SpringServletContainerInitializer

**该类上面的注解@HandlesTypes指定了，在调用onStartup()方法时，第一个参数需要传入什么类型的实现类**

SpringMVC指定了需要传入WebApplicationInitializer的实现类或接口

@HandlesTypes(WebApplicationInitializer.class)
    public class SpringServletContainerInitializer implements ServletContainerInitializer {
        
    
        public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
            throws ServletException {
        
    		……
        }
    }

SpringMVC在onStartup()方法的实现中，然后拿到了所有实现了WebApplicationInitializer接口的类和接口，但是，会把接口和抽象类过滤掉，SpringMVC自身提供了三个实现类，分别是：AbstractContextLoaderInitializer、AbstractDispatcherServletInitializer和AbstractAnnotationConfigDispatcherServletInitializer，不过这三个类都是抽象类，在启动的时候是没法使用的，这就是为什么我们在零配置使用SpringMVC的时候需要，需要添加一个类，来继承AbstractAnnotationConfigDispatcherServletInitializer抽象类

过滤完之后，就会去遍历所有过滤得到的WebApplicationInitializer类的是实现类，然后调用它们的onStartup()方法

List<WebApplicationInitializer> initializers = Collections.emptyList();
    
    if (webAppInitializerClasses != null) {
        
        initializers = new ArrayList<>(webAppInitializerClasses.size());
        for (Class<?> waiClass : webAppInitializerClasses) {
        
            // 接口和抽象类servlet容器也会给我们，但是我们不要
            // 排除接口和容器
            if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
                WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
        
                // 实例化，然后添加到集合中
                initializers.add((WebApplicationInitializer)
                                 ReflectionUtils.accessibleConstructor(waiClass).newInstance());
            }
        }
    }
    
    AnnotationAwareOrderComparator.sort(initializers);
    // 调用initializer.onStartup  进行扩展
    for (WebApplicationInitializer initializer : initializers) {
        
        initializer.onStartup(servletContext);
    }

### 三、创建父子容器 ###

#### 3.1 创建父容器 ####

在前面我们定义的AbstractAnnotationConfigDispatcherServletInitializer的实现类LizhiStarterInitializer中，并没有实现onStartup()方法，所以会去调用父类的onStartup()方法

AbstractAnnotationConfigDispatcherServletInitializer中onStartup()方法的定义如下：

因为其继承自AbstractContextLoaderInitializer抽象类，所以又会去调用父类的onStartup()方法

public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {
        
    
        @Override
        public void onStartup(ServletContext servletContext) throws ServletException {
        
            //registerContextLoaderListener  ok
            super.onStartup(servletContext);
            // registerDispatcherServlet
            registerDispatcherServlet(servletContext);
        }
        ……
    }

在AbstractContextLoaderInitializer类的onStartup()方法中，就会去创建Spring的父容器，然后再创建一个ContextLoaderListener类型的监听器，这个监听器实现了ServletContextListener接口，可以监听Servlet上下文信息，这个我们在使用xml开发时，是要固定配置的，后面会详细讲到这个监听器的用处

最后把这个监听器添加到Servlet容器中

public abstract class AbstractContextLoaderInitializer implements WebApplicationInitializer {
        
    
        @Override
        public void onStartup(ServletContext servletContext) throws ServletException {
        
            registerContextLoaderListener(servletContext);
        }
    
        protected void registerContextLoaderListener(ServletContext servletContext) {
        
            // 创建父容器 ，
            WebApplicationContext rootAppContext = createRootApplicationContext();
            if (rootAppContext != null) {
        
                ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
                // 设置初始化器
                listener.setContextInitializers(getRootApplicationContextInitializers());
                servletContext.addListener(listener);
            }
        }
        ……
    }

创建父容器的方法实现在AbstractAnnotationConfigDispatcherServletInitializer类中，看到这里就很熟悉了，根据getRootConfigClasses()方法来获取父容器的配置类，然后注册该配置类，到这里，Spring容器还并没有启动，只是创建完成了而已

protected WebApplicationContext createRootApplicationContext() {
        
        Class<?>[] configClasses = getRootConfigClasses();
        if (!ObjectUtils.isEmpty(configClasses)) {
        
            AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
            context.register(configClasses);
            return context;
        }
        else {
        
            return null;
        }
    }

#### 3.2 创建子容器 ####

在AbstractDispatcherServletInitializer中，调用父类的onStartup()创建完父容器之后，接着就会去调用registerDispatcherServlet()方法来创建子容器，以及创建DispatcherServlet实例

public void onStartup(ServletContext servletContext) throws ServletException {
        
       //registerContextLoaderListener  ok
       super.onStartup(servletContext);
       // registerDispatcherServlet
       registerDispatcherServlet(servletContext);
    }

registerDispatcherServlet()方法中，会调用createServletApplicationContext()方法创建子容器，逻辑与创建父容器一样

然后调用createDispatcherServlet()方法来创建DispatcherServlet，会把子容器设置到DispatcherServlet实例中，这个需要注意，在DispatcherServlet初始化的时候，会使用到子容器的

然后就是把DispatcherServlet添加到Servlet上下文中，返回一个ServletRegistration.Dynamic的对象，然后设置一些DispatcherServlet的基础信息，这些信息都是在使用xml时需要手动配置的

protected void registerDispatcherServlet(ServletContext servletContext) {
        
        String servletName = getServletName();
        Assert.hasLength(servletName, "getServletName() must not return null or empty");
        // 创建子容器
        WebApplicationContext servletAppContext = createServletApplicationContext();
        Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
        // 创建DispatcherServlet
        FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
    
        ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
        
        // 启动时加载
        registration.setLoadOnStartup(1);
        // 映射
        registration.addMapping(getServletMappings());
        // 是否异步支持
        registration.setAsyncSupported(isAsyncSupported());
        // 设置DispatcherServlet的过滤器
        Filter[] filters = getServletFilters();
        if (!ObjectUtils.isEmpty(filters)) {
        
            for (Filter filter : filters) {
        
                registerServletFilter(servletContext, filter);
            }
        }
    }

[Servlet_Spring MVC]: https://blog.csdn.net/sermonlizhi/article/details/121976310
[image-20211217145748662]: https://raw.githubusercontent.com/sermonlizhi/picture/main/image-20211217145748662.png
[image-20211217154234161.png]: https://raw.githubusercontent.com/sermonlizhi/picture/main/image-20211217154234161.png