spring mvc的零xml配置原理

在tomcat启动的时候，会调用到一个类，叫StandardContext，这里会读取我们配置的web.xml文件，所以可以简单的理解为“tomcat启动的时候默认会调用web.xml”。

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

在web.xml中，最开始我们在配置mvc的时候都会配置这两个东西。ContextLoaderListener（spring中的类）实现了ServletContextListener（servlet中的类），ServletContextListener能够监听到servlet的生命周期，而一个web应用启动的时候就只有1个servlet，因此相当于监听了整个web应用。web启动后，会触发ServletContextEvent事件，此时就会调用ContextLoaderListener中的contextInitialized方法，这个方法会调用initWebApplicationContext，返回一个WebApplicationContext，在这个方法中，会加载在web.xml中配置的classpath。因此在web.xml中配置的这段实际上的作用是“tomcat来初始化一个spring环境”。

public void contextInitialized(ServletContextEvent event) {
    this.initWebApplicationContext(event.getServletContext());
}
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    ...
    String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);//"contextConfigLocation"(设置配置文件的路径名)
}

那么如果我们想不用xml配置，需要我们自己来初始化spring环境，在一个spring项目中，我们初始化spring的方式是。

@ComponentScan("com.bafan.spring.dependencies")
public class AppConfig {
}

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(AppConfig.class);

所以思路就是需要我们自己new一个ApplicationContext，然后需要tomcat在启动的时候能调用到它。

web.xml中另一个很重要的需要配置的点就是拦截器，在使用web.xml的时候，配置姿势如下面所示。

<servlet>
    <servlet-name>SpringMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
    <async-supported>true</async-supported>
</servlet>
<servlet-mapping>
    <servlet-name>SpringMVC</servlet-name>
    <!-- 此处可以可以配置成*.do，对应struts的后缀习惯 -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

如果不通过web.xml的方式能够让上面的代码别调用，mvc官方文档中写，可以实现WebApplicationInitializer，然后重写onStartup方法。

/**
 * mvc如何实现0xml配置
 * onStartup方法，tomcat是如何能调用到的
 */
public class BafanWebApplication implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        System.out.println("tomcat------init---------");
        //spring环境初始化
        AnnotationConfigWebApplicationContext applicationContext = new AnnotationConfigWebApplicationContext();
        applicationContext.register(AppConfig.class);
        applicationContext.setServletContext(servletContext);
        applicationContext.refresh();

        //web环境初始化(servlet的配置)
        DispatcherServlet servlet = new DispatcherServlet(applicationContext);
        ServletRegistration.Dynamic registration = servletContext.addServlet("app", servlet);
        registration.addMapping("*.do");
        registration.setLoadOnStartup(1);
    }
}

在tomcat启动的时候，会调用到我们重写的onStartup方法，在这个方法中，我们初始化了spring的环境，因此就不用xml的方式初始spring的环境了，同时也初始化了web的环境。写了这几行代码就可以不用配置web.xml了。

为什么我们实现了WebApplicationInitializer tomcat就可以调用到我们重写的方法了呢？

WebApplicationInitializer是在org.springframework.web这个包下面的，也就是说这个接口是spring写的，点到这个jar包下。
它的根目录中的/META-INF/services有一个文件，文件名是javax.servlet.ServletContainerInitializer，文件里面写着org.springframework.web.SpringServletContainerInitializer。根据servlet的规范，tomcat和spring都遵守这个规范，tomcat启动的时候会调用这个方法（servlet的规定）。
这个方法的上面，加了一个@HandlesTypes(WebApplicationInitializer.class)的注解，@Nullable Set<Class<?>> webAppInitializerClasses的入参中，如果我们自己实现了WebApplicationInitializer这个接口的话，这个入参中会拿到我们所有实现了这个接口类，然后循环调用里面的onStartup方法。

for (WebApplicationInitializer initializer : initializers) {
    initializer.onStartup(servletContext);
}

我们可以自己模拟一下这个过程

1. 在根目录下创建一个/META-INF/services/javax.servlet.ServletContainerInitializer这个文件，里面写com.bafan.spring.web.test.BafanServletContainerInitializer
2. 
@HandlesTypes(A.class)
public class BafanServletContainerInitializer implements ServletContainerInitializer {

    @Override
    public void onStartup(Set<Class<?>> set, ServletContext servletContext) throws ServletException {
        System.out.println("执行了");
    }

}
3. 启动tomcat，这时候set会传进来B和C（都实现了A这个接口）。

PS：

在代码中引入
<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>8.5.43</version>
</dependency>
<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
    <version>8.5.45</version>
</dependency>

/**
 * 如何使用一个jar包的方式用main方法来启动tomcat
 */
public class TomcatServer {

    public static void main(String[] args) {
        Tomcat tomcat = new Tomcat();
        tomcat.setPort(8080);
        tomcat.addWebapp("/", "/Users/maxiaojun/bafan/tomcat");
        try {
            tomcat.start();
            tomcat.getServer().await();
        } catch (LifecycleException e) {
            e.printStackTrace();
        }
    }

}
这样就可以在代码中使用一个方法来启动tomcat，感觉很高大尚。

一个mvc项目，如果什么都不配置的话

@RequestMapping("/query.do")
@ResponseBody
public Map<String, String> query() {
    System.out.println("query controller");
    Map<String, String> map = new HashMap<String, String>();
    map.put("xxx", "xxxx");
    return map;
}
这行代码会报500的错误，因为mvc默认不知道咋对Map（对象也一样）进行解析，所以需要我们配置一下，告诉mvc要用fastjson来解析
@Configuration
@ComponentScan("com.bafan.spring.web")
@EnableWebMvc
public class AppConfig implements WebMvcConfigurer {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new FastJsonHttpMessageConverter());
    }

}
实现WebMvcConfigurer，重写configureMessageConverters方法，然后加一下fastjson解析器就ok了。

思考方式：