Servlet项目启动执行顺序
由前面的回顾内容可知,Servlet项目启动执行顺序如下
- ServletContainerInitializer.onStartup(Set<Class<?>> c, ServletContext ctx)
- ServletContextListener.contextInitialized(ServletContextEvent sce)
- Filter-------init(FilterConfig filterConfig)
- HttpServlet-------------init()
- Filter-------doFilter 过滤前
- HttpServlet------------doget/dopost
- Filter-------doFilter 过滤后
SpringMVC的xml配置
web.xml
<web-app>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<servlet>
<servlet-name>app</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>app</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
">
<!-- 扫描基本包并开启spring注解 过滤controller层是因为Spring MVC管理Controller，Spring 管理Controller之外的Bean -->
<context:component-scan base-package="com.yoocar" >
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
</context:component-scan>
</beans>
springmvc.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.2.xsd"
>
<!-- 使用基于注解的控制器，spring会自动扫描base-package下的子包和类，如果扫描到会把这些类注册为bean-->
<context:component-scan base-package="com.yoocar.controller"/>
<!-- mvc 请求映射处理器与适配器 @RequestMapping -->
<mvc:annotation-driven />
<!--配置视图解析器 默认的视图解析器- -->
<bean id="defaultViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
<!--<property name="contentType" value="text/html" />-->
<property name="prefix" value="/WEB-INF/" />
<property name="suffix" value=".jsp" />
</bean>
<!-- json 支持 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping">
</bean>
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
<property name="messageConverters">
<list>
<bean class="org.springframework.http.converter.StringHttpMessageConverter"/>
<bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter" />
</list>
</property>
</bean>
<!-- 文件上传配置 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize">
<value>104857600</value>
</property>
<property name="maxInMemorySize">
<value>4096</value>
</property>
</bean>
<!-- 拦截器配置 -->
<mvc:interceptors>
<!-- 多个拦截器,顺序执行 -->
<mvc:interceptor>
<!-- 需要拦截的url -->
<mvc:mapping path="/*/*"/>
<!-- 不拦截该请求 -->
<mvc:exclude-mapping path="/user/login*"/>
<mvc:exclude-mapping path="/video/**"/>
<!-- 拦截器实现类 -->
<bean class="com.yoocar.config.VisitInterceptor"/>
</mvc:interceptor>
</mvc:interceptors>
</beans>
SpringServletContainerInitializer
SpringMVC实现了Servlet的spi机制.,如下
源码如下
@HandlesTypes(WebApplicationInitializer.class)
public class SpringServletContainerInitializer implements ServletContainerInitializer {
@Override
public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
throws ServletException {
List<WebApplicationInitializer> initializers = new LinkedList<>();
if (webAppInitializerClasses != null) {
//传入所有实现了WebApplicationInitializer的子类
for (Class<?> waiClass : webAppInitializerClasses) {
// Be defensive: Some servlet containers provide us with invalid classes,
// no matter what @HandlesTypes says...
//判断是否是接口或者抽象类,都不是,进如下逻辑
if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
try {
//利用反射,实例化实现了WebApplicationInitializer的子类,并加入到initializers中去
initializers.add((WebApplicationInitializer)
ReflectionUtils.accessibleConstructor(waiClass).newInstance());
}
catch (Throwable ex) {
throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
}
}
}
}
if (initializers.isEmpty()) {
servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
return;
}
servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
AnnotationAwareOrderComparator.sort(initializers);
for (WebApplicationInitializer initializer : initializers) {
//调用所有实现了WebApplicationInitializer的子类的onStartup方法
initializer.onStartup(servletContext);
}
}
}
-
调用onStartUp()前会先找到@HandlesTypes(WebApplicationInitializer.class) 所有实现了WebApplicationInitializer的类，
-
传入到OnStartup的webAppInitializerClasses参数中，并传入Servlet上下文对象。
-
找到所有WebApplicationInitializer的实现类后， 不是接口、不是抽象则通过反射进行实例化（所以，你会发现内部实现类都是抽象的，你想让其起作用我们必须添加一个自定义实现类，在下文提供我的自定义实现类）
-
调用所有上一步实例化后的对象的onStartup方法
注意,如果使用xml,且没有自定义配置,这里SpringServletContainerInitializer并没有特殊的处理,以下的知识点用于注解版补充,可以先略过
实现了了WebApplicationInitializer接口的类结构图
AbstractDispatcherServletInitializer.onStartup
public abstract class AbstractDispatcherServletInitializer extends AbstractContextLoaderInitializer {
/**
* The default servlet name. Can be customized by overriding {@link #getServletName}.
*/
public static final String DEFAULT_SERVLET_NAME = "dispatcher";
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
super.onStartup(servletContext);
//注册DispatcherServlet
registerDispatcherServlet(servletContext);
}
protected void registerDispatcherServlet(ServletContext servletContext) {
//获取DispatcherServlet的名字
String servletName = getServletName();
Assert.hasLength(servletName, "getServletName() must not return null or empty");
//创建WebApplicationContext对象,创建子容器
WebApplicationContext servletAppContext = createServletApplicationContext();
Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
//这里new了一个DispatcherServlet
FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());
//添加dispatcherServlet到servletContext
ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
if (registration == null) {
throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
"Check if there is another servlet registered under the same name.");
}
//设置启动时加载
registration.setLoadOnStartup(1);
//调用抽象方法设置映射路径：getServletMappings()（此抽象方法在我们自定义的子类中实现提供我们自定义的映射路径 ）
registration.addMapping(getServletMappings());
registration.setAsyncSupported(isAsyncSupported());
Filter[] filters = getServletFilters();
if (!ObjectUtils.isEmpty(filters)) {
for (Filter filter : filters) {
registerServletFilter(servletContext, filter);
}
}
customizeRegistration(registration);
}
protected String getServletName() {
return DEFAULT_SERVLET_NAME;
}
protected abstract WebApplicationContext createServletApplicationContext();
protected FrameworkServlet createDispatcherServlet(WebApplicationContext servletAppContext) {
return new DispatcherServlet(servletAppContext);
}
@Nullable
protected ApplicationContextInitializer<?>[] getServletApplicationContextInitializers() {
return null;
}
protected abstract String[] getServletMappings();
@Nullable
protected Filter[] getServletFilters() {
return null;
}
protected FilterRegistration.Dynamic registerServletFilter(ServletContext servletContext, Filter filter) {
String filterName = Conventions.getVariableName(filter);
Dynamic registration = servletContext.addFilter(filterName, filter);
if (registration == null) {
int counter = 0;
while (registration == null) {
if (counter == 100) {
throw new IllegalStateException("Failed to register filter with name '" + filterName + "'. " +
"Check if there is another filter registered under the same name.");
}
registration = servletContext.addFilter(filterName + "#" + counter, filter);
counter++;
}
}
registration.setAsyncSupported(isAsyncSupported());
registration.addMappingForServletNames(getDispatcherTypes(), false, getServletName());
return registration;
}
private EnumSet<DispatcherType> getDispatcherTypes() {
return (isAsyncSupported() ?
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.INCLUDE, DispatcherType.ASYNC) :
EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.INCLUDE));
}
protected boolean isAsyncSupported() {
return true;
}
protected void customizeRegistration(ServletRegistration.Dynamic registration) {
}
}
createServletApplicationContext
@Override
protected WebApplicationContext createServletApplicationContext() {
//创建子容器
AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
//获取子容器的配置类
Class<?>[] configClasses = getServletConfigClasses();
if (!ObjectUtils.isEmpty(configClasses)) {
//把配置类注册到子容器中
context.register(configClasses);
}
return context;
}
ContextLoaderListener
ContextLoaderListener通过实现ServletContextListener接口，将创建springIOC容器作为父容器融入web容器当中。
- 父容器:springIOC容器,扫描包的时候排除controller层
- 子容器:springweb,只扫描controller层
子容器可以使用父容器的bean
父容器不可以使用子容器的bean
ContextLoaderListener.contextInitialized
直接看ContextLoaderListener.contextInitialized源码
public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
public ContextLoaderListener() {
}
public ContextLoaderListener(WebApplicationContext context) {
super(context);
}
/**
* 初始化根容器,关键方法
* Initialize the root web application context.
*/
@Override
public void contextInitialized(ServletContextEvent event) {
initWebApplicationContext(event.getServletContext());
}
/**
* Close the root web application context.
*/
@Override
public void contextDestroyed(ServletContextEvent event) {
closeWebApplicationContext(event.getServletContext());
ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
}
ContextLoader.initWebApplicationContext
//创建和初始化spring主容器对应的WebApplicationContext对象实例
//并调用refresh方法完成从contextConfigLocation指定的配置中，加载BeanDefinitions和创建bean实例
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
//判断是否已经有Root WebApplicationContext，已经有则抛出异常
if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
throw new IllegalStateException(
"Cannot initialize context because there is already a root application context present - " +
"check whether you have multiple ContextLoader* definitions in your web.xml!");
}
servletContext.log("Initializing Spring root WebApplicationContext");
Log logger = LogFactory.getLog(ContextLoader.class);
if (logger.isInfoEnabled()) {
logger.info("Root WebApplicationContext: initialization started");
}
//记录当前时间
long startTime = System.currentTimeMillis();
try {
if (this.context == null) {
//创建上下文对象,即XmlWebApplicationContext(静态方法中从ContextLoader.properties文件中读取) 并赋值给全局变量context
this.context = createWebApplicationContext(servletContext);
}
//XmlWebApplicationContext是ConfigurableWebApplicationContext类型的
if (this.context instanceof ConfigurableWebApplicationContext) {
//这里的cwac就是XmlWebApplicationContext
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
// 设置父容器（如果有）,一般来说没有,可忽略
ApplicationContext parent = loadParentContext(servletContext);
cwac.setParent(parent);
}
//核心方法，完成配置加载，BeanDefinition定义和bean对象创建
configureAndRefreshWebApplicationContext(cwac, servletContext);
}
}
//ioc容器上下文设置到servlet上下文servletContext,将ROOT容器存入到Servlet域中供子容器使用
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
if (ccl == ContextLoader.class.getClassLoader()) {
currentContext = this.context;
}
else if (ccl != null) {
//将当前类加载器和上下文绑定
currentContextPerThread.put(ccl, this.context);
}
if (logger.isInfoEnabled()) {
long elapsedTime = System.currentTimeMillis() - startTime;
logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
}
return this.context;
}
catch (RuntimeException | Error ex) {
logger.error("Context initialization failed", ex);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
throw ex;
}
}
ContextLoader.createWebApplicationContext
这里就是实例化了一个root 容器,即spring ioc容器,知识实例化,还没有refresh
protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
//核心代码
Class<?> contextClass = determineContextClass(sc);
if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
}
//利用反射实例化contextClass
return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
}
ContextLoader.determineContextClass
获取ServletContextclass对象，如果没有指定,xml方式默认为XmlWebApplicationContext
protected Class<?> determineContextClass(ServletContext servletContext) {
//从配置文件中获取contextClass的值,一般不会手动配置
String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
if (contextClassName != null) {
try {
return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
}
catch (ClassNotFoundException ex) {
throw new ApplicationContextException(
"Failed to load custom context class [" + contextClassName + "]", ex);
}
}
else {
//如果没有指定,默认为XmlWebApplicationContext
contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
try {
return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
}
catch (ClassNotFoundException ex) {
throw new ApplicationContextException(
"Failed to load default context class [" + contextClassName + "]", ex);
}
}
}
defaultStrategies.getProperty
defaultStrategies的内容在static代码块中加载
private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
private static final Properties defaultStrategies;
static {
// Load default strategy implementations from properties file.
// This is currently strictly internal and not meant to be customized
// by application developers.
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
}
}
上面的DEFAULT_STRATEGIES_PATH如下
private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
ContextLoader.properties文件位于ContextLoader类的统计目录,我们看下ContextLoader.properties文件的内容
# Default WebApplicationContext implementation class for ContextLoader.
# Used as fallback when no explicit context implementation has been specified as context-param.
# Not meant to be customized by application developers.
org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
xml方式默认为XmlWebApplicationContext,类结构如下
instantiateClass
根据class对象利用反射实例化
public static <T> T instantiateClass(Class<T> clazz) throws BeanInstantiationException {
Assert.notNull(clazz, "Class must not be null");
if (clazz.isInterface()) {
throw new BeanInstantiationException(clazz, "Specified class is an interface");
}
try {
//根据class对象利用反射实例化
return instantiateClass(clazz.getDeclaredConstructor());
}
catch (NoSuchMethodException ex) {
Constructor<T> ctor = findPrimaryConstructor(clazz);
if (ctor != null) {
return instantiateClass(ctor);
}
throw new BeanInstantiationException(clazz, "No default constructor found", ex);
}
catch (LinkageError err) {
throw new BeanInstantiationException(clazz, "Unresolvable class definition", err);
}
}
instantiateClass
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
return KotlinDelegate.instantiateClass(ctor, args);
}
else {
Class<?>[] parameterTypes = ctor.getParameterTypes();
Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
Object[] argsWithDefaultValues = new Object[args.length];
for (int i = 0 ; i < args.length; i++) {
if (args[i] == null) {
Class<?> parameterType = parameterTypes[i];
argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
}
else {
argsWithDefaultValues[i] = args[i];
}
}
//利用反射实例化
return ctor.newInstance(argsWithDefaultValues);
}
}
catch (InstantiationException ex) {
throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
}
catch (IllegalAccessException ex) {
throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
}
catch (IllegalArgumentException ex) {
throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
}
catch (InvocationTargetException ex) {
throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
}
}
loadParentContext(servletContext);
@Nullable
protected ApplicationContext loadParentContext(ServletContext servletContext) {
return null;
}
默认为空,留着扩展
configureAndRefreshWebApplicationContext
这个方法就是根据root容器的配置文件去初始化spring ioc容器并实例化root容器的配置文件的bean
注意,这里springmvc容器的bean还没有实例化
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
//配置root容器的contextId
if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
if (idParam != null) {
wac.setId(idParam);
}
else {
wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
ObjectUtils.getDisplayString(sc.getContextPath()));
}
}
wac.setServletContext(sc);
//CONFIG_LOCATION_PARAM=contextConfigLocation
//获取web.xml中的contextConfigLocation配置,即springIOC配置文件的路径
String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
if (configLocationParam != null) {
wac.setConfigLocation(configLocationParam);
}
//获取Environment环境对象的信息,若没有,则创建Environment环境对象并返回
ConfigurableEnvironment env = wac.getEnvironment();
if (env instanceof ConfigurableWebEnvironment) {
((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
}
// 使用ApplicationContextInitializer对ApplicationContext进行初始化
customizeContext(sc, wac);
//spring的核心方法
wac.refresh();
}
getEnvironment
@Override
public ConfigurableEnvironment getEnvironment() {
if (this.environment == null) {
this.environment = createEnvironment();
}
return this.environment;
}
customizeContext(sc, wac);
这里initializerClasses默认size=0,可忽略
protected void customizeContext(ServletContext sc, ConfigurableWebApplicationContext wac) {
List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
determineContextInitializerClasses(sc);
for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
Class<?> initializerContextClass =
GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
if (initializerContextClass != null && !initializerContextClass.isInstance(wac)) {
throw new ApplicationContextException(String.format(
"Could not apply context initializer [%s] since its generic parameter [%s] " +
"is not assignable from the type of application context used by this " +
"context loader: [%s]", initializerClass.getName(), initializerContextClass.getName(),
wac.getClass().getName()));
}
this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass));
}
AnnotationAwareOrderComparator.sort(this.contextInitializers);
for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
initializer.initialize(wac);
}
}
servletContext.setAttribute
将实例化的root容器存到servletContext备用
String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
currentContextPerThread.put();
private static final Map<ClassLoader, WebApplicationContext> currentContextPerThread =
new ConcurrentHashMap<>(1);
currentContextPerThread.put(ccl, this.context);
总结
ContextLoaderListener监听器的作用就是启动Web容器时，自动装配root容器的的配置信息。
如果web.xml中加入了ContextLoaderListener则初始化SpringIOC容器，即root ApplicationContex.
ContextLoaderListener监听器实现了ServletContextListener这个接口，在web.xml配置了这个监听器时，启动容器时，就会执行它实现的contextInitialized()方法
该方法初始化了WebApplicationContext实例（XmlWebApplicationContext）,IOC容器的一系列流程,扫描包并实例化了除controller层之外的bean
并将该IOC容器放入到ServletContext中,以便后面使用。
DispachterServlet
springmvc最重要的类，DispachterServlet本质HttpServlet
类结构如下
web容器：web容器使用ServletContext来维护每一个web应用，ContextLoaderListener将spring容器，即WebApplicationContext，作为ServletContext的一个attribute，key为，保存在ServletContext中，从而web容器和spring项目可以通过ServletContext来交互。
从FrameworkServlet中获取WebApplicationContext，然后从WebApplicationContext中获取DispatcherServlet的相关功能子组件bean，然后在自身维护一个引用。实现doService方法并使用这些功能子组件来完成请求的处理和生成响应。
我们知道,一个HttpServlet会先调用init(),那么我们来看下DispatcherServlet的init()
DispatcherServlet本身没有实现init()方法,主要逻辑在其父类HttpServletBean中实现,因此我们先看HttpServletBean.init()方法
HttpServletBean.init()
@Override
public final void init() throws ServletException {
//读取springmvc配置文件的init-param标签,该标签配置了springmvc容器的配置文件路径
// Set bean properties from init parameters.
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
if (!pvs.isEmpty()) {
try {
//将DispatcherServlet包装成BeanWrapper对象,并将上面的springmvc容器的配置文件路径读取到DispatcherServlet里去
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
initBeanWrapper(bw);
//将上面的springmvc容器的配置文件路径读取到DispatcherServlet里去
bw.setPropertyValues(pvs, true);
}
catch (BeansException ex) {
if (logger.isErrorEnabled()) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
}
throw ex;
}
}
//关键方法
// Let subclasses do whatever initialization they like.
initServletBean();
}
FrameworkServlet.initServletBean
@Override
protected final void initServletBean() throws ServletException {
getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
if (logger.isInfoEnabled()) {
logger.info("Initializing Servlet '" + getServletName() + "'");
}
long startTime = System.currentTimeMillis();
try {
//关键方法,创建子容器并返回
this.webApplicationContext = initWebApplicationContext();
//空方法,扩展用
initFrameworkServlet();
}
catch (ServletException | RuntimeException ex) {
logger.error("Context initialization failed", ex);
throw ex;
}
if (logger.isDebugEnabled()) {
String value = this.enableLoggingRequestDetails ?
"shown which may lead to unsafe logging of potentially sensitive data" :
"masked to prevent unsafe logging of potentially sensitive data";
logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
"': request parameters and headers will be " + value);
}
if (logger.isInfoEnabled()) {
logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
}
}
FrameworkServlet.initWebApplicationContext
protected WebApplicationContext initWebApplicationContext() {
//从ServletContext中拿到springIOC父容器
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
//这里就是方法返回值,返回的是子容器
WebApplicationContext wac = null;
//这里的webApplicationContext就是子容器,第一次为空
if (this.webApplicationContext != null) {
// A context instance was injected at construction time -> use it
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
//判断是否激活
if (!cwac.isActive()) {
// The context has not yet been refreshed -> provide services such as
// setting the parent context, setting the application context id, etc
if (cwac.getParent() == null) {
// The context instance was injected without an explicit parent -> set
// the root application context (if any; may be null) as the parent
//设置父容器,就是IOC容器
cwac.setParent(rootContext);
}
//执行refresh方法
configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
// No context instance was injected at construction time -> see if one
// has been registered in the servlet context. If one exists, it is assumed
// that the parent context (if any) has already been set and that the
// user has performed any initialization such as setting the context id
//获取子容器,第一次获取不到
wac = findWebApplicationContext();
}
//如果子容器为空
if (wac == null) {
// No context instance is defined for this servlet -> create a local one
//使用父容器读取springmvc配置文件,并作为子容器返回
wac = createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
// Either the context is not a ConfigurableApplicationContext with refresh
// support or the context injected at construction time had already been
// refreshed -> trigger initial onRefresh manually here.
synchronized (this.onRefreshMonitor) {
//这里是由DispatcherServlet实现了
onRefresh(wac);
}
}
if (this.publishContext) {
// Publish the context as a servlet context attribute.
String attrName = getServletContextAttributeName();
//将子容器和org.springframework.web.servlet.FrameworkServlet.CONTEXT.dispatcher存到ServletContext备用
getServletContext().setAttribute(attrName, wac);
}
return wac;
}
findWebApplicationContext
@Nullable
protected WebApplicationContext findWebApplicationContext() {
//这里attrName返回null
String attrName = getContextAttribute();
if (attrName == null) {
return null;
}
//获取springIOC容器
WebApplicationContext wac =
WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);
if (wac == null) {
throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");
}
return wac;
}
createWebApplicationContext
在这里实例化并初始化springmvc容器作为web容器
protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
//获取父容器的Class对象
Class<?> contextClass = getContextClass();
if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
throw new ApplicationContextException(
"Fatal initialization error in servlet with name '" + getServletName() +
"': custom WebApplicationContext class [" + contextClass.getName() +
"] is not of type ConfigurableWebApplicationContext");
}
//根据root容器的Class对象实例化web容器,这里web容器只是实例化,还没有refresh
ConfigurableWebApplicationContext wac =
(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
wac.setEnvironment(getEnvironment());
//将root容器作为刚刚实例化的web容器的父容器
wac.setParent(parent);
//获取子容器的配置文件路径
String configLocation = getContextConfigLocation();
if (configLocation != null) {
//设置springmvc配置文件到父容器
wac.setConfigLocation(configLocation);
}
//关键代码,就是根据web容器的配置文件去初始化容器和bean
configureAndRefreshWebApplicationContext(wac);
return wac;
}
configureAndRefreshWebApplicationContext
和父容器的逻辑大体一致
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
// The application context id is still set to its original default value
// -> assign a more useful id based on available information
if (this.contextId != null) {
wac.setId(this.contextId);
}
else {
// Generate default id...
wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
}
}
wac.setServletContext(getServletContext());
wac.setServletConfig(getServletConfig());
wac.setNamespace(getNamespace());
wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
// The wac environment's #initPropertySources will be called in any case when the context
// is refreshed; do it eagerly here to ensure servlet property sources are in place for
// use in any post-processing or initialization that occurs below prior to #refresh
ConfigurableEnvironment env = wac.getEnvironment();
if (env instanceof ConfigurableWebEnvironment) {
((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
}
postProcessWebApplicationContext(wac);
applyInitializers(wac);
//执行refresh方法
wac.refresh();
}
到这里加载springmvc的配置文件的子容器已经产生,并返回了,然后执行子容器的.refresh(),实例化了子容器的bean
进入wac.refresh();其中有个finishRefresh()方法
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
// Publish the final event. 这里在web容器启动时会发布事件
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}
而DispatcherServlet的父类FrameworkServlet里有个ContextRefreshListener,会监听此事件
private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
FrameworkServlet.this.onApplicationEvent(event);
}
}
具体实现如下
public void onApplicationEvent(ContextRefreshedEvent event) {
this.refreshEventReceived = true;
synchronized (this.onRefreshMonitor) {
onRefresh(event.getApplicationContext());
}
}
而该onRefresh方法由DispatcherServlet实现,源码如下
DispatcherServlet.onRefresh
@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
//初始化九大核心组件
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);//初始化我们web上下文对象的 用于文件上传下载的解析器对象
initLocaleResolver(context);//初始化我们web上下文对象用于处理国际化资源的
initThemeResolver(context);//主题解析器对象初始化
initHandlerMappings(context);//url请求映射,初始化我们的HandlerMapping
initHandlerAdapters(context);//初始化真正调用controloler方法的类,实例化我们的HandlerAdapters
initHandlerExceptionResolvers(context);//异常解析,实例化我们处理器异常解析器对象
initRequestToViewNameTranslator(context);
initViewResolvers(context);//视图解析,给DispatcherSerlvet的ViewResolvers处理器
initFlashMapManager(context);
}
至此,springmvc的root容器和web容器都已启动完成
总结
1.Tomcat在启动时首先调用 实现了ServletContextListener接口的ContextLoaderListener
- 在调用ContextLoaderListener过程中会实例化父容器,并根据配置查找root容器的配置
- 将root容器以及root配置文件的bean初始化,最后将root容器设置到ServletContext,以备后续调用
2.Tomcat在启动时调用实现了HttpServlet接口的DispatcherServlet对象的init方法
- 在init方法的执行过程中会根据root容器的class对象利用反射实例化一个新的容器作为web容器
- 将root容器设置为web容器的父容器
- 根据配置查找web容器的配置
- 将web容器以及web配置文件的bean初始化
- 在初始化的过程中发布事件,在监听事件过程中调用DispatcherServlet的onRefresh方法初始化springmvc的九大组件
