spring mvc的零xml配置原理

spring mvc的零xml配置原理

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

    org.springframework.web.context.ContextLoaderListener


    contextConfigLocation
    classpath:applicationContext.xml
 

在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的时候，配置姿势如下面所示。

    SpringMVC
    org.springframework.web.servlet.DispatcherServlet
    1
    true


    SpringMVC
    
    /

如果不通过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就可以调用到我们重写的方法了呢？

1. WebApplicationInitializer是在org.springframework.web这个包下面的，也就是说这个接口是spring写的，点到这个jar包下。
2. 它的根目录中的/META-INF/services有一个文件，文件名是javax.servlet.ServletContainerInitializer，文件里面写着org.springframework.web.SpringServletContainerInitializer。根据servlet的规范，tomcat和spring都遵守这个规范，tomcat启动的时候会调用这个方法（servlet的规定）。
3. 这个方法的上面，加了一个@HandlesTypes(WebApplicationInitializer.class)的注解，@Nullable Set> 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> set, ServletContext servletContext) throws ServletException {
        System.out.println("执行了");
    }

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

PS：

在代码中引入

    org.apache.tomcat
    tomcat-catalina
    8.5.43


    org.apache.tomcat.embed
    tomcat-embed-jasper
    8.5.45


/**
 * 如何使用一个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 query() {
    System.out.println("query controller");
    Map map = new HashMap();
    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> converters) {
        converters.add(new FastJsonHttpMessageConverter());
    }

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

思考方式：

1. tomcat启动的时候是怎么初始化的spring环境？
2. tomcat初始化web环境的时候有哪些比较重要的配置？
3. 为什么实现了WebApplicationInitializer之后，里面的onStartUp方法就能别调用到？