一、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>
    <display-name>Archetype Created Web Application</display-name>
    <!--listener作用：在web应用启动的时候能够加载Spring 环境-->
   <listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <<param-value>spring.xml</param-value>
    </context-param>
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>spring-mvc.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>*.do</url-pattern>
    </servlet-mapping>
</web-app>

三、基于Servlet3.0自定义spring及SpringMVC的整合

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

image.png image.png

2.创建javax.servlet.ServletContainerInitializer的实现类

package com.mjw.service;
import javax.servlet.ServletContainerInitializer;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.HandlesTypes;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
@HandlesTypes(WebInit.class)
public class MjwServletContainerInitializer 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);
        }
    }
}

3.定义Webinit接口并创建实现类

package com.mjw.service;
import javax.servlet.ServletContext;
public interface WebInit {
    void start(ServletContext context);
}

package com.mjw.service;
import com.mjw.config.AppConfig;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import javax.servlet.ServletContext;
import javax.servlet.ServletRegistration;

/**
 * 在这个类的start方法中实现spring容器环境的加载及初始化
 * 配置SpringMvc的DispatcherServlet
 */
public class MyWebInit implements WebInit {
    @Override
    public void start(ServletContext context) {
        //创建spring环境
        AnnotationConfigWebApplicationContext ac = new AnnotationConfigWebApplicationContext();
        ac.register(AppConfig.class);
        //创建servlet
        DispatcherServlet servlet = new DispatcherServlet(ac);
        //讲servlet注册到web容器中
        ServletRegistration.Dynamic spmvc = context.addServlet("spmvc", servlet);
        //配置web容器初始化完成后调用该servlet的初始化方法
        spmvc.setLoadOnStartup(1);
        //请求路径映射
        spmvc.addMapping("*.do");
    }
}

4.定义启动类并启动tomcat

package com.mjw;
import org.apache.catalina.Context;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.startup.Tomcat;
public class App {
    public static void main(String[] args) throws Exception {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        Context context = tomcat.addContext("/", System.getProperty("java.io.tmpdir"));
        context.addLifecycleListener((LifecycleListener) Class.forName(tomcat.getHost().getConfigClass()).newInstance());
        tomcat.start();
        tomcat.getServer().await();
    }
}

四、spring整合SpringMvc的真实代码

image.png

//
// 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);
            }
        }
    }
}

image.png

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容器配置类

五、springMVC请求处理流程介绍

1.初始化过程

Web容器启动后进行初始化，根据Web.xml配置的监听器进行spring环境创建，如果是servlet3.0java配置方式，
会根据调用实现ServletContianerIniliazer接口的类的onStartUp方法创建spring环境。之后会进行调用
DispatchServlet初始化方法进行初始化：
初始化做了什么？
1.  实例化视图解析器、消息转换器、参数解析器、handlerMappings映射器、拦截器
2.  从spring容器中获取带有@Controller和@RequestMapping注解的对象，解析里面
带有@RequestMapping注解的方法，解析成一个一个的handler对象，并根据请求路径做映射放入到一个map中。

2.springMVC请求过程

1.  请求进来之后会进入到doDispatch()方法中。
2.  根据request从handlermappings循环获取handler，并构建成一个调用链对象
       HandlerExecutionChain,调用链中包含handler对象以及拦截器。
      注意：springMVC中生命一个controller有三种方式:@Controller注解\实现
      Controller接口\实现HttpRequestHandler接口分别对应三种映射器来获取
      handler对象。这三种方式@Contoller是把对象中的方法解析成一个个handler；
      其余两种其实就是从Spring容器中获取真实的对象。
3.  根据request从匹配出适合的适配器，适配器也有三种分别对应不同的Controller类型,
4.  Chain.applyPreHandle()按顺序调用拦截器
5.  Ha.hand(hand) –通过适配器调用handle对应的方法。其中@Controller类型是通过反射调用，
   期间会通过策略模式，根据不同类型的参数调用不同的参数解析器从request中解析参 
   数值，然后通过反射调用controller的方法;根据方法的返回值以及方法上有没有加@ResponseBody注解，
   来判断是走视图解析器还是走消息转换器。
6.  Chain.applyPostHandle()调用拦截器
7.  调用视图解析器渲染参数以及页面跳转。