一、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.在项目目录下添加接口配置文件
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的真实代码
//
// 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);
}
}
}
}
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. 调用视图解析器渲染参数以及页面跳转。