SpringMVC源码解析
xml配置文件版
0. 准备阶段
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<!-- spring主配置文件位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-config/spring-*.xml</param-value>
</context-param>
<!-- 配置监听器 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 配置中央调度器 -->
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-config/springmvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<!-- 配置字符集过滤器 -->
<filter>
<filter-name>characterEncodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>characterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
springmvc-config.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">
<!-- 静态资源处理器 -->
<mvc:default-servlet-handler/>
<!-- 配置注解驱动 -->
<mvc:annotation-driven/>
<!-- controller扫描器 -->
<context:component-scan base-package="com.tca.springmvc.learning.controller"/>
</beans>
controller
/**
* @author zhouan
* @Date 2021/6/7
*/
@Controller
@RequestMapping("/hello")
public class HelloController {
@GetMapping("/test")
@ResponseBody
public String test() {
return String.valueOf(System.currentTimeMillis());
}
@RequestMapping("/message")
@ResponseBody
public String message(@RequestBody JSONObject request) {
System.out.println("收到消息: " + request.toJSONString());
return "ok";
}
}
1.java web基础
1.1 启动原理
1.web容器(如tomcat)启动时, 会根据tomcat的配置文件读取项目的web.xml配置文件, web.xml配置文件中主要涉及的标签有:
<context-param>、<listener>、<fileter>、<servlet>
加载的顺序是: <context-param>、<listener>、<fileter>、<servlet>
2.web容器启动时(如tomcat), 首先加载依赖的jar, 然后读取web.xml文件, 创建ServletContext, 容器会将context-param的配置以key-value键值对形式传给servletContext, 并且实例化<listener>标签中配置的类, 然后初始化Filter和Servlet
3.我们在springmvc工程中配置的<listener>为org.springframework.web.context.ContextLoaderListener, 它实现了ServletContextListener接口, 这个接口用于监听web容器的开启和关闭, 并有对应方法进行回调
1.2 ServletContextListener
public interface ServletContextListener extends EventListener {
/**
** Notification that the web application initialization
** process is starting.
** All ServletContextListeners are notified of context
** initialization before any filter or servlet in the web
** application is initialized.
*/
public void contextInitialized ( ServletContextEvent sce );
/**
** Notification that the servlet context is about to be shut down.
** All servlets and filters have been destroy()ed before any
** ServletContextListeners are notified of context
** destruction.
*/
public void contextDestroyed ( ServletContextEvent sce );
}
这个接口提供了两个方法，分别用来监听web容器启动和关闭进行回调，可以看到：contextInitialized的执行顺序优先于filter和servlet的初始化！
2.ContextLoaderListener
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());
}
}
2.1ContextLoaderListener#contextInitialized(ServletContextEvent event)
@Override
public void contextInitialized(ServletContextEvent event) {
initWebApplicationContext(event.getServletContext());
}
2.2 ContextLoader#initWebApplicationContext(ServletContext servletContext)
/**
* Initialize Spring's web application context for the given servlet context,
* using the application context provided at construction time, or creating a new one
* according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
* "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
* @param servletContext current servlet context
* @return the new WebApplicationContext
* @see #ContextLoader(WebApplicationContext)
* @see #CONTEXT_CLASS_PARAM
* @see #CONFIG_LOCATION_PARAM
*/
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
// 1.判断servletContext中是否已有ROOT
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!");
}
Log logger = LogFactory.getLog(ContextLoader.class);
servletContext.log("Initializing Spring root WebApplicationContext");
if (logger.isInfoEnabled()) {
logger.info("Root WebApplicationContext: initialization started");
}
long startTime = System.currentTimeMillis();
try {
// Store context in local instance variable, to guarantee that
// it is available on ServletContext shutdown.
// 2.判断是否有WebApplicationContext实例, 如果没有需要创建
if (this.context == null) {
// 3.创建WebApplicationContext, 这里是 XmlWebApplicationContext, 这里仅仅是创建父容器, 并没有进行配置和启动
this.context = createWebApplicationContext(servletContext);
}
if (this.context instanceof ConfigurableWebApplicationContext) {
// 4.进入
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
// 5.容器如果没有启动
if (!cwac.isActive()) {
// The context has not yet been refreshed -> provide services such as
// setting the parent context, setting the application context id, etc
// 6.父容器为null
if (cwac.getParent() == null) {
// The context instance was injected without an explicit parent ->
// determine parent for root web application context, if any.
// 7.设置父容器为null
ApplicationContext parent = loadParentContext(servletContext);
cwac.setParent(parent);
}
// 8.封装容器XmlWebApplicationContext, 并启动容器refresh()方法
// 这个方法会对父容器 XmlWebApplicationContext 进行配置并启动, 配置中包括读取ServletContext的初始化参数:contextConfigLocation, 这个参数对应的value, 在web.xml文件中的开头就进行了配置: <context-param>, value为: classpath:spring-config/spring-*.xml, 即为父容器的主配置文件！！！
configureAndRefreshWebApplicationContext(cwac, servletContext);
}
}
// 9.将spring容器设为servletContext的ROOT属性
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
// 10.这里的ClassLoader是 WebAppClassLoader
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
if (ccl == ContextLoader.class.getClassLoader()) {
currentContext = this.context;
}
else if (ccl != null) {
currentContextPerThread.put(ccl, this.context);
}
if (logger.isDebugEnabled()) {
logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
}
if (logger.isInfoEnabled()) {
long elapsedTime = System.currentTimeMillis() - startTime;
logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
}
// 11.返回当前容器
return this.context;
}
catch (RuntimeException ex) {
logger.error("Context initialization failed", ex);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
throw ex;
}
catch (Error err) {
logger.error("Context initialization failed", err);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
throw err;
}
}
总结
1.web容器(如tomcat)启动时, 创建ServletContext对象, 作为web容器Servlet上下文, 同时去加载web.xml文件
2.web.xml文件中配置了<listener>监听器, 其实现类为ContextLoaderListener, 用于监听web容器的开启和关闭, 因此web容器启动时会回调ContextLoaderListener#initWebApplicationContext(ServletContext servletContext)方法, 该方法用于创建一个XmlWebApplicationContext的spring-web容器, 并将其作为ServletContext的一个属性, 属性为ROOT
问题
1.父容器的作用是什么? 为什么需要设置父子容器?
3.FrameworkServlet
想要了解另一个核心类DispatcherServlet，需要先熟悉其父类FrameworkServlet
3.1 结构图
可以看到，其继承了HttpServletBean，同时实现了ApplicationContextAware接口
3.2 初始化
3.2.1 流程
step1：web容器在实例化servlet时会调用Servlet的init(ServletConfig)方法，由Servlet子类GenericServlet实现了该方法，因而最终会调用GenericServlet.init(ServletConfig)方法。
GenericServlet#init(ServletConfig)
public void init(ServletConfig config) throws ServletException {
this.config = config;
this.init();
}
step2：调用init()方法，init()方法由GenericServlet的子类HttpServletBean实现，实际上是执行了HttpServletBean.init()方法
HttpServletBean#init()
@Override
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
}
// Set bean properties from init parameters.
try {
// 1.获取web.xml中 DispatcherServlet的<init-param>参数配置, contextConfigLocation -- classpath:spring-config/springmvc-config.xml
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
initBeanWrapper(bw);
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.
// 2.调用子类方法
initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
}
}
step3 上述中调用了HttpServletBean.init()方法，这个方法中调用了initServletBean()方法，这个方法由子类FrameworkServlet实现
FrameworkServlet#initServletBean()
@Override
protected final void initServletBean() throws ServletException {
getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
if (this.logger.isInfoEnabled()) {
this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
}
long startTime = System.currentTimeMillis();
try {
// 1.创建并初始化子容器
this.webApplicationContext = initWebApplicationContext();
// 2.空实现
initFrameworkServlet();
}
catch (ServletException ex) {
this.logger.error("Context initialization failed", ex);
throw ex;
}
catch (RuntimeException ex) {
this.logger.error("Context initialization failed", ex);
throw ex;
}
if (this.logger.isInfoEnabled()) {
long elapsedTime = System.currentTimeMillis() - startTime;
this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +
elapsedTime + " ms");
}
}
FrameworkServlet#initWebApplicationContext()
protected WebApplicationContext initWebApplicationContext() {
// 1.获取Root的 XmlWebApplicationContext, 这里是从servletContext中获取ContextLoaderListener中创建的 webApplicationContext
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
WebApplicationContext wac = null;
// 2.为空, 跳过
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
cwac.setParent(rootContext);
}
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
// 3.wac == null, 子容器没有创建
wac = findWebApplicationContext();
}
if (wac == null) {
// No context instance is defined for this servlet -> create a local one
// 4.创建子容器, 并启动
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.
onRefresh(wac);
}
// 5.进入
if (this.publishContext) {
// Publish the context as a servlet context attribute.
// 6.创建完子容器后, 将子容器也存储到servletContext的属性中
// (org.springframework.web.servlet.FrameworkServlet.CONTEXT.springMVC --> 子容器)
// ("org.springframework.web.context.WebApplicationContext.ROOT" -> 父容器)
String attrName = getServletContextAttributeName();
getServletContext().setAttribute(attrName, wac);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
"' as ServletContext attribute with name [" + attrName + "]");
}
}
return wac;
}
FrameworkServlet#createWebApplicationContext(ApplicationContext parent)
/**
* Instantiate the WebApplicationContext for this servlet, either a default
* {@link org.springframework.web.context.support.XmlWebApplicationContext}
* or a {@link #setContextClass custom context class}, if set.
* <p>This implementation expects custom contexts to implement the
* {@link org.springframework.web.context.ConfigurableWebApplicationContext}
* interface. Can be overridden in subclasses.
* <p>Do not forget to register this servlet instance as application listener on the
* created context (for triggering its {@link #onRefresh callback}, and to call
* {@link org.springframework.context.ConfigurableApplicationContext#refresh()}
* before returning the context instance.
* @param parent the parent ApplicationContext to use, or {@code null} if none
* @return the WebApplicationContext for this servlet
* @see org.springframework.web.context.support.XmlWebApplicationContext
* 创建子容器 webApplicationContext, 跟当前FrameworkServlet(DispatcherServlet)绑定
* 父容器 --> servletContext中存储
* 子容器 --> FrameworkServlet(DispatcherServlet)中存储 servletContext中存储
*/
protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
// 1.contextClass == org.springframework.web.context.support.XmlWebApplicationContext
Class<?> contextClass = getContextClass();
if (this.logger.isDebugEnabled()) {
this.logger.debug("Servlet with name '" + getServletName() +
"' will try to create custom WebApplicationContext context of class '" +
contextClass.getName() + "'" + ", using parent context [" + parent + "]");
}
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");
}
// 2.实例化 XmlWebApplicationContext
ConfigurableWebApplicationContext wac =
(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
wac.setEnvironment(getEnvironment());
// 3.设置当前 XmlWebApplicationContext的父容器为 ROOT(ContextLoaderListener创建的容器, 并存储到servletContext中的)
wac.setParent(parent);
// 4.设置配置文件路径, 这里的路径是web.xml文件中DispatcherServlet中, init-param中配置的变量 -- contextConfigLocation, 这里是: classpath:spring-config/springmvc-config.xml
wac.setConfigLocation(getContextConfigLocation());
// 5.配置并启动子容器
configureAndRefreshWebApplicationContext(wac);
return wac;
}
FrameworkServlet#configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac)
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 {
// 1.生成容器id: org.springframework.web.context.WebApplicationContext:/springMVC
wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
}
}
// 2.设置servletContext
wac.setServletContext(getServletContext());
// 3.设置servletConfig
wac.setServletConfig(getServletConfig());
// 4.设置namespace
wac.setNamespace(getNamespace());
// 5.添加容器监听器, 这个监听器很重要, 容器启动完成后会发布refresh事件, 会被ContextRefreshListener监听
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);
// 6.启动容器
wac.refresh();
}
3.2.2 回调
上述，创建完子容器之后，添加了监听器new SourceFilteringListener(wac, new ContextRefreshListener())监听容器refresh，容器启动时会回调ContextRefreshListener的onApplicationEvent(ContextRefreshedEvent event)方法
/**
* ApplicationListener endpoint that receives events from this servlet's WebApplicationContext
* only, delegating to {@code onApplicationEvent} on the FrameworkServlet instance.
*/
private class ContextRefreshListener implements ApplicationListener<ContextRefreshedEvent> {
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
// 调用FrameworkServlet#onApplicationEvent(event)
FrameworkServlet.this.onApplicationEvent(event);
}
}
FrameworkServlet#onApplicationEvent(ContextRefreshedEvent event)
public void onApplicationEvent(ContextRefreshedEvent event) {
this.refreshEventReceived = true;
// 这里 onRefresh(ApplicationContext context) 被子类DispatcherServlet重写, 调用的是子类DispatcherServlet的onRefresh(ApplicationContext context)方法
onRefresh(event.getApplicationContext());
}
总结
web容器启动时, 会加载并初始化web.xml文件中配置的<servlet>, 这里只有核心类DispatcherServlet, 继承了FrameworkServlet, 初始化FrameworkServlet时会创建子spring web容器XmlWebApplicationContext, 创建时会添加监听器ContextRefreshListener, 所以创建完成时回调其onApplicationEvent(ContextRefreshedEvent event)方法, 该方法用于初始化DispatcherServlet相关组件！
4.DispatcherServlet
4.1 初始化
综上，子容器XmlWebApplicationContext启动时，发布ContextRefreshedEvent事件，被已经添加的ContextRefreshListener监听，回调其onApplicationEvent(ContextRefreshedEvent event)方法，这个方法中调用了DispatcherServlet的onRefresh(ApplicationContext context)方法
DispatcherServlet#onRefresh(ApplicationContext context)
@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
DispatcherServlet#initStrategies(ApplicationContext context)
/**
* Initialize the strategy objects that this servlet uses.
* <p>May be overridden in subclasses in order to initialize further strategy objects.
*/
// 入参的ApplicationContext是子容器
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
initMultipartResolver(ApplicationContext context)
/**
* Initialize the MultipartResolver used by this class.
* <p>If no bean is defined with the given name in the BeanFactory for this namespace,
* no multipart handling is provided.
*/
private void initMultipartResolver(ApplicationContext context) {
try {
this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// Default is no multipart resolver.
this.multipartResolver = null;
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
"': no multipart request handling provided");
}
}
}
初始化MultipartResolver, 用于处理文件上传, 这个是可配置的, 如果未配置, 为空
initLocaleResolver(ApplicationContext context)
/**
* Initialize the LocaleResolver used by this class.
* <p>If no bean is defined with the given name in the BeanFactory for this namespace,
* we default to AcceptHeaderLocaleResolver.
*/
private void initLocaleResolver(ApplicationContext context) {
try {
this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Using LocaleResolver [" + this.localeResolver + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// We need to use the default.
// 使用默认的LocaleResolver
this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate LocaleResolver with name '" + LOCALE_RESOLVER_BEAN_NAME +
"': using default [" + this.localeResolver + "]");
}
}
}
初始化LocaleResolver，如果没有配置，使用默认的
initThemeResolver(ApplicationContext context)
/**
* Initialize the ThemeResolver used by this class.
* <p>If no bean is defined with the given name in the BeanFactory for this namespace,
* we default to a FixedThemeResolver.
*/
private void initThemeResolver(ApplicationContext context) {
try {
this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Using ThemeResolver [" + this.themeResolver + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// We need to use the default.
// 使用默认的ThemeResolver
this.themeResolver = getDefaultStrategy(context, ThemeResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate ThemeResolver with name '" + THEME_RESOLVER_BEAN_NAME +
"': using default [" + this.themeResolver + "]");
}
}
}
初始化ThemeResolver，如果没有配置，使用默认的
initHandlerMappings(ApplicationContext context)
/**
* Initialize the HandlerMappings used by this class.
* <p>If no HandlerMapping beans are defined in the BeanFactory for this namespace,
* we default to BeanNameUrlHandlerMapping.
*/
private void initHandlerMappings(ApplicationContext context) {
this.handlerMappings = null;
if (this.detectAllHandlerMappings) {
// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
// 1.从子容器中获取所有的HandlerMapping, 这里有3个
// org.springframework.web.servlet.handler.SimpleUrlHandlerMapping
// org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
// org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
Map<String, HandlerMapping> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
// We keep HandlerMappings in sorted order.
// 2.排序handlerMapping
// RequestMappingHandlerMapping、BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping
AnnotationAwareOrderComparator.sort(this.handlerMappings);
}
}
else {
try {
HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
this.handlerMappings = Collections.singletonList(hm);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerMapping later.
}
}
// Ensure we have at least one HandlerMapping, by registering
// a default HandlerMapping if no other mappings are found.
if (this.handlerMappings == null) {
this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
if (logger.isDebugEnabled()) {
logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
}
}
}
从容器中获取所有HandlerMapping处理器，并排序，目前有三个，顺序为：RequestMappingHandlerMapping、BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping
initHandlerAdapters(ApplicationContext context)
/**
* Initialize the HandlerAdapters used by this class.
* <p>If no HandlerAdapter beans are defined in the BeanFactory for this namespace,
* we default to SimpleControllerHandlerAdapter.
*/
private void initHandlerAdapters(ApplicationContext context) {
this.handlerAdapters = null;
if (this.detectAllHandlerAdapters) {
// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
// 1.从子容器中获取所有HandlerAdapter, 这里有三个：
// org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter
// org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter
// org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
Map<String, HandlerAdapter> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerAdapters = new ArrayList<HandlerAdapter>(matchingBeans.values());
// We keep HandlerAdapters in sorted order.
// 2.排序HandlerAdapter
// HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter
AnnotationAwareOrderComparator.sort(this.handlerAdapters);
}
}
else {
try {
HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
this.handlerAdapters = Collections.singletonList(ha);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerAdapter later.
}
}
// Ensure we have at least some HandlerAdapters, by registering
// default HandlerAdapters if no other adapters are found.
if (this.handlerAdapters == null) {
this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
if (logger.isDebugEnabled()) {
logger.debug("No HandlerAdapters found in servlet '" + getServletName() + "': using default");
}
}
}
从容器中获取所有HandlerAdapter处理器，并排序，目前有三个，顺序为：HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter
initHandlerExceptionResolvers(ApplicationContext context)
/**
* Initialize the HandlerExceptionResolver used by this class.
* <p>If no bean is defined with the given name in the BeanFactory for this namespace,
* we default to no exception resolver.
*/
private void initHandlerExceptionResolvers(ApplicationContext context) {
this.handlerExceptionResolvers = null;
if (this.detectAllHandlerExceptionResolvers) {
// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
// 1.从子容器中获取所有 HandlerExceptionResolver, 这里找到3个:
// org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver
// org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver
// org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerExceptionResolvers = new ArrayList<HandlerExceptionResolver>(matchingBeans.values());
// We keep HandlerExceptionResolvers in sorted order.
// 2.排序HandlerExceptionResolver:
// ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver
AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
}
}
else {
try {
HandlerExceptionResolver her =
context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
this.handlerExceptionResolvers = Collections.singletonList(her);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, no HandlerExceptionResolver is fine too.
}
}
// Ensure we have at least some HandlerExceptionResolvers, by registering
// default HandlerExceptionResolvers if no other resolvers are found.
if (this.handlerExceptionResolvers == null) {
this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("No HandlerExceptionResolvers found in servlet '" + getServletName() + "': using default");
}
}
}
从容器中获取所有HandlerExceptionResolver处理器，并排序，目前有三个，顺序为：ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver
initRequestToViewNameTranslator(ApplicationContext context)
/**
* Initialize the RequestToViewNameTranslator used by this servlet instance.
* <p>If no implementation is configured then we default to DefaultRequestToViewNameTranslator.
*/
private void initRequestToViewNameTranslator(ApplicationContext context) {
try {
this.viewNameTranslator =
context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
if (logger.isDebugEnabled()) {
logger.debug("Using RequestToViewNameTranslator [" + this.viewNameTranslator + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// We need to use the default.
this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate RequestToViewNameTranslator with name '" +
REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME + "': using default [" + this.viewNameTranslator +
"]");
}
}
}
初始化RequestToViewNameTranslator，如果没有配置，使用默认的
initViewResolvers(ApplicationContext context)
/**
* Initialize the ViewResolvers used by this class.
* <p>If no ViewResolver beans are defined in the BeanFactory for this
* namespace, we default to InternalResourceViewResolver.
*/
private void initViewResolvers(ApplicationContext context) {
this.viewResolvers = null;
if (this.detectAllViewResolvers) {
// Find all ViewResolvers in the ApplicationContext, including ancestor contexts.
// 1.从子容器中获取所有ViewResolver, 没有获取到
Map<String, ViewResolver> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
if (!matchingBeans.isEmpty()) {
this.viewResolvers = new ArrayList<ViewResolver>(matchingBeans.values());
// We keep ViewResolvers in sorted order.
AnnotationAwareOrderComparator.sort(this.viewResolvers);
}
}
else {
try {
ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
this.viewResolvers = Collections.singletonList(vr);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default ViewResolver later.
}
}
// Ensure we have at least one ViewResolver, by registering
// a default ViewResolver if no other resolvers are found.
if (this.viewResolvers == null) {
// 2.使用默认的ViewResolver
this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
if (logger.isDebugEnabled()) {
logger.debug("No ViewResolvers found in servlet '" + getServletName() + "': using default");
}
}
}
初始化ViewResolver，如果没有配置，使用默认的
initFlashMapManager(ApplicationContext context)
/**
* Initialize the {@link FlashMapManager} used by this servlet instance.
* <p>If no implementation is configured then we default to
* {@code org.springframework.web.servlet.support.DefaultFlashMapManager}.
*/
private void initFlashMapManager(ApplicationContext context) {
try {
this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
if (logger.isDebugEnabled()) {
logger.debug("Using FlashMapManager [" + this.flashMapManager + "]");
}
}
catch (NoSuchBeanDefinitionException ex) {
// We need to use the default.
this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
if (logger.isDebugEnabled()) {
logger.debug("Unable to locate FlashMapManager with name '" +
FLASH_MAP_MANAGER_BEAN_NAME + "': using default [" + this.flashMapManager + "]");
}
}
}
初始化FlashMapManager，如果没有配置，使用默认的
总结
这里主要初始化DispatcherServlet的相关组件, 其中最重要的组件有: HandlerMapping、 HandlerAdapter
4.2 建立Map<url, controller>关系
综上，我们从容器中获取所有的HandlerMapping对象时，会获取到其中的BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping和RequestMappingHandlerMapping，这个类继承了AbstractDetectingUrlHandlerMapping，AbstractDetectingUrlHandlerMapping继承了AbstractUrlHandlerMapping，AbstractUrlHandlerMapping继承了WebApplicationObjectSupport，WebApplicationObjectSupport继承了ApplicationObjectSupport，ApplicationObjectSupport实现了ApplicationContextAware接口
即：HandlerMapping实例间接实现了ApplicationContextAware接口
4.2.1 SimpleUrlHandlerMapping
4.2.1.1 结构图
根据[@Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext](/Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext) context)方法
4.3.1.2 ApplicationObjectSupport#setApplicationContext(ApplicationContext context)
@Override
public final void setApplicationContext(ApplicationContext context) throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
}
else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
}
// 1.赋值子容器
this.applicationContext = context;
// 2.初始化messageSourceAccessor
this.messageSourceAccessor = new MessageSourceAccessor(context);
// 3.这里的initApplicationContext(context)由子类WebApplicationObjectSupport复写
initApplicationContext(context);
}
else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is [" +
this.applicationContext + "], passed-in one is [" + context + "]");
}
}
}
4.2.1.3 WebApplicationObjectSupport#initApplicationContext(ApplicationContext context)
/**
* Calls {@link #initServletContext(javax.servlet.ServletContext)} if the
* given ApplicationContext is a {@link WebApplicationContext}.
*/
@Override
protected void initApplicationContext(ApplicationContext context) {
// 1.这里会先调用父类的方法, 即ApplicationObjectSupport的initApplicationContext(ApplicationContext context), 最终会回调到
// SimpleUrlHandlerMapping#initApplicationContext()
super.initApplicationContext(context);
if (this.servletContext == null && context instanceof WebApplicationContext) {
this.servletContext = ((WebApplicationContext) context).getServletContext();
if (this.servletContext != null) {
initServletContext(this.servletContext);
}
}
}
4.2.1.4 SimpleUrlHandlerMapping#initApplicationContext()
@Override
public void initApplicationContext() throws BeansException {
// 先调用父类的initApplicationContext(), 这里调用的是 AbstractHandlerMapping#initApplicationContext()
super.initApplicationContext();
// 这里的urlMap存的是url和处理器的关联关系, 初始化时已经有了1个
// ("/**", DefaultServletHttpRequestHandler字符串)
registerHandlers(this.urlMap);
}
4.2.1.5 SimpleUrlHandlerMapping#registerHandlers(Map<String, Object> urlMap)
/**
* Register all handlers specified in the URL map for the corresponding paths.
* @param urlMap Map with URL paths as keys and handler beans or bean names as values
* @throws BeansException if a handler couldn't be registered
* @throws IllegalStateException if there is a conflicting handler registered
*/
protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
if (urlMap.isEmpty()) {
logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
}
else {
// 1.urlMap不为空, ("/**", DefaultServletHttpRequestHandler)
for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
String url = entry.getKey();
Object handler = entry.getValue();
// Prepend with slash if not already present.
if (!url.startsWith("/")) {
url = "/" + url;
}
// Remove whitespace from handler bean name.
if (handler instanceof String) {
handler = ((String) handler).trim();
}
// 2.注册handler, 向父类AbstractUrlHandlerMapping中注册, urlMap
// handlerMap成员变量添加("/**", DefaultServletHttpRequestHandler)
registerHandler(url, handler);
}
}
}
4.2.2 BeanNameUrlHandlerMapping
4.2.2.1 结构图
根据[@Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext](/Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext) context)方法
4.3.2.2 ApplicationObjectSupport#setApplicationContext(ApplicationContext context)
@Override
public final void setApplicationContext(ApplicationContext context) throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
}
else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
}
// 1.赋值子容器
this.applicationContext = context;
// 2.初始化messageSourceAccessor
this.messageSourceAccessor = new MessageSourceAccessor(context);
// 3.这里的initApplicationContext(context)由子类WebApplicationObjectSupport复写
initApplicationContext(context);
}
else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is [" +
this.applicationContext + "], passed-in one is [" + context + "]");
}
}
}
4.2.2.3 WebApplicationObjectSupport#initApplicationContext(ApplicationContext context)
/**
* Calls {@link #initServletContext(javax.servlet.ServletContext)} if the
* given ApplicationContext is a {@link WebApplicationContext}.
*/
@Override
protected void initApplicationContext(ApplicationContext context) {
// 1.这里会先调用父类的方法, 即ApplicationObjectSupport的initApplicationContext(ApplicationContext context), 最终会回调到
// AbstractDelectingUrlHandlerMapping#initApplicationContext()
super.initApplicationContext(context);
if (this.servletContext == null && context instanceof WebApplicationContext) {
this.servletContext = ((WebApplicationContext) context).getServletContext();
if (this.servletContext != null) {
initServletContext(this.servletContext);
}
}
}
4.2.2.4 AbstractDelectingUrlHandlerMapping#initApplicationContext()
/**
* Calls the {@link #detectHandlers()} method in addition to the
* superclass's initialization.
*/
@Override
public void initApplicationContext() throws ApplicationContextException {
// 1.调用父类 AbstractHandlerMapping#initApplicationContext()
super.initApplicationContext();
// 2.调用
detectHandlers();
}
4.2.2.5 AbstractDelectingUrlHandlerMapping#detectHandlers()
/**
* Register all handlers found in the current ApplicationContext.
* <p>The actual URL determination for a handler is up to the concrete
* {@link #determineUrlsForHandler(String)} implementation. A bean for
* which no such URLs could be determined is simply not considered a handler.
* @throws org.springframework.beans.BeansException if the handler couldn't be registered
* @see #determineUrlsForHandler(String)
*/
protected void detectHandlers() throws BeansException {
if (logger.isDebugEnabled()) {
logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
}
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
getApplicationContext().getBeanNamesForType(Object.class));
// Take any bean name that we can determine URLs for.
for (String beanName : beanNames) {
// 目前determineUrlsForHandler(beanName)都返回空
String[] urls = determineUrlsForHandler(beanName);
if (!ObjectUtils.isEmpty(urls)) {
// URL paths found: Let's consider it a handler.
registerHandler(urls, beanName);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
}
}
}
}
4.2.3 RequestMappingHandlerMapping（重点）
4.2.3.1 结构图
根据[@Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext](/Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext) context)方法
4.3 处理请求
4.3.1 预备
1.当一个请求过来时，优先使用Filter处理，处理完之后根据配置找到对应的Servlet，我们这里只配置了一个DispatcherServlet用于处理所有请求
2.Dispatcher处理请求时，优先调用service(req, resp)方法，该方法由其父类FrameworkServlet实现
4.3.2 FrameworkServlet#service(HttpServletRequest request, HttpServletResponse response)
/**
* Override the parent class implementation in order to intercept PATCH requests.
*/
@Override
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
processRequest(request, response);
}
else {
// 调用父类的service(req,resp)方法, 见@4.3.3
super.service(request, response);
}
}
4.3.3 HttpServlet#service(HttpServletRequest req, HttpServletResponse resp)
这个方法根据不同的请求方法调用不同的处理方法，如doGet()，doPost()等，具体的方法有子类FrameworkServlet实现
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
String method = req.getMethod();
if (method.equals(METHOD_GET)) {
long lastModified = getLastModified(req);
if (lastModified == -1) {
// servlet doesn't support if-modified-since, no reason
// to go through further expensive logic
doGet(req, resp);
} else {
long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
if (ifModifiedSince < (lastModified / 1000 * 1000)) {
// If the servlet mod time is later, call doGet()
// Round down to the nearest second for a proper compare
// A ifModifiedSince of -1 will always be less
maybeSetLastModified(resp, lastModified);
doGet(req, resp);
} else {
resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
}
}
} else if (method.equals(METHOD_HEAD)) {
long lastModified = getLastModified(req);
maybeSetLastModified(resp, lastModified);
doHead(req, resp);
} else if (method.equals(METHOD_POST)) {
doPost(req, resp);
} else if (method.equals(METHOD_PUT)) {
doPut(req, resp);
} else if (method.equals(METHOD_DELETE)) {
doDelete(req, resp);
} else if (method.equals(METHOD_OPTIONS)) {
doOptions(req,resp);
} else if (method.equals(METHOD_TRACE)) {
doTrace(req,resp);
} else {
//
// Note that this means NO servlet supports whatever
// method was requested, anywhere on this server.
//
String errMsg = lStrings.getString("http.method_not_implemented");
Object[] errArgs = new Object[1];
errArgs[0] = method;
errMsg = MessageFormat.format(errMsg, errArgs);
resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
}
}
4.3.4 Framework#doGet(HttpServletRequest request, HttpServletResponse response)
@Override
protected final void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
// 见@4.3.5
processRequest(request, response);
}
4.3.5 Framework#processRequest(HttpServletRequest request, HttpServletResponse response)
/**
* Process this request, publishing an event regardless of the outcome.
* <p>The actual event handling is performed by the abstract
* {@link #doService} template method.
*/
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
long startTime = System.currentTimeMillis();
Throwable failureCause = null;
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
// 1.构建localeContext
LocaleContext localeContext = buildLocaleContext(request);
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
// 2.构建ServletRequestAttributes
ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
// 3.初始化LocaleContextHolder, 主要是一些线程共享变量 ThreadLocal
initContextHolders(request, localeContext, requestAttributes);
try {
// 4.调用doService(req, resp), 由子类DispatcherServlet实现，见@4.3.6
doService(request, response);
}
catch (ServletException ex) {
failureCause = ex;
throw ex;
}
catch (IOException ex) {
failureCause = ex;
throw ex;
}
catch (Throwable ex) {
failureCause = ex;
throw new NestedServletException("Request processing failed", ex);
}
finally {
// 5.销毁LocaleContextHolder, 主要是一些线程共享变量 ThreadLocal
resetContextHolders(request, previousLocaleContext, previousAttributes);
if (requestAttributes != null) {
requestAttributes.requestCompleted();
}
if (logger.isDebugEnabled()) {
if (failureCause != null) {
this.logger.debug("Could not complete request", failureCause);
}
else {
if (asyncManager.isConcurrentHandlingStarted()) {
logger.debug("Leaving response open for concurrent processing");
}
else {
this.logger.debug("Successfully completed request");
}
}
}
// 6.发布处理请求事件
publishRequestHandledEvent(request, response, startTime, failureCause);
}
}
4.3.6 DispatcherServlet#doService(HttpServletRequest request, HttpServletResponse response)
@Override
protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
if (logger.isDebugEnabled()) {
String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
" processing " + request.getMethod() + " request for [" + getRequestUri(request) + "]");
}
// Keep a snapshot of the request attributes in case of an include,
// to be able to restore the original attributes after the include.
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap<String, Object>();
Enumeration<?> attrNames = request.getAttributeNames();
while (attrNames.hasMoreElements()) {
String attrName = (String) attrNames.nextElement();
if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
attributesSnapshot.put(attrName, request.getAttribute(attrName));
}
}
}
// Make framework objects available to handlers and view objects.
// 1.将框架中的一些对象暴露给其他处理器, 比如localeResolver
request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
if (inputFlashMap != null) {
request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
}
request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
try {
// 2.核心方法, 作请求分发处理, 见@4.3.7
doDispatch(request, response);
}
finally {
if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
// Restore the original attribute snapshot, in case of an include.
if (attributesSnapshot != null) {
restoreAttributesAfterInclude(request, attributesSnapshot);
}
}
}
}
4.3.7 DispatcherServlet#doDispatch(HttpServletRequest request, HttpServletResponse response)
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 1.判断是否是文件上传
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// Determine handler for the current request.
// 2.根据请求获取HandlerExecutionChain, 见@4.3.8
// 这里由RequestMappingHandlerMapping根据请求url匹配到对应的Controller的对应方法, 封装成HandlerExecutionChain
// 这个chain封装了一个HandlerMethod(url对应的Controller和对应的method)以及一个拦截器: ConversionServiceExpodingInterceptor
mappedHandler = getHandler(processedRequest);
// 3.没找到直接返回404
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}
// Determine handler adapter for the current request.
// 4.根据handlerMethod找到HandlerAdapter, 这里获取的是RequestMappingHandlerAdapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (logger.isDebugEnabled()) {
logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
}
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
// 5.前面: mappedHandler是HandlerExecutionChain, 是对对应处理器HandlerMethod以及拦截器的封装,
// 这里会先调用拦截器的preHandle方法进行拦截
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// Actually invoke the handler.
// 6.调用处理器方法, 见@4.3.10
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
// 7.mv == null, 直接跳过
applyDefaultViewName(processedRequest, mv);
// 8.调用拦截器的postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
// As of 4.3, we're processing Errors thrown from handler methods as well,
// making them available for @ExceptionHandler methods and other scenarios.
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
triggerAfterCompletion(processedRequest, response, mappedHandler,
new NestedServletException("Handler processing failed", err));
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
4.3.8 DispatcherServlet#getHandler(HttpServletRequest request)
/**
* Return the HandlerExecutionChain for this request.
* <p>Tries all handler mappings in order.
* @param request current HTTP request
* @return the HandlerExecutionChain, or {@code null} if no handler could be found
*/
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
// 这里的handlerMappings有三个, 且已经排序了, 第一个是RequestMappingHandlerMapping
for (HandlerMapping hm : this.handlerMappings) {
if (logger.isTraceEnabled()) {
logger.trace(
"Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
}
// 这里由RequestMappingHandlerMapping根据请求url匹配到对应的HandlerMethod, 封装成HandlerExecutionChain
// 这个chain封装了对应的HandlerMethod以及一个拦截器: ConversionServiceExpodingInterceptor
HandlerExecutionChain handler = hm.getHandler(request);
if (handler != null) {
return handler;
}
}
return null;
}
4.3.9 DispatcherServlet#getHandlerAdapter(Object handler)
/**
* Return the HandlerAdapter for this handler object.
* @param handler the handler object to find an adapter for
* @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
*/
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
// 这里的handlerAdapters有三个: HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter
for (HandlerAdapter ha : this.handlerAdapters) {
if (logger.isTraceEnabled()) {
logger.trace("Testing handler adapter [" + ha + "]");
}
// 因为前期用的RequestMappingHandlerMapping, 所以这里获取到的是 RequestMappingHandlerAdapter
if (ha.supports(handler)) {
return ha;
}
}
throw new ServletException("No adapter for handler [" + handler +
"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}
4.3.10 AbstractHandlerMethodAdapter#handle(HttpServletRequest request, HttpServletResponse response, Object handler)
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 这里由子类 RequstMappingHandlerAdapter 实现, 见@4.3.11
return handleInternal(request, response, (HandlerMethod) handler);
}
4.3.11 RequstMappingHandlerAdapter#handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod)
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
// 1.校验请求方法和是否需要session
checkRequest(request);
// Execute invokeHandlerMethod in synchronized block if required.
if (this.synchronizeOnSession) {
HttpSession session = request.getSession(false);
if (session != null) {
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No HttpSession available -> no mutex necessary
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No synchronization on session demanded at all...
// 2.进入, 返回ModelAndView, 这里使用的rest方法, 不会返回ModelAndView
mav = invokeHandlerMethod(request, response, handlerMethod);
}
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
prepareResponse(response);
}
}
return mav;
}
5.springmvc组件解析
5.1 入口
1.由前面分析, servlet容器在加载web.xml时, 会初始化DispatcherServlet, 此时会执行DispatcherServlet的静态代码块
static {
try {
// DEFAULT_STRATEGIES_PATH == DispatcherServlet.properties
// 即加载DispatcherServlet类时会加载 DispatcherServlet.properties 配置文件, 存储在 defaultStrategies
// 查看 DispatcherServlet.properties, 可以看到, 是DispatcherServlet中九大组件的默认实现类, 其中有八个组件的默认实现类, 缺少一个MultipartResolver, 因此, 如果没有在 springmvc-config.xml文件中配置, 则不会有 MultipartResolver, 此时无法解析文件上传等功能
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
}
}
org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager
2.子容器XmlWebApplicationContext启动时，发布ContextRefreshedEvent事件，被已经添加的ContextRefreshListener监听，回调其onApplicationEvent(ContextRefreshedEvent event)方法，这个方法中调用了DispatcherServlet的onRefresh(ApplicationContext context)方法，在onRefresh方法中会调用核心方法 initStrategies，在 initStrategies 方法中完成九大组件的初始化
3.注意：以上配置文件中的组件不会一开始就加载到子容器XmlWebApplicationContext中，子容器一开始只会加载其他核心bean以及配置文件springmvc中bean，所以如果我们在springmvc.xml文件中配置了相关组件，优先会使用我们配置的，如果没有，才会使用 DispatcherServlet.properties 配置的相关组件
DispatcherServlet#onRefresh(ApplicationContext context)
@Override
protected void onRefresh(ApplicationContext context) {
initStrategies(context);
}
DispatcherServlet#initStrategies(ApplicationContext context)
/**
* Initialize the strategy objects that this servlet uses.
* <p>May be overridden in subclasses in order to initialize further strategy objects.
*/
// 入参的ApplicationContext是子容器
protected void initStrategies(ApplicationContext context) {
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
5.2 MultipartResolver
MultipartResolver是九大组件之一，用于处理文件上传
5.2.1 初始化
private void initMultipartResolver(ApplicationContext context) {
try {
// 1.直接从子spring容器中获取, 如果springmvc-config.xml文件中没有配置, 则获取失败
this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
if (logger.isTraceEnabled()) {
logger.trace("Detected " + this.multipartResolver);
}
else if (logger.isDebugEnabled()) {
logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
}
}
catch (NoSuchBeanDefinitionException ex) {
// Default is no multipart resolver.
// 2.获取失败后, 也不会从 DispatcherServlet.properties 配置中读取, 因为 DispatcherServlet.properties 配置文件中也没有配置当前组件
this.multipartResolver = null;
if (logger.isTraceEnabled()) {
logger.trace("No MultipartResolver '" + MULTIPART_RESOLVER_BEAN_NAME + "' declared");
}
}
}
5.2.2 实现
MultipartResolver有两个实现：CommonsMultipartResolver 和 StandardServletMultipartResolver，如果在springmvc中需要使用，则需要在springmvc-config.xml文件中进行注册，否则默认无法解析文件上传
5.2.2.1 CommonsMultipartResolver
1.在springmvc.config文件中配置CommonsMultipartResolver
<bean class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<property name="maxUploadSize" value="104857600" />
<property name="maxInMemorySize" value="104857600" />
</bean>
2.pom.xml文件中需要引入commons-file，因为CommonsMultipartResolver借助了commons-file
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>
5.2.2.2 StandardServletMultipartResolver
这个是springboot中默认引入的bean，springboot采用spi机制，在spring-boot-autoconfigure包的resources/META-INF/spring.factories文件中，引入了MultipartAutoConfiguration，在MultipartAutoConfiguration中根据条件，向spring容器中注册了 StandardServletMultipartResolver
5.2.3 应用
在核心处理流程中，DispatcherServlet#doDispatch方法中
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 1.判断是否是文件上传, 判断条件: Content-Type 是否以 multipart/ 开头
// 并将 HttpServletRequest 封装成 MultipartHttpServletRequest, 具体实现暂略
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
......
}
5.3 HandlerMapping
HandlerMapping是九大组件之一，负责为请求找到合适的 HandlerExecutionChain 处理器执行链，包含处理器（handler）和拦截器（interceptors），处理器通常就是我们在@Controller下@RequestMapping注解对应的方法的封装，拦截器是对处理请求进行增强处理，用于对处理器的增强
5.3.1 初始化
private void initHandlerMappings(ApplicationContext context) {
this.handlerMappings = null;
// 1.如果开启探测功能, 则会从springmvc容器中扫描所有的 HandlerMapping, 添加到 handlerMappings 中, 默认开启, 默认找到3个
// 默认3个是何时添加到springmvc容器中？是在初始化子springmvc容器的过程中, 解析springmvc-config.xml配置文件的过程中创建的BeanDefinition, 这个后期有空再具体写文档
// SimpleUrlHandlerMapping、BeanNameUrlHandlerMapping、RequestMappingHandlerMapping, 下面会进行重新排序
if (this.detectAllHandlerMappings) {
// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
Map<String, HandlerMapping> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerMappings = new ArrayList<>(matchingBeans.values());
// We keep HandlerMappings in sorted order.
// 重新排序: RequestMappingHandlerMapping、BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping
AnnotationAwareOrderComparator.sort(this.handlerMappings);
}
}
// 2.关闭探测功能时, 获得Bean名称为 handlerMapping 对应的 Bean, 将其添加至 handlerMappings
else {
try {
HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
this.handlerMappings = Collections.singletonList(hm);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerMapping later.
}
}
// Ensure we have at least one HandlerMapping, by registering
// a default HandlerMapping if no other mappings are found.
// 3.如果未获得到, 则获得默认配置 DispatcherServlet.properties 中的 HandlerMapping 类
if (this.handlerMappings == null) {
this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
5.3.2 实现
5.3.2.1 结构图
1.蓝色框 AbstractHandlerMapping 抽象类, 实现了getHandler方法, 用于处理器映射器找到对应的 HandlerExecutionChain, getHandler中采用模板方法模式, 子类需要实现 getHandlerInternal(HttpServletRequest request) 抽象方法
2.AbstractHandlerMapping的子类主要分为两类:
黄色框 AbstractUrlHandlerMapping, 是基于url进行匹配的, 目前这种方式已经基本不用了, 我们初始化获取的 SimpleUrlHandlerMapping 和 BeanNameUrlHandlerMapping 就是属于此类, 所以接下来也不会分析了
红色框 AbstractHandlerMethodMapping系, 基于Method匹配, 我们现在使用的@RequestMapping注解就是基于这种方式, 这个是我们接下来会具体分析的
5.3.2.2 AbstractHandlerMapping
public abstract class AbstractHandlerMapping extends WebApplicationObjectSupport implements HandlerMapping, Ordered, BeanNameAware {
/**
* 默认处理器
*/
@Nullable
private Object defaultHandler;
/**
* URL 路径工具类
*/
private UrlPathHelper urlPathHelper = new UrlPathHelper();
/**
* 路径匹配器
*/
private PathMatcher pathMatcher = new AntPathMatcher();
/**
* 配置的拦截器数组.
*
* 在 {@link #initInterceptors()} 方法中，初始化到 {@link #adaptedInterceptors} 中
*
* 添加方式有两种：
* 1. {@link #setInterceptors(Object...)} 方法
* 2. {@link #extendInterceptors(List)} 方法
*/
private final List<Object> interceptors = new ArrayList<>();
/**
* 初始化后的拦截器 HandlerInterceptor 数组
*/
private final List<HandlerInterceptor> adaptedInterceptors = new ArrayList<>();
......
}
initApplicationContext
@Override
protected void initApplicationContext() throws BeansException {
// 1.空实现,交给子类实现, 用于注册自定义的拦截器到 interceptors 中, 目前暂无子类实现
extendInterceptors(this.interceptors);
// 2.扫描已注册的 MappedInterceptor 的 Bean，添加到 mappedInterceptors 中
detectMappedInterceptors(this.adaptedInterceptors);
// 3.将 interceptors 初始化成 HandlerInterceptor 类型，添加到 mappedInterceptors 中
initInterceptors();
}
getHandler
@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
// 1.获得处理器（HandlerMethod 或者 HandlerExecutionChain）, 该方法是抽象方法, 由子类实现
Object handler = getHandlerInternal(request);
// 2.获得不到, 则使用默认处理器
if (handler == null) {
handler = getDefaultHandler();
}
// 3.还是获得不到, 则返回 null
if (handler == null) {
return null;
}
// Bean name or resolved handler?
// 4.如果找到的处理器是 String 类型, 则从 Spring 容器中找到对应的 Bean 作为处理器
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
// 5.创建 HandlerExecutionChain 对象(包含处理器和拦截器), 见下
HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
if (logger.isTraceEnabled()) {
logger.trace("Mapped to " + handler);
}
else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
logger.debug("Mapped to " + executionChain.getHandler());
}
if (CorsUtils.isCorsRequest(request)) {
CorsConfiguration globalConfig = this.corsConfigurationSource.getCorsConfiguration(request);
CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
}
return executionChain;
}
getHandlerExecutionChain
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
// 1.创建 HandlerExecutionChain 对象
HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ? (HandlerExecutionChain) handler
: new HandlerExecutionChain(handler));
// 2.获得请求路径
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
// 3.遍历 adaptedInterceptors 数组, 获得请求匹配的拦截器
for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
//4.需要匹配，若路径匹配，则添加到 chain 中
if (interceptor instanceof MappedInterceptor) {
MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) { // 匹配
chain.addInterceptor(mappedInterceptor.getInterceptor());
}
}
// 5.无需匹配，直接添加到 chain 中
else {
chain.addInterceptor(interceptor);
}
}
return chain
}
5.3.2.3 RequestMappingHandlerMapping
结构图
由结构图可以看出，RequestMappingHandlerMapping间接继承了父类ApplicationObjectSupport，实现了Aware接口，根据[@Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext](/Spring源码，在bean的创建和初始化过程中，会先后八次调用BeanPostProcessor，在属性注入之后，会第七次调用BeanPostProcessor，执行部分Aware回调接口，这里会回调其父类ApplicationObjectSupport的setApplicationContext(ApplicationContext) context)方法
ApplicationObjectSupport#setApplicationContext(ApplicationContext context)
@Override
public final void setApplicationContext(ApplicationContext context) throws BeansException {
if (context == null && !isContextRequired()) {
// Reset internal context state.
this.applicationContext = null;
this.messageSourceAccessor = null;
}
else if (this.applicationContext == null) {
// Initialize with passed-in context.
if (!requiredContextClass().isInstance(context)) {
throw new ApplicationContextException(
"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
}
// 1.赋值子容器
this.applicationContext = context;
// 2.初始化messageSourceAccessor
this.messageSourceAccessor = new MessageSourceAccessor(context);
// 3.这里的initApplicationContext(context)由子类WebApplicationObjectSupport复写
initApplicationContext(context);
}
else {
// Ignore reinitialization if same context passed in.
if (this.applicationContext != context) {
throw new ApplicationContextException(
"Cannot reinitialize with different application context: current one is [" +
this.applicationContext + "], passed-in one is [" + context + "]");
}
}
}
WebApplicationObjectSupport#initApplicationContext(ApplicationContext context)
/**
* Calls {@link #initServletContext(javax.servlet.ServletContext)} if the
* given ApplicationContext is a {@link WebApplicationContext}.
*/
@Override
protected void initApplicationContext(ApplicationContext context) {
// 1.这里会先调用父类的方法, 即ApplicationObjectSupport的initApplicationContext(ApplicationContext context), 最终会回调到
// AbstractHandlerMapping#initApplicationContext()
super.initApplicationContext(context);
if (this.servletContext == null && context instanceof WebApplicationContext) {
this.servletContext = ((WebApplicationContext) context).getServletContext();
if (this.servletContext != null) {
initServletContext(this.servletContext);
}
}
}
AbstractHandlerMapping#initApplicationContext()
/**
* Initializes the interceptors.
* @see #extendInterceptors(java.util.List)
* @see #initInterceptors()
*/
@Override
protected void initApplicationContext() throws BeansException {
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.adaptedInterceptors);
initInterceptors();
}
在第七次BeanPostProcessor调用后，会调用bean的初始化方法，因为RequestMappingHandlerMapping实现了InitializingBean接口，所以会回调其afterPropertiesSet()方法，在这里真正完成url和HandlerMethod的绑定
RequestMappingHandlerMapping#afterPropertiesSet()
@Override
public void afterPropertiesSet() {
this.config = new RequestMappingInfo.BuilderConfiguration();
this.config.setUrlPathHelper(getUrlPathHelper());
this.config.setPathMatcher(getPathMatcher());
this.config.setSuffixPatternMatch(this.useSuffixPatternMatch);
this.config.setTrailingSlashMatch(this.useTrailingSlashMatch);
this.config.setRegisteredSuffixPatternMatch(this.useRegisteredSuffixPatternMatch);
this.config.setContentNegotiationManager(getContentNegotiationManager());
// 调用父类 afterPropertiesSet(), 由AbstractHandlerMethodMapping实现
super.afterPropertiesSet();
}
AbstractHandlerMethodMapping#afterPropertiesSet()
@Override
public void afterPropertiesSet() {
initHandlerMethods();
}
AbstractHandlerMethodMapping#initHandlerMethods()
/**
* Scan beans in the ApplicationContext, detect and register handler methods.
* @see #getCandidateBeanNames()
* @see #processCandidateBean
* @see #handlerMethodsInitialized
*/
protected void initHandlerMethods() {
for (String beanName : getCandidateBeanNames()) {
// 不以 scopedTarget. 开头, 则进入
if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
processCandidateBean(beanName);
}
}
handlerMethodsInitialized(getHandlerMethods());
}
AbstractHandlerMethodMapping#processCandidateBean(String beanName)
protected void processCandidateBean(String beanName) {
Class<?> beanType = null;
try {
// 1.获取Class对象
beanType = obtainApplicationContext().getType(beanName);
}
catch (Throwable ex) {
// An unresolvable bean type, probably from a lazy bean - let's ignore it.
if (logger.isTraceEnabled()) {
logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
}
}
// 2.判断Class是否有@RequestMapping注解或者@Controller注解
if (beanType != null && isHandler(beanType)) {
// 3.封装 HandlerMethod, 存储到mappingLookup中
// key = @RequestMapping中的url
// value = HandlerMethod
// 在这里绑定了url和对应Controller的处理方法的封装 HandlerMethod, 存储到了其父类AbstractHandlerMehodMapping的属性mappingRegistry中, 见下
detectHandlerMethods(beanName);
}
}
AbstractHandlerMethodMapping#detectHandlerMethods
protected void detectHandlerMethods(Object handler) {
Class<?> handlerType = (handler instanceof String ?
obtainApplicationContext().getType((String) handler) : handler.getClass());
if (handlerType != null) {
Class<?> userType = ClassUtils.getUserClass(handlerType);
Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
(MethodIntrospector.MetadataLookup<T>) method -> {
try {
return getMappingForMethod(method, userType);
}
catch (Throwable ex) {
throw new IllegalStateException("Invalid mapping on handler class [" + userType.getName() + "]: " + method, ex);
}
});
if (logger.isTraceEnabled()) {
logger.trace("Mapped " + methods.size() + " handler method(s) for " + userType + ": " + methods);
}
methods.forEach((method, mapping) -> {
Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
// 注册url和对应的Method, 见下
registerHandlerMethod(handler, invocableMethod, mapping);
});
}
}
AbstractHandlerMethodMapping#registerHandlerMethod
protected void registerHandlerMethod(Object handler, Method method, T mapping) {
// 核心方法
this.mappingRegistry.register(mapping, handler, method);
}
MappingRegistry#register
public void register(T mapping, Object handler, Method method) {
// 1.获取写锁
this.readWriteLock.writeLock().lock();
try {
// 2.创建 Method 对应的 HandlerMethod
HandlerMethod handlerMethod = createHandlerMethod(handler, method);
assertUniqueMethodMapping(handlerMethod, mapping);
// 3.存储 (mapping, HandlerMethod) 关联关系到 mappingLookup属性
this.mappingLookup.put(mapping, handlerMethod);
// 4.获得 mapping 对应的普通 URL 数组
List<String> directUrls = getDirectUrls(mapping);
for (String url : directUrls) {
// 5.将 url 和 mapping 的映射关系保存至 urlLookup属性
this.urlLookup.add(url, mapping);
}
String name = null;
// 6.初始化 nameLookup
if (getNamingStrategy() != null) {
// 7.获得 Mapping 的名字
name = getNamingStrategy().getName(handlerMethod, mapping);
// 8.将 mapping 的名字与 HandlerMethod 的映射关系保存至 nameLookup
addMappingName(name, handlerMethod);
}
// 9.初始化 CorsConfiguration 配置对象
CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
if (corsConfig != null) {
this.corsLookup.put(handlerMethod, corsConfig);
}
// 10.创建 MappingRegistration 对象, 与 mapping 映射添加到 registry 注册表中
this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
}
finally {
this.readWriteLock.writeLock().unlock();
}
}
5.3.2.4 总结
初始化HandlerMapping时, 扫描有 @Controller 或者 @RequestMapping 注解的类下面的方法, 如果方法上面有 @RequestMapping 注解(包括GetMapping, PostMapping等), 则会为该方法创建对应的 RequestMappingInfo 对象, 将所有的 RequestMappingInfo 对象和 Method 以及方法所在类, 往 MappingRegistry 进行注册, 会生成 HandlerMethod 处理器（Method 所有信息）对象。这样一来, 当 Spring MVC 的 DispatcherServlet 处理请求的时候, 获取到对应的 HandlerMethod 处理器, 就可以通过反射执行对应的方法了
5.3.3 应用
在 DispatcherServlet 的doDispatch的方法中
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 1.使用MultipartResolver处理文件上传
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// 2.根据请求获取到对应的 HandlerExectionChain, HandlerExectionChain是对 HandlerMethod 和 HandlerInterceptor 的封装, HandlerMethod一般是我们使用@RequestMapping注解中对应的方法
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
......
}
DispatcherServlet#getHandler
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
// 这里 handlerMappings, 默认有三个, 在initHandlerMapping方法中完成初始化并排序, 排序后为
// RequestMappingHandlerMapping、BeanNameUrlHandlerMapping、SimpleUrlHandlerMapping,
// 其中第一个 RequestMappingHandlerMapping 就是我们现在常用的用于处理 @RequestMapping 注解方式的 handlerMapping
if (this.handlerMappings != null) {
for (HandlerMapping mapping : this.handlerMappings) {
// 按顺序依次调用 handlerMapping#getHandler 方法, getHandler方法由其父类 AbstractHandlerMapping 实现, 上文已分析
// HandlerExecutionChain的具体调用后面会分析
HandlerExecutionChain handler = mapping.getHandler(request);
if (handler != null) {
return handler;
}
}
}
return null;
}
在AbstractHandlerMapping中的getHandler方法，采用模板方法设计模式，回调子类的getHandlerInternal方法，这里我们看 RequestMappingHandlerMapping 的getHandlerInternal方法
RequestMappingHandlerMapping#getHandlerInternal
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
// 1.根据请求获取请求url
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
// 2.获得读锁
this.mappingRegistry.acquireReadLock();
try {
// 3.【重要】根据请求和url获取对应的HandlerMethod, 见下
HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
// 4.响应
return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
}
finally {
// 5.释放锁
this.mappingRegistry.releaseReadLock();
}
}
RequestMappingHandlerMapping#lookupHandlerMethod
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
List<Match> matches = new ArrayList<>();
// 1.首先, 从 urlLookup 属性中找, urlLookup (key --> url, value --> List<RequestMappingInfo>)
List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
if (directPathMatches != null) {
// 2.如果找到, 则再根据 RequestMappingInfo 找到对应的 HandlerMethod, 并封装成 Match, 添加到 matches 中
// 这里会用到 mappingRegistry 的 mappingLookup 属性 (key --> RequestMappingInfo, value --> HandlerMethod)
addMatchingMappings(directPathMatches, matches, request);
}
// 2.这里跳过
if (matches.isEmpty()) {
// No choice but to go through all mappings...
addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
}
// 3.上述如果匹配到, 则会进行排序, 选择最佳Match
if (!matches.isEmpty()) {
Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
matches.sort(comparator);
Match bestMatch = matches.get(0);
if (matches.size() > 1) {
if (logger.isTraceEnabled()) {
logger.trace(matches.size() + " matching mappings: " + matches);
}
if (CorsUtils.isPreFlightRequest(request)) {
return PREFLIGHT_AMBIGUOUS_MATCH;
}
Match secondBestMatch = matches.get(1);
if (comparator.compare(bestMatch, secondBestMatch) == 0) {
Method m1 = bestMatch.handlerMethod.getMethod();
Method m2 = secondBestMatch.handlerMethod.getMethod();
String uri = request.getRequestURI();
throw new IllegalStateException(
"Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
}
}
handleMatch(bestMatch.mapping, lookupPath, request);
return bestMatch.handlerMethod;
}
else {
return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
}
}
5.4 HandlerAdapter
HandlerAdapter组件, 是DispatcherServlet的九大组件之一。在上一步中, 我们通过HandlerMapping组件获取了 HandlerExecutionChain, HandlerExecutionChain 是对对应handler和interceptor的封装, 这里的 handler 是object类型, 需要有一个调用者来实现 handler 是怎么被执行。Spring 中的处理器的有多种实现, 比如用户的处理器可以实现 Controller 接口或者 HttpRequestHandler 接口(这两种方式基本不用了), 也可以用 @RequestMapping 注解将方法作为一个处理器等(这是目前主流的方式), 这就导致 SpringMVC 无法直接执行这个处理器。所以这里需要一个处理器适配器，由它去执行处理器。
5.4.1 初始化
private void initHandlerAdapters(ApplicationContext context) {
this.handlerAdapters = null;
if (this.detectAllHandlerAdapters) {
// Find all HandlerAdapters in the ApplicationContext, including ancestor contexts.
// 1.如果开启探测功能, 则会从springmvc容器中扫描所有的 HandlerAdapter, 添加到 handlerAdapters 中, 默认开启, 默认找到3个
// 默认3个是何时添加到springmvc容器中？是在初始化子springmvc容器的过程中, 解析springmvc-config.xml配置文件的过程中创建的BeanDefinition, 这个后期有空再具体写文档
// 这里默认有3个: HttpRequestHandlerAdapter、 SimpleControllerHandlerAdapter、 RequestMappingHandlerAdapter
Map<String, HandlerAdapter> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerAdapters = new ArrayList<>(matchingBeans.values());
// We keep HandlerAdapters in sorted order.
// 排序: HttpRequestHandlerAdapter、 SimpleControllerHandlerAdapter、 RequestMappingHandlerAdapter(重点分析)
AnnotationAwareOrderComparator.sort(this.handlerAdapters);
}
}
else {
try {
HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
this.handlerAdapters = Collections.singletonList(ha);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, we'll add a default HandlerAdapter later.
}
}
// Ensure we have at least some HandlerAdapters, by registering
// default HandlerAdapters if no other adapters are found.
if (this.handlerAdapters == null) {
// 从DispatcherServlet.properties 中获取
this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerAdapters declared for servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
这里的初始化和 HandlerMapping 的初始化类似，首先从子springmvc容器中获取，即先获取我们在springmvc-config.xml配置文件中配置的 HandlerAdapter以及springmvc容器中自带的（子springmvc容器在初始化时会向容器中注册一些默认的bean, 其中包括一些组件），如果未配置，则获得默认配置 DispatcherServlet.properties 中的 HandlerAdapter 类
5.4.2 实现
5.4.2.1 结构图
5.4.2.2 HandlerAdapter
public interface HandlerAdapter {
// 使用适配器模式, 判断是否支持当前处理器
boolean supports(Object handler);
// 执行处理器, 返回ModelAndView
@Nullable
ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;
// 返回请求的最新更新时间, 如果不支持该操作, 则返回 -1 即可
long getLastModified(HttpServletRequest request, Object handler);
}
5.4.2.3 AbstractHandlerMethodAdapter
public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
// 优先级最低
private int order = Ordered.LOWEST_PRECEDENCE;
public AbstractHandlerMethodAdapter() {
// no restriction of HTTP methods by default
// 参数 restrictDefaultSupportedMethods 参数为 false , 表示不需要严格校验 HttpMethod
super(false);
}
@Override
public final boolean supports(Object handler) {
// handler的类型需要是 HandlerMethod, 这个是@RequestMapping配置创建的对应的 HandlerMethod, 且交由子类实现另一个条件
return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
}
// 必须同时满足support才成立, 子类一般直接返回true
protected abstract boolean supportsInternal(HandlerMethod handlerMethod);
/**
* This implementation expects the handler to be an {@link HandlerMethod}.
*/
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
// 处理逻辑 , 交给子类实现
return handleInternal(request, response, (HandlerMethod) handler);
}
@Nullable
protected abstract ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;
@Override
public final long getLastModified(HttpServletRequest request, Object handler) {
return getLastModifiedInternal(request, (HandlerMethod) handler);
}
protected abstract long getLastModifiedInternal(HttpServletRequest request, HandlerMethod handlerMethod);
}
5.4.2.4 RequestMappingHandlerAdapter
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter
implements BeanFactoryAware, InitializingBean {
...
}
由上可以看到，其实现了InitializingBean接口，由@spring源码可知，实例化时会回调其afterPropertiesSet方法
RequestMappingHandlerAdapter#afterPropertiesSet
@Override
public void afterPropertiesSet() {
// Do this first, it may add ResponseBody advice beans
// 1.初始化 ControllerAdvice 相关
initControllerAdviceCache();
// 2.初始化 argumentResolvers 属性
if (this.argumentResolvers == null) {
List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
// 3.初始化 initBinderArgumentResolvers 属性
if (this.initBinderArgumentResolvers == null) {
List<HandlerMethodArgumentResolver> resolvers = getDefaultInitBinderArgumentResolvers();
this.initBinderArgumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
}
// 4.初始化 returnValueHandlers 属性
if (this.returnValueHandlers == null) {
List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
}
}
RequestMappingHandlerAdapter#initControllerAdviceCache
private void initControllerAdviceCache() {
if (getApplicationContext() == null) {
return;
}
// 1.从spring获取中获取有 @ControllerAdvice 注解的bean, 并封装成 ControllerAdviceBean
// @ControllerAdvice 通常我们用来做全局异常处理等
List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
// 2.排序
AnnotationAwareOrderComparator.sort(adviceBeans);
List<Object> requestResponseBodyAdviceBeans = new ArrayList<>();
// 3.遍历 adviceBeans
for (ControllerAdviceBean adviceBean : adviceBeans) {
Class<?> beanType = adviceBean.getBeanType();
if (beanType == null) {
throw new IllegalStateException("Unresolvable type for ControllerAdviceBean: " + adviceBean);
}
// 扫描有 @ModelAttribute, 没有 @RequestMapping 注解的方法，添加到 modelAttributeAdviceCache 属性中
// 该类方法用于在执行方法前修改 Model 对象
Set<Method> attrMethods = MethodIntrospector.selectMethods(beanType, MODEL_ATTRIBUTE_METHODS);
if (!attrMethods.isEmpty()) {
this.modelAttributeAdviceCache.put(adviceBean, attrMethods);
}
// 扫描有 @InitBinder 注解的方法，添加到 initBinderAdviceCache 属性中
// 该类方法用于在执行方法前初始化数据绑定器
Set<Method> binderMethods = MethodIntrospector.selectMethods(beanType, INIT_BINDER_METHODS);
if (!binderMethods.isEmpty()) {
this.initBinderAdviceCache.put(adviceBean, binderMethods);
}
// 如果是 RequestBodyAdvice 或 ResponseBodyAdvice 的子类, 添加到 requestResponseBodyAdviceBeans 中
if (RequestBodyAdvice.class.isAssignableFrom(beanType)) {
requestResponseBodyAdviceBeans.add(adviceBean);
}
if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
requestResponseBodyAdviceBeans.add(adviceBean);
}
}
// 将 requestResponseBodyAdviceBeans 添加到 this.requestResponseBodyAdvice 属性
if (!requestResponseBodyAdviceBeans.isEmpty()) {
this.requestResponseBodyAdvice.addAll(0, requestResponseBodyAdviceBeans);
}
if (logger.isDebugEnabled()) {
int modelSize = this.modelAttributeAdviceCache.size();
int binderSize = this.initBinderAdviceCache.size();
int reqCount = getBodyAdviceCount(RequestBodyAdvice.class);
int resCount = getBodyAdviceCount(ResponseBodyAdvice.class);
if (modelSize == 0 && binderSize == 0 && reqCount == 0 && resCount == 0) {
logger.debug("ControllerAdvice beans: none");
}
else {
logger.debug("ControllerAdvice beans: " + modelSize + " @ModelAttribute, " + binderSize +
" @InitBinder, " + reqCount + " RequestBodyAdvice, " + resCount + ", ResponseBodyAdvice");
}
}
}
总结
@ControllerAdvice 注解：用于 Controller 类的增强类, 其中可定义多种增强的方法, 例如 @ExceptionHandler 注解的方法用于处理器 Controller 抛出的异常等
RequestMappingHandlerAdapter#handleInternal
protected ModelAndView handleInternal(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
ModelAndView mav;
// 1.请求校验
checkRequest(request);
// Execute invokeHandlerMethod in synchronized block if required.
// 2.synchronizeOnSession == false
if (this.synchronizeOnSession) {
HttpSession session = request.getSession(false);
if (session != null) {
Object mutex = WebUtils.getSessionMutex(session);
synchronized (mutex) {
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No HttpSession available -> no mutex necessary
mav = invokeHandlerMethod(request, response, handlerMethod);
}
}
else {
// No synchronization on session demanded at all...
// 3.核心方法
mav = invokeHandlerMethod(request, response, handlerMethod);
}
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
}
else {
prepareResponse(response);
}
}
return mav;
}
RequestMappingHandlerAdapter#invokeHandlerMethod
@Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
// 1.创建 ServletWebRequest 对象
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
// 2.创建 WebDataBinderFactory 对象
WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
// 3.创建 ModelFactory 对象
ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
// 4.创建 ServletInvocableHandlerMethod 对象, 并设置其相关属性
ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
if (this.argumentResolvers != null) {
invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
}
if (this.returnValueHandlers != null) {
invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
}
invocableMethod.setDataBinderFactory(binderFactory);
invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
// 5.创建 ModelAndViewContainer 对象, 并初始其相关属性
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
modelFactory.initModel(webRequest, mavContainer, invocableMethod);
mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
// 6.创建 AsyncWebRequest 异步请求对象
AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
asyncWebRequest.setTimeout(this.asyncRequestTimeout);
// 7.创建 WebAsyncManager 异步请求管理器对象
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.setTaskExecutor(this.taskExecutor);
asyncManager.setAsyncWebRequest(asyncWebRequest);
asyncManager.registerCallableInterceptors(this.callableInterceptors);
asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
if (asyncManager.hasConcurrentResult()) {
Object result = asyncManager.getConcurrentResult();
mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
asyncManager.clearConcurrentResult();
LogFormatUtils.traceDebug(logger, traceOn -> {
String formatted = LogFormatUtils.formatValue(result, !traceOn);
return "Resume with async result [" + formatted + "]";
});
invocableMethod = invocableMethod.wrapConcurrentResult(result);
}
// 8.执行, 核心方法, 见下
invocableMethod.invokeAndHandle(webRequest, mavContainer);
if (asyncManager.isConcurrentHandlingStarted()) {
return null;
}
// 9.获得 ModelAndView 对象
return getModelAndView(mavContainer, modelFactory, webRequest);
}
finally {
webRequest.requestCompleted();
}
}
5.4.2.5 ServletInvocableHandlerMethod
结构图
ServletInvocableHandlerMethod#invokeAndHandle
public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
Object... providedArgs) throws Exception {
// 1.执行方法, 调用的是其父类 InvocableHandlerMethod#invokeForRequest(见下方) 在该方法中, 会回调子类的 doInvoke 方法
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
// 2.设置响应状态码
setResponseStatus(webRequest);
// 3.设置 ModelAndViewContainer 为请求已处理, 返回, 和 @ResponseStatus 注解相关
if (returnValue == null) {
if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
mavContainer.setRequestHandled(true);
return;
}
}
else if (StringUtils.hasText(getResponseStatusReason())) {
mavContainer.setRequestHandled(true);
return;
}
// 4.设置 ModelAndViewContainer 为请求未处理
mavContainer.setRequestHandled(false);
Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
// 5.使用 HandlerMethodReturnValueHandler 处理返回值
// 这里的 returnValueHandlers 为 HandlerMethodReturnValueHandlerComposite 组合对象, 包含了许多的返回值解析器, 采用适配器设计模式, 适配到某个具体的返回值解析器;
// 如: 解析 @ResponseBody 参数, 使用的是 RequestResponseBodyMethodProcessor, 参数解析, 需要借助 HttpMessageConverter
this.returnValueHandlers.handleReturnValue(
returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
}
catch (Exception ex) {
if (logger.isTraceEnabled()) {
logger.trace(formatErrorForReturnValue(returnValue), ex);
}
throw ex;
}
}
InvocableHandlerMethod#invokeForRequest
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
// 1.解析请求参数, 见下
Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
if (logger.isTraceEnabled()) {
logger.trace("Arguments: " + Arrays.toString(args));
}
// 2.回调子类方法
return doInvoke(args);
}
InvocableHandlerMethod#getMethodArgumentValues
protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {
// 1.获取方法的参数
MethodParameter[] parameters = getMethodParameters();
// 2.将参数解析成对应的类型
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
// 获得当前遍历的 MethodParameter 对象，并设置 parameterNameDiscoverer
MethodParameter parameter = parameters[i];
parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
// 先从 providedArgs 中获得参数。如果获得到, 则进入下一个参数的解析, 默认情况 providedArgs 不会传参
args[i] = resolveProvidedArgument(parameter, providedArgs);
if (args[i] != null) {
continue;
}
// 3.判断 resolvers 是否支持当前的参数解析
// 这里的 argumentResolvers 为 HandlerMethodArgumentResolverComposite 组合对象, 包含了许多的参数解析器, 默认26个, 采用适配器设计模式, 适配到某个具体的参数解析器;
// 如: 解析 @RequestBody 参数, 使用的是 RequestResponseBodyMethodProcessor
// 解析 @RequestParam 参数, 使用的是 RequestParamMethodArgumentResolver
// 解析 @PathVariable 参数, 使用的是 PathVariableMethodArgumentResolver
if (this.argumentResolvers.supportsParameter(parameter)) {
try {
// 参数解析, 这里需要借助 HttpMessageConverter
args[i] = this.argumentResolvers.resolveArgument(
parameter, mavContainer, request, this.dataBinderFactory);
continue;
}
catch (Exception ex) {
// Leave stack trace for later, e.g. AbstractHandlerExceptionResolver
if (logger.isDebugEnabled()) {
String message = ex.getMessage();
if (message != null && !message.contains(parameter.getExecutable().toGenericString())) {
logger.debug(formatArgumentError(parameter, message));
}
}
throw ex;
}
}
if (args[i] == null) {
throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
}
}
return args;
}
5.4.3 应用
综上, 在我们最常见的 @RequestMapping 注解类型, 首先会由对应的 HandlerMapping --> RequestMappingHandlerMapping, 获取到对应的HandlerExecutionChain, HandlerExecutionChain封装了的 HandlerMethod 和 HandlerInterceptor, 再由适配器模式根据Handler(这里是HandlerMethod)获取到对应的HandlerAdapter --> RequestMappingHandlerAdapter, 由 RequestMappingHandlerAdapter 执行对应的 HandlerMethod 和 HandlerInterceptor。
具体执行过程:
RequestMappingHandlerAdapter 会先将 HandlerMethod 封装成 ServletInvocableHandlerMethod, 通过 HandlerMethodArgumentResolver 组件解析请求参数,如：通过 RequestResponseBodyMethodProcessor 解析 @RequestBody 参数等; 然后再通过反射机制调用对应的方法(controller中对应的方法), 获取到执行结果后需要通过 HandlerMethodReturnValueHandler 结果处理器来进行处理。
在 HandlerMethodArgumentResolver 解析参数和 HandlerMethodReturnValueHandler 解析返回值的过程中, 会借助 HttpMessageConverter 进行参数解析
5.5 HandlerExceptionResolver
HandlerExceptionResolver是处理器异常解析器，将处理器执行时发生的异常，解析转换成对应的ModelAndView
5.5.1 初始化
private void initHandlerExceptionResolvers(ApplicationContext context) {
this.handlerExceptionResolvers = null;
if (this.detectAllHandlerExceptionResolvers) {
// Find all HandlerExceptionResolvers in the ApplicationContext, including ancestor contexts.
Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
if (!matchingBeans.isEmpty()) {
this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
// We keep HandlerExceptionResolvers in sorted order.
AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
}
}
else {
try {
HandlerExceptionResolver her =
context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
this.handlerExceptionResolvers = Collections.singletonList(her);
}
catch (NoSuchBeanDefinitionException ex) {
// Ignore, no HandlerExceptionResolver is fine too.
}
}
// Ensure we have at least some HandlerExceptionResolvers, by registering
// default HandlerExceptionResolvers if no other resolvers are found.
if (this.handlerExceptionResolvers == null) {
this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
if (logger.isTraceEnabled()) {
logger.trace("No HandlerExceptionResolvers declared in servlet '" + getServletName() +
"': using default strategies from DispatcherServlet.properties");
}
}
}
初始化的过程和上述组件初始化过程类似，先从springmvc容器中获取相关组件并排序，如果获取失败，则获取 DispatcherServlet.properties 配置文件中的默认配置，这里默认获取3个：ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver
5.5.2 应用
DispatcherServlet#doDispatch
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
// 1.判断是否文件上传
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
// 2.使用HandlerMapping, 获取 HandlerExecutionChain, HandlerExecutionChain 是对 Handler 和 Interceptor的封装
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
// 3.根据 Handler 找到对应的 HandlerAdapter
HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
// Process last-modified header, if supported by the handler.
String method = request.getMethod();
boolean isGet = "GET".equals(method);
if (isGet || "HEAD".equals(method)) {
long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
return;
}
}
// 4.执行相关 Interceptor 的 preHandle
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
// 5.执行 Handler
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
applyDefaultViewName(processedRequest, mv);
// 6.执行相关 Interceptor 的 postHandle
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
dispatchException = ex;
}
catch (Throwable err) {
// As of 4.3, we're processing Errors thrown from handler methods as well,
// making them available for @ExceptionHandler methods and other scenarios.
dispatchException = new NestedServletException("Handler dispatch failed", err);
}
// 7.处理结果和异常
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
catch (Throwable err) {
triggerAfterCompletion(processedRequest, response, mappedHandler,
new NestedServletException("Handler processing failed", err));
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
// Instead of postHandle and afterCompletion
if (mappedHandler != null) {
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
// Clean up any resources used by a multipart request.
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
DispatcherServlet#processDispatchResult
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
boolean errorView = false;
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
logger.debug("ModelAndViewDefiningException encountered", exception);
mv = ((ModelAndViewDefiningException) exception).getModelAndView();
}
else {
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
// 处理异常
mv = processHandlerException(request, response, handler, exception);
errorView = (mv != null);
}
}
// Did the handler return a view to render?
if (mv != null && !mv.wasCleared()) {
render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No view rendering, null ModelAndView returned.");
}
}
if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
// Concurrent handling started during a forward
return;
}
if (mappedHandler != null) {
mappedHandler.triggerAfterCompletion(request, response, null);
}
}
DispatcherServlet#processHandlerException
@Nullable
protected ModelAndView processHandlerException(HttpServletRequest request, HttpServletResponse response,
@Nullable Object handler, Exception ex) throws Exception {
// Success and error responses may use different content types
request.removeAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);
// 遍历 HandlerExceptionResolver, 解析异常, 生成 ModelAndView 对象
// ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver
// ExceptionHandlerExceptionResolver 是基于 @ExceptionHandler 注解来配置对应的异常处理器
ModelAndView exMv = null;
if (this.handlerExceptionResolvers != null) {
for (HandlerExceptionResolver resolver : this.handlerExceptionResolvers) {
exMv = resolver.resolveException(request, response, handler, ex);
if (exMv != null) {
break;
}
}
}
if (exMv != null) {
if (exMv.isEmpty()) {
request.setAttribute(EXCEPTION_ATTRIBUTE, ex);
return null;
}
// We might still need view name translation for a plain error model...
if (!exMv.hasView()) {
String defaultViewName = getDefaultViewName(request);
if (defaultViewName != null) {
exMv.setViewName(defaultViewName);
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using resolved error view: " + exMv, ex);
}
if (logger.isDebugEnabled()) {
logger.debug("Using resolved error view: " + exMv);
}
WebUtils.exposeErrorRequestAttributes(request, ex, getServletName());
return exMv;
}
throw ex;
}
5.6 RequestToViewNameTranslator
5.6.1 初始化
private void initRequestToViewNameTranslator(ApplicationContext context) {
try {
this.viewNameTranslator =
context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
if (logger.isTraceEnabled()) {
logger.trace("Detected " + this.viewNameTranslator.getClass().getSimpleName());
}
else if (logger.isDebugEnabled()) {
logger.debug("Detected " + this.viewNameTranslator);
}
}
catch (NoSuchBeanDefinitionException ex) {
// We need to use the default.
this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
if (logger.isTraceEnabled()) {
logger.trace("No RequestToViewNameTranslator '" + REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME +
"': using default [" + this.viewNameTranslator.getClass().getSimpleName() + "]");
}
}
}
初始化的过程和上述组件初始化过程类似，先从springmvc容器中获取相关组件并排序，如果获取失败，则获取 DispatcherServlet.properties 配置文件中的默认配置，这里默认获取1个：DefaultRequestToViewNameTranslator
5.6.2 应用
在 DispatcherServlet #doDispatch方法中，调用了applyDefaultViewName
DispatcherServlet#applyDefaultViewName
private void applyDefaultViewName(HttpServletRequest request, @Nullable ModelAndView mv) throws Exception {
if (mv != null && !mv.hasView()) {
// 使用 DefaultRequestToViewNameTranslator 获取viewName
String defaultViewName = getDefaultViewName(request);
if (defaultViewName != null) {
mv.setViewName(defaultViewName);
}
}
}
DefaultRequestToViewNameTranslator#getViewName
public String getViewName(HttpServletRequest request) {
String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
return (this.prefix + transformPath(lookupPath) + this.suffix);
}
5.7 LocaleResolver
LocaleResolver 组件, 本地化(国际化)解析器, 提供国际化支持, 这里暂略
5.8 ViewResolver
ViewResolver 组件, 是试图解析器, 这里暂略
注解版
0.准备阶段
WebAppInitializer
public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
@Override
protected Class<?>[] getRootConfigClasses() {
return new Class[]{RootConfig.class};
}
@Override
protected Class<?>[] getServletConfigClasses() {
return new Class[]{WebConfig.class};
}
@Override
protected String[] getServletMappings() {
return new String[]{"/"};
}
}
config
// 这个是根容器, 相当于ApplicationContext.xml, 包扫描的时候要排除@Controller注解, 避免重复扫描
@ComponentScan(value ={"com.tca"},
excludeFilters={@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class})})
public class RootConfig {
}
// 这个是子容器, 相当于springmvc-config.xml, 只扫描@Controller注解, 避免重复扫描
@EnableWebMvc
@Configuration
@ComponentScan(value = {"com.tca"}, includeFilters={@ComponentScan.Filter(
type= FilterType.ANNOTATION, value={Controller.class})}, useDefaultFilters = false)
public class WebConfig {
}
controller
@RequestMapping("/hello")
@Controller
public class HelloController {
@Autowired
private HelloService helloService;
@GetMapping("/test")
@ResponseBody
public String test() {
return helloService.test();
}
}
service
@Service
public class HelloService {
public String test() {
return "test";
}
}
1.Servlet3.0
1.1 servlet3.0规范
目的
servlet3.0规范主要是用于去web.xml化, 使用纯注解的方式
实现
实现servlet3.0规范的servlet容器（如tomcat），必须实现以下规范
1.servlet容器(如tomcat)启动时会扫描当前应用里所有的jar中ServletContainerInitializer的实现类
2.当前jar中ServletContainerInitializer的实现类, 需要绑定在当前jar下resource目录下的META_INF/services/javax.servlet.ServletContainerInitializer文件, 文件里内容是ServletContainerInitializer实现类的全类名
3.自定义ServletContainerInitializer的实现上可以添加@HandlesTypes注解, 注解中可以传入一些class/interface, 这些class/interface的所有子类实现都会作为onStartup方法的参数
4.在onstart方法中, 我们可以向servlet容器中注册web三大组件: Listener(监听器), Filter(过滤器), Servlet, 完美替代了web.xml的作用
总结
容器启动时会扫描所有jar中的META_INF/services/javax.servlet.ServletContainerInitializer文件, 实例化文件中的类, 并调用onStartup方法(SPI机制)
2.springmvc注解版对servlet3.0规范的适配
2.1 实现
1.spring-web的jar中, 在 resource/META_INF/services/javax.servlet.ServletContainerInitializer 目录下, 有一个ServletContainerInitializer的实现类:
org.springframework.web.SpringServletContainerInitializer
2.SpringServletContainerInitializer配置了@HandlesTypes注解, 指定了WebApplicationInitializer接口
3.容器启动时, 会调用SpringServletContainerInitializer的onStartup方法, 方法的参数有两个: 一是WebApplicationInitializer的所有实现类对应的Class对象, 另一个是ServletContext
2.2 SpringServletContainerInitializer
SpringServletContainerInitializer上注解：@HandlesTypes(WebApplicationInitializer.class)
SpringServletContainerInitializer#onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
根据上述，servlet容器（tomcat）启动时调用ServletContainerInitializer实现类的onStartup方法
@Override
public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
throws ServletException {
List<WebApplicationInitializer> initializers = new LinkedList<>();
// 1.获取所有的 WebApplicationInitializer 接口的实现类Class对象, 这里有5个:
// AbstractContextLoaderInitializer
// AbstractDispatcherServletInitializer
// AbstractAnnotationConfigDispatcherServletInitializer
// WebAppInitializer
// AbstractReactiveWebInitializer
if (webAppInitializerClasses != null) {
for (Class<?> waiClass : webAppInitializerClasses) {
// 2.这里只有自定义的WebAppInitializer不是接口和抽象类
if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
try {
// 3.实例化 WebAppInitializer
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);
// 4.调用onStartUp方法
for (WebApplicationInitializer initializer : initializers) {
initializer.onStartup(servletContext);
}
}
2.3 WebAppInitializer
2.3.1 结构图
2.3.2 启动流程
1.调用WebAppInitializer的onStartup方法，该方法其父类AbstractDispatcherServletInitializer、AbstractContextLoaderInitializer都有实现，首先调用AbstractDispatcherServletInitializer#onStartup方法
AbstractDispatcherServletInitializer#onStartup(ServletContext servletContext)
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
// 1.先调用其父类 AbstractContextLoaderInitializer 的onStartup方法, 用于初始化父Spring容器, 添加监听器等操作
super.onStartup(servletContext);
// 2.这里创建springmvc容器, 向容器中注册DispatcherServlet, 注册Filter等
registerDispatcherServlet(servletContext);
}
AbstractDispatcherServletInitializer#registerDispatcherServlet(ServletContext servletContext)
protected void registerDispatcherServlet(ServletContext servletContext) {
// 1.获取当前servletName, 这里是dispatcher
String servletName = getServletName();
Assert.hasLength(servletName, "getServletName() must not return null or empty");
// 2.创建springmvc子容器, 这里回调用getServletConfigClasses()方法, 获取springmvc的主配置, 该方法由子类 WebAppInitializer 实现, 这里返回
// WebConfig.class
WebApplicationContext servletAppContext = createServletApplicationContext();
Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
// 3.创建DispatcherServlet
FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());
// 4.将DispatcherServlet添加到 servletContext容器中, 这里完成了web.xml文件中<servlet>-DispatcherServlet的配置
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);
// 5.这里调用 getServletMappings(), 获取DispatcherServlet拦截的请求, 该方法由子类 WebAppInitializer 实现, 这里返回 "/"
registration.addMapping(getServletMappings());
registration.setAsyncSupported(isAsyncSupported());
// 6.这里我们可以实现 getServletFilters() 方法, 向servletContext中注册 Filter
Filter[] filters = getServletFilters();
if (!ObjectUtils.isEmpty(filters)) {
for (Filter filter : filters) {
registerServletFilter(servletContext, filter);
}
}
customizeRegistration(registration);
}
AbstractContextLoaderInitializer#onStartup(ServletContext servletContext)
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
registerContextLoaderListener(servletContext);
}
AbstractContextLoaderInitializer#registerContextLoaderListener(ServletContext servletContext)
protected void registerContextLoaderListener(ServletContext servletContext) {
// 1.初始化父spring容器, 调用createRootApplicationContext()方法时, 会调用getRootConfigClasses(), 用于获取父容器的主配置类,
// getRootConfigClasses()被子类 WebAppInitializer复写, 这里返回了RootConfig.class
WebApplicationContext rootAppContext = createRootApplicationContext();
if (rootAppContext != null) {
// 2.初始化 ContextLoaderListener 监听器
ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
listener.setContextInitializers(getRootApplicationContextInitializers());
// 3.servletContext中添加监听器 ContextLoaderListener, 这里就替代了web.xml中<listener>标签作用
servletContext.addListener(listener);
}
else {
logger.debug("No ContextLoaderListener registered, as " +
"createRootApplicationContext() did not return an application context");
}
}
2.4 总结
1.spring-web的jar中, 在 resource/META_INF/services/javax.servlet.ServletContainerInitializer 目录下, 有一个ServletContainerInitializer的实现类:
org.springframework.web.SpringServletContainerInitializer
2.SpringServletContainerInitializer配置了@HandlesTypes注解, 指定了WebApplicationInitializer接口
3.容器启动时, 会调用SpringServletContainerInitializer的onStartup方法, 方法的参数有两个: 一是WebApplicationInitializer的所有实现类对应的Class对象, 另一个是ServletContext; 这里 WebApplicationInitializer的实现类只有一个: WebAppInitializer(自定义的)
4.调用其onStartup方法时会完成父spring容器的创建, 子spring容器的创建, 以及完成DispatcherServlet的创建并注册到spring容器中, 添加监听器, 过滤器等
评论