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了。
思考方式：
- tomcat启动的时候是怎么初始化的spring环境？
- tomcat初始化web环境的时候有哪些比较重要的配置？
- 为什么实现了WebApplicationInitializer之后，里面的onStartUp方法就能别调用到？
