Spring 源码解析

文章15 |   阅读 8469 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析一：SpringMVC 的加载机制

x33g5p2x  于2022-02-11 发布在 Spring  
字(32.8k)|赞(0)|评价(0)|浏览(607)

1. spring-framework 包含的模块

在解析 SpringMVC 的加载机制之前，先来看看官方 spring-framework 包含有哪些模块，各有什么用。

spring-framework 官方仓库

  • spring-jcl：spring 框架的通用日志处理
  • spring-core：spring 框架的核心机制模块，包括 Java 字节码的操作处理与动态生成、依赖注入机制（也叫控制反转）、工具类库、
    注解操作、编码处理与数据转换、资源加载与处理、环境加载机制等
  • spring-beans：spring bean 的定义、加载、解析、编辑等
  • spring-context：spring 框架的上下文环境，包括应用缓存、应用事件、应用配置、核心注解定义与处理、资源加载、异步与定时任务、数据验证与格式化等
  • spring-aop：面向切面编程的封装与处理
  • spring-aspects：使用 AspectJ 作为底层实现的面向切面编程
  • spring-tx：事务的封装与处理
  • spring-jdbc：数据库链接的封装与处理
  • spring-context-indexer：对注解 @Indexed 的支持
  • spring-context-support：对一些第三方库的可选支持，如 ehcache, javamail, quartz, freemarker
  • spring-oxm：对 O/X Mapper 的封装
  • spring-messaging：对 http, rsocket, simp 等消息传递协议的封装
  • spring-jms：对 JMS(Java 消息服务) 的封装
  • spring-expression：Spring Expression Language (SpEL) Spring 表达式语言的实现
  • spring-r2dbc：对 R2DBC 的封装
  • spring-orm：对 JPA 和 hibernate 的封装
  • spring-web：提供了 Web 框架的基础结构与技术，如 Http 的调用、过滤、处理等
  • spring-webmvc：Web MVC 架构的实现，包括 Servlet 容器初始化、路由映射、视图渲染、响应处理等
  • spring-websocket：对 WebSocket 的支持
  • spring-webflux：Reactive Web 框架的实现，与 spring-webmvc 相对

SpringMVC 框架的核心模块主要是：spring-core、spring-beans、spring-context、spring-web、spring-webmvc，后面也主要从这几个模块来解析。

1.1. spring-core

spring-core 的核心功能有几点需要在这里简单介绍一下：

  1. spring-core 有强大的 Java 字节码操作处理功能与动态生成功能，这是面向切面编程、数据类型转换、SpEL 表达式等功能的基础
  2. spring-core 提供了依赖注入机制，这是 spring bean 加载的基础，也是我们可以使用 @Autowired 自动装载对象等功能的底层机制
  3. spring-core 提供了环境加载的机制，所以我们可以使用 application-dev.yml, application-test.yml, application-prod.yml, ...
    来根据环境加载不同的配置
  4. spring-core 提供了一个类似 Java SPI 的的扩展机制，可以自动实例化其他包指定的类，spring-boot, spring-cloud 都依赖这个机制自动加载资源。
    在 META-INF/spring.factories 文件中定义需要自动加载的类，详细介绍可以参考 Spring Factories

1.2. spring-beans

Spring bean 的加载与扩展机制有几点需要在这里简单介绍一下：

  1. Spring bean 的定义主要是两种：基于注解的定义、基于 XML 文件的定义
  2. spring-beans 提供了基于 XML 配置的、第三方对 bean 的命令空间扩展机制，主要是在
    META-INF/spring.handlers, META-INF/spring.schemas 文件中定义需要扩展的命令空间，
    比如 <dubbo:application name="name"/>, <dubbo:registry address="address"/>
  3. 基于注解的自定义扩展，需要依赖 spring-boot 的扩展加载机制

1.3. spring-context

spring-context 是应用的核心处理部分，包括：

  • 应用缓存
  • 应用事件
  • 应用配置
  • 核心注解定义与处理
  • 资源加载
  • 异步与定时任务
  • 数据验证与格式化

等，@ComponentScan, @Profile, @Conditional, @Bean, @Async, @Controller, @Service, @Component, @Validated 等这类框架核心注解便是在这里定义的。

1.4. spring-web

spring-web 是 Http 的核心处理部分，主要包含：

  • 核心 Http 请求与响应处理（包括 Cookie、缓存、多媒体等）
  • Http 请求与响应编解码与转换（包括 Json、XML、ProtoBuf 等）
  • Reactive Web 框架基础处理
  • 调用客户端（如 RestTemplate）
  • Servlet 上下文环境
  • 请求过滤器
  • Multipart 文件上传处理

等，@RequestMapping, @RequestParam, @PathVariable, @ResponseBody, @RestController 等这类 Web 核心注解便是在这里定义的。

1.5. spring-webmvc

spring-webmvc 依赖于 spring-web，主要功能包括：

  • Servlet 容器初始化
  • 路由映射
  • 视图渲染
  • 响应处理

等，如果不使用 Spring MVC ，但想要借助其它 Spring 支持的 web 相关技术的优势，那么只需依赖 spring-web，如 spring-webflux。

1.6. spring-webflux

spring-webflux 与 spring-webmvc 相对应，webmvc 是同步阻塞框架，而 webflux 是异步非阻塞框架，
是 Spring Framework 5.0 中引入的新的响应式 web 框架。

参考：Spring WebFlux 入门、
Spring WebFlux :: Spring Docs

2. 一个简单的 spring-webmvc 项目配置

在 WEB-INF/web.xml 文件中如下配置：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.     xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
  5.     version="3.0">
  7.   <display-name>springMVC</display-name>
  9.   <!-- 部署 DispatcherServlet -->
  10.   <servlet>
  11.     <servlet-name>springmvc</servlet-name>
  12.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  13.     <init-param>
  14.       <param-name>contextConfigLocation</param-name>
  15.       <param-value>classpath:springmvc-servlet.xml</param-value>
  16.     </init-param>
  17.     <!-- 容器再启动时立即加载servlet -->
  18.     <load-on-startup>1</load-on-startup>
  19.   </servlet>
  21.   <servlet-mapping>
  22.     <servlet-name>springmvc</servlet-name>
  23.     <!-- 处理所有URL -->
  24.     <url-pattern>/</url-pattern>
  25.   </servlet-mapping>
  27.   <!-- 定义应用程序监听器 -->
  28.   <listener>
  29.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  30.   </listener>
  31. </web-app>

这里有两个入口类：

这两个类分别定义在 spring-webmvc 与 spring-web 中，下面对他们一一进行解析。

3. DispatcherServlet

先来看看 DispatcherServlet 的继承关系：

  1. - javax.servlet.Servlet
  2.   - javax.servlet.GenericServlet
  3.     - javax.servlet.http.HttpServlet
  4.       - HttpServletBean
  5.         - FrameworkServlet
  6.           - DispatcherServlet

3.1. javax.servlet.Servlet

首先看看 javax.servlet.Servlet

javax.servlet.Servlet 主要定义了 2 个方法：

  • init：初始化 Servlet，只执行一次
  • service：响应请求，每次 http 请求都会调用这个方法
  1. public interface Servlet {
  2.     // 初始化 Servlet，只执行一次
  3.     public void init(ServletConfig config) throws ServletException;
  5.     // 响应请求，每次http请求都会调用这个方法
  6.     public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
  8.     // 销毁 Servlet
  9.     public void destroy();
  10. }

3.2. javax.servlet.GenericServlet

再来看看 javax.servlet.GenericServlet

javax.servlet.GenericServlet 主要是重载了 init 方法

  1. public abstract class GenericServlet implements Servlet, ServletConfig, java.io.Serializable {
  2.     public GenericServlet() {}
  4.     // 添加配置初始化
  5.     public void init(ServletConfig config) throws ServletException {
  6.         this.config = config;
  7.         this.init();
  8.     }
  10.     // 保留无参初始化
  11.     public void init() throws ServletException {}
  13.     // 留给子类实现
  14.     public abstract void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;
  15. }

3.3. javax.servlet.http.HttpServlet

再来看看 javax.servlet.http.HttpServlet

javax.servlet.http.HttpServlet 主要是重载了 service 方法，并扩展了 7 个方法：

  • doGet：处理 GET 请求，只输入错误信息，未实现
  • doHead：处理 HEAD 请求，只输入错误信息，未实现
  • doPost：处理 POST 请求，只输入错误信息，未实现
  • doPut：处理 PUT 请求，只输入错误信息，未实现
  • doDelete：处理 DELETE 请求，只输入错误信息，未实现
  • doOptions：处理 OPTIONS 请求
  • doTrace：处理 TRACE 请求
  1. public abstract class HttpServlet extends GenericServlet {
  2.     private static final String METHOD_DELETE = "DELETE";
  3.     private static final String METHOD_HEAD = "HEAD";
  4.     private static final String METHOD_GET = "GET";
  5.     private static final String METHOD_OPTIONS = "OPTIONS";
  6.     private static final String METHOD_POST = "POST";
  7.     private static final String METHOD_PUT = "PUT";
  8.     private static final String METHOD_TRACE = "TRACE";
  10.     protected void doGet(HttpServletRequest req, HttpServletResponse resp)
  11.         throws ServletException, IOException
  12.     {
  13.         String protocol = req.getProtocol();
  14.         String msg = lStrings.getString("http.method_get_not_supported");
  15.         if (protocol.endsWith("1.1")) {
  16.             resp.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, msg);
  17.         } else {
  18.             resp.sendError(HttpServletResponse.SC_BAD_REQUEST, msg);
  19.         }
  20.     }
  22.     protected void doHead(HttpServletRequest req, HttpServletResponse resp)
  23.         throws ServletException, IOException
  24.     {
  25.         NoBodyResponse response = new NoBodyResponse(resp);
  26.         // 调用 doGet，但body设为空body
  27.         doGet(req, response);
  28.         response.setContentLength();
  29.     }
  31.     protected void doPost(HttpServletRequest req, HttpServletResponse resp)
  32.         throws ServletException, IOException
  33.     {
  34.         // ... 代码省略
  35.     }
  37.     protected void doPut(HttpServletRequest req, HttpServletResponse resp)
  38.         throws ServletException, IOException
  39.     {
  40.         // ... 代码省略
  41.     }
  43.     protected void doDelete(HttpServletRequest req, HttpServletResponse resp)
  44.         throws ServletException, IOException
  45.     {
  46.         // ... 代码省略
  47.     }
  49.     protected void doOptions(HttpServletRequest req, HttpServletResponse resp)
  50.         throws ServletException, IOException
  51.     {
  52.         // ... 代码省略
  53.     }
  55.     protected void doTrace(HttpServletRequest req, HttpServletResponse resp)
  56.         throws ServletException, IOException
  57.     {
  58.         // ... 代码省略
  59.     }
  61.     // 实现了GET, HEAD, POST PUT, DELETE, OPTIONS, TRACE七个Http方法
  62.     protected void service(HttpServletRequest req, HttpServletResponse resp)
  63.         throws ServletException, IOException
  64.     {
  65.         String method = req.getMethod();
  67.         if (method.equals(METHOD_GET)) {
  68.             // ... 代码省略
  69.             doGet(req, resp);
  70.             // ... 代码省略
  71.         } else if (method.equals(METHOD_HEAD)) {
  72.             long lastModified = getLastModified(req);
  73.             maybeSetLastModified(resp, lastModified);
  74.             doHead(req, resp);
  75.         } else if (method.equals(METHOD_POST)) {
  76.             doPost(req, resp);
  77.         } else if (method.equals(METHOD_PUT)) {
  78.             doPut(req, resp);
  79.         } else if (method.equals(METHOD_DELETE)) {
  80.             doDelete(req, resp);
  81.         } else if (method.equals(METHOD_OPTIONS)) {
  82.             doOptions(req,resp);
  83.         } else if (method.equals(METHOD_TRACE)) {
  84.             doTrace(req,resp);
  85.         } else {
  86.             String errMsg = lStrings.getString("http.method_not_implemented");
  87.             Object[] errArgs = new Object[1];
  88.             errArgs[0] = method;
  89.             errMsg = MessageFormat.format(errMsg, errArgs);
  91.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
  92.         }
  93.     }
  95.     // 把 Servlet 转化为 HttpServlet
  96.     @Override
  97.     public void service(ServletRequest req, ServletResponse res)
  98.         throws ServletException, IOException
  99.     {
  100.         HttpServletRequest  request;
  101.         HttpServletResponse response;
  103.         if (!(req instanceof HttpServletRequest &&
  104.                 res instanceof HttpServletResponse)) {
  105.             throw new ServletException("non-HTTP request or response");
  106.         }
  108.         request = (HttpServletRequest) req;
  109.         response = (HttpServletResponse) res;
  111.         service(request, response);
  112.     }
  113. }

3.4. HttpServletBean

再来看看 HttpServletBean

HttpServletBean 主要是重载了 init 方法，并扩展了 2 个方法：

  • initBeanWrapper：初始化由 Servlet Config 定义的 Java Bean，由子类实现，默认不实现
  • initServletBean：初始化 Servlet bean，由子类实现
  1. public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
  2.     // 初始化
  3.     @Override
  4.     public final void init() throws ServletException {
  5.         // 把Servlet配置参数设置到bean属性中
  6.         PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
  7.         if (!pvs.isEmpty()) {
  8.             try {
  9.                 BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
  10.                 ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
  11.                 bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
  12.                 initBeanWrapper(bw);
  13.                 bw.setPropertyValues(pvs, true);
  14.             }
  15.             catch (BeansException ex) {
  16.                 if (logger.isErrorEnabled()) {
  17.                     logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
  18.                 }
  19.                 throw ex;
  20.             }
  21.         }
  23.         // 初始化Servlet bean
  24.         initServletBean();
  25.     }
  27.     // 初始化由Servlet Config定义的Java Bean，由子类实现，默认不实现
  28.     protected void initBeanWrapper(BeanWrapper bw) throws BeansException {
  29.     }
  31.     // 初始化Servlet bean，由子类实现
  32.     protected void initServletBean() throws ServletException {
  33.     }
  34. }

3.5. FrameworkServlet

再来看看 FrameworkServlet

FrameworkServlet 是框架的核心 Servlet，主要是重载了 initServletBean 方法，并扩展了 2 个方法：

  • initFrameworkServlet：初始化框架 Servlet，由子类实现，默认不实现
  • onRefresh：刷新上下文数据，由子类实现

重载了 service, doGet, doPost, doPut, doDelete, doOptions, doTrace 方法，并扩展了 1 个方法：

  • doService：处理响应请求

3.5.1. FrameworkServlet.initServletBean

父类 HttpServletBean 初始化后，留下两个钩子 initBeanWrapper, initServletBean，initBeanWrapper 默认并不实现，
所以来看看 initServletBean 钩子的实现：FrameworkServlet.initServletBean

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     @Override
  3.     protected final void initServletBean() throws ServletException {
  4.         // ... 代码省略
  6.         try {
  7.             // 初始化Web应用上下文
  8.             this.webApplicationContext = initWebApplicationContext();
  9.             // 初始化Web框架Servlet
  10.             initFrameworkServlet();
  11.         }
  12.         catch (ServletException | RuntimeException ex) {
  13.             logger.error("Context initialization failed", ex);
  14.             throw ex;
  15.         }
  17.         // ... 代码省略
  18.     }
  20.     // 初始化框架Servlet，由子类实现，默认不实现
  21.     protected void initFrameworkServlet() throws ServletException {}
  22. }

再来看看 FrameworkServlet.initWebApplicationContext

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     protected WebApplicationContext initWebApplicationContext() {
  3.         // 获取应用根上下文
  4.         WebApplicationContext rootContext =
  5.                 WebApplicationContextUtils.getWebApplicationContext(getServletContext());
  6.         WebApplicationContext wac = null;
  8.         if (this.webApplicationContext != null) {
  9.             // 对webApplicationContext进行配置
  10.             wac = this.webApplicationContext;
  11.             if (wac instanceof ConfigurableWebApplicationContext) {
  12.                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
  13.                 // 未激活
  14.                 if (!cwac.isActive()) {
  15.                     if (cwac.getParent() == null) {
  16.                         cwac.setParent(rootContext);
  17.                     }
  18.                     // 配置并刷新应用上下文
  19.                     configureAndRefreshWebApplicationContext(cwac);
  20.                 }
  21.             }
  22.         }
  23.         if (wac == null) {
  24.             // 如果没有，则在ServletContext中查找是否注册过
  25.             wac = findWebApplicationContext();
  26.         }
  27.         if (wac == null) {
  28.             // 如果任然没有，则以rootContext为父上下文创建一个新的上下文
  29.             // 并调用 configureAndRefreshWebApplicationContext(cwac) 配置并刷新新的上下文
  30.             // 默认使用 XmlWebApplicationContext（基于XML加载）作为应用上下文
  31.             wac = createWebApplicationContext(rootContext);
  32.         }
  34.         if (!this.refreshEventReceived) {
  35.             // 重载上下文数据
  36.             synchronized (this.onRefreshMonitor) {
  37.                 onRefresh(wac);
  38.             }
  39.         }
  41.         if (this.publishContext) {
  42.             // 把上下文注册到ServletContext中
  43.             String attrName = getServletContextAttributeName();
  44.             getServletContext().setAttribute(attrName, wac);
  45.         }
  47.         return wac;
  48.     }
  51.     // 以parent为父上下文创建一个新的上下文
  52.     // 并调用 configureAndRefreshWebApplicationContext(cwac) 配置并刷新新的上下文
  53.     // 默认使用 XmlWebApplicationContext（基于XML加载）作为应用上下文
  54.     protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
  55.         // 这里默认使用 XmlWebApplicationContext（基于XML加载）
  56.         Class<?> contextClass = getContextClass();
  57.         ConfigurableWebApplicationContext wac =
  58.                 (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
  60.         wac.setEnvironment(getEnvironment());
  61.         wac.setParent(parent);
  62.         String configLocation = getContextConfigLocation();
  63.         if (configLocation != null) {
  64.             wac.setConfigLocation(configLocation);
  65.         }
  66.         configureAndRefreshWebApplicationContext(wac);
  68.         return wac;
  69.     }
  70. }

这其中有两个方法需要深入解析：configureAndRefreshWebApplicationContext, onRefresh

再来看看 FrameworkServlet.configureAndRefreshWebApplicationContext

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
  3.         // ... 代码省略
  5.         // 设置ServletContext
  6.         wac.setServletContext(getServletContext());
  7.         // 设置ServletConfig
  8.         wac.setServletConfig(getServletConfig());
  9.         wac.setNamespace(getNamespace());
  10.         // 添加应用事件监听器，应用事件会触发当前对象的onApplicationEvent方法
  11.         // 进一步，会调用当前对象的onRefresh方法，刷新上下文数据
  12.         wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
  14.         // ... 代码省略
  16.         // 初始化一些需要初始加载的类，调用这些类的initialize方法
  17.         applyInitializers(wac);
  18.         // 应用上下文刷新
  19.         wac.refresh();
  20.     }
  22.     // 应用事件会触发此方法，然后调用当前对象的onRefresh方法，刷新上下文数据
  23.     public void onApplicationEvent(ContextRefreshedEvent event) {
  24.         this.refreshEventReceived = true;
  25.         synchronized (this.onRefreshMonitor) {
  26.             onRefresh(event.getApplicationContext());
  27.         }
  28.     }
  29. }

再来看看 FrameworkServlet.onRefresh

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     protected void onRefresh(ApplicationContext context) {
  3.         // 由子类来实现
  4.     }
  5. }

3.5.2. FrameworkServlet.service

再来看看 FrameworkServlet.service

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     @Override
  3.     protected void service(HttpServletRequest request, HttpServletResponse response)
  4.             throws ServletException, IOException {
  6.         HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
  7.         // 如果Http方法是Patch或没有，扩展处理
  8.         if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
  9.             processRequest(request, response);
  10.         }
  11.         else {
  12.             super.service(request, response);
  13.         }
  14.     }
  16.     @Override
  17.     protected final void doGet(HttpServletRequest request, HttpServletResponse response)
  18.             throws ServletException, IOException {
  19.         // 扩展处理
  20.         processRequest(request, response);
  21.     }
  23.     @Override
  24.     protected final void doPost(HttpServletRequest request, HttpServletResponse response)
  25.             throws ServletException, IOException {
  26.         // 扩展处理
  27.         processRequest(request, response);
  28.     }
  30.     @Override
  31.     protected final void doPut(HttpServletRequest request, HttpServletResponse response)
  32.             throws ServletException, IOException {
  33.         // 扩展处理
  34.         processRequest(request, response);
  35.     }
  37.     @Override
  38.     protected final void doDelete(HttpServletRequest request, HttpServletResponse response)
  39.             throws ServletException, IOException {
  40.         // 扩展处理
  41.         processRequest(request, response);
  42.     }
  44.     @Override
  45.     protected void doOptions(HttpServletRequest request, HttpServletResponse response)
  46.             throws ServletException, IOException {
  48.         if (this.dispatchOptionsRequest || CorsUtils.isPreFlightRequest(request)) {
  49.             // 扩展处理
  50.             processRequest(request, response);
  51.             if (response.containsHeader("Allow")) {
  52.                 return;
  53.             }
  54.         }
  56.         // ... 代码省略
  57.     }
  59.     @Override
  60.     protected void doTrace(HttpServletRequest request, HttpServletResponse response)
  61.             throws ServletException, IOException {
  63.         if (this.dispatchTraceRequest) {
  64.             // 扩展处理
  65.             processRequest(request, response);
  66.             if ("message/http".equals(response.getContentType())) {
  67.                 return;
  68.             }
  69.         }
  70.         super.doTrace(request, response);
  71.     }
  72. }

再来看看扩展处理方法 FrameworkServlet.processRequest

  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
  3.             throws ServletException, IOException {
  5.         // ... 代码省略
  7.         // 记录请求属性与上下文环境，请求处理完后派发事件
  8.         LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
  9.         LocaleContext localeContext = buildLocaleContext(request);
  11.         RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
  12.         ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
  14.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  15.         asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
  17.         initContextHolders(request, localeContext, requestAttributes);
  19.         try {
  20.             doService(request, response);
  21.         }
  22.         // ... 代码省略
  24.         finally {
  25.             resetContextHolders(request, previousLocaleContext, previousAttributes);
  26.             if (requestAttributes != null) {
  27.                 requestAttributes.requestCompleted();
  28.             }
  29.             logResult(request, response, failureCause, asyncManager);
  30.             publishRequestHandledEvent(request, response, startTime, failureCause);
  31.         }
  32.     }
  34.     // 由子类来实现
  35.     protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
  36.             throws Exception;
  37. }

3.6. DispatcherServlet

DispatcherServlet 主要扩展了 2 个方法：onRefresh、doService，所以来看看 DispatcherServlet
是如何实现的

3.6.1. DispatcherServlet.onRefresh

DispatcherServlet.onRefresh

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     @Override
  3.     protected void onRefresh(ApplicationContext context) {
  4.         initStrategies(context);
  5.     }
  7.     protected void initStrategies(ApplicationContext context) {
  8.         // 初始化Multipart文件上传处理
  9.         initMultipartResolver(context);
  10.         // 初始化本地化处理
  11.         initLocaleResolver(context);
  12.         // 初始化主题处理
  13.         initThemeResolver(context);
  14.         // 初始化处理器映射
  15.         initHandlerMappings(context);
  16.         // 初始化处理器适配
  17.         initHandlerAdapters(context);
  18.         // 初始化处理器异常
  19.         initHandlerExceptionResolvers(context);
  20.         // 初始化视图查找处理
  21.         initRequestToViewNameTranslator(context);
  22.         // 初始化视图解析处理
  23.         initViewResolvers(context);
  24.         // 初始化内存暂存session数据管理器
  25.         initFlashMapManager(context);
  26.     }
  28.     private void initMultipartResolver(ApplicationContext context) {
  29.         try {
  30.             // 获取bean
  31.             this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
  33.             // ... 代码省略
  34.         }
  35.         catch (NoSuchBeanDefinitionException ex) {
  36.             // ... 代码省略
  37.         }
  38.     }
  40.     private void initLocaleResolver(ApplicationContext context) {
  41.         try {
  42.             // 获取bean
  43.             this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);
  45.             // ... 代码省略
  46.         }
  47.         catch (NoSuchBeanDefinitionException ex) {
  48.             // ... 代码省略
  49.         }
  50.     }
  52.     private void initThemeResolver(ApplicationContext context) {
  53.         try {
  54.             // 获取bean
  55.             this.themeResolver = context.getBean(THEME_RESOLVER_BEAN_NAME, ThemeResolver.class);
  57.             // ... 代码省略
  58.         }
  59.         catch (NoSuchBeanDefinitionException ex) {
  60.             // ... 代码省略
  61.         }
  62.     }
  64.     private void initFlashMapManager(ApplicationContext context) {
  65.         try {
  66.             // 获取bean
  67.             this.flashMapManager = context.getBean(FLASH_MAP_MANAGER_BEAN_NAME, FlashMapManager.class);
  68.         }
  69.         catch (NoSuchBeanDefinitionException ex) {
  70.             // 没有bean，则获取默认策略
  71.             this.flashMapManager = getDefaultStrategy(context, FlashMapManager.class);
  72.         }
  73.     }
  74. }
3.6.1.1. DispatcherServlet.initHandlerMappings

DispatcherServlet.initHandlerMappings

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     private void initHandlerMappings(ApplicationContext context) {
  3.         this.handlerMappings = null;
  5.         // 默认是探测所有的HandlerMapping，包括父上下文
  6.         if (this.detectAllHandlerMappings) {
  7.             Map<String, HandlerMapping> matchingBeans =
  8.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
  9.             if (!matchingBeans.isEmpty()) {
  10.                 this.handlerMappings = new ArrayList<>(matchingBeans.values());
  11.                 AnnotationAwareOrderComparator.sort(this.handlerMappings);
  12.             }
  13.         }
  14.         else {
  15.             // 否则直接获取bean
  16.             try {
  17.                 HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
  18.                 this.handlerMappings = Collections.singletonList(hm);
  19.             }
  20.             catch (NoSuchBeanDefinitionException ex) {}
  21.         }
  23.         // 如果以上两种都没有定义，则获取默认的处理策略
  24.         if (this.handlerMappings == null) {
  25.             this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
  26.         }
  28.         // ... 代码省略
  29.     }
  31.     // 获取默认的处理策略
  32.     protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
  33.         // 尝试从DispatcherServlet.properties文件中加载
  34.         if (defaultStrategies == null) {
  35.             try {
  36.                 ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
  37.                 defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
  38.             }
  39.             catch (IOException ex) {
  40.                 throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
  41.             }
  42.         }
  44.         String key = strategyInterface.getName();
  45.         String value = defaultStrategies.getProperty(key);
  46.         if (value != null) {
  47.             String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
  48.             List<T> strategies = new ArrayList<>(classNames.length);
  49.             for (String className : classNames) {
  50.                 try {
  51.                     Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
  52.                     // 创建bean
  53.                     Object strategy = createDefaultStrategy(context, clazz);
  54.                     // 装载到 strategies 中
  55.                     strategies.add((T) strategy);
  56.                 }
  57.                 catch (ClassNotFoundException ex) {
  58.                     // ... 代码省略
  59.                 }
  60.                 catch (LinkageError err) {
  61.                     // ... 代码省略
  62.                 }
  63.             }
  64.             return strategies;
  65.         }
  66.         else {
  67.             return Collections.emptyList();
  68.         }
  69.     }
  71.     // 创建bean
  72.     protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {
  73.         return context.getAutowireCapableBeanFactory().createBean(clazz);
  74.     }
  75. }

DispatcherServlet.properties
文件（开发者不能自定义覆盖）如下：

  1. org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver
  3. org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver
  5. org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
  6.     org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
  7.     org.springframework.web.servlet.function.support.RouterFunctionMapping
  9. org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
  10.     org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
  11.     org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
  12.     org.springframework.web.servlet.function.support.HandlerFunctionAdapter
  15. org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
  16.     org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
  17.     org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver
  19. org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator
  21. org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver
  23. org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

DispatcherServlet.properties 文件中指明：

3.6.1.2. DispatcherServlet.initHandlerAdapters

DispatcherServlet.initHandlerAdapters

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     private void initHandlerAdapters(ApplicationContext context) {
  3.         this.handlerAdapters = null;
  5.         // 默认是探测所有的HandlerAdapter，包括父上下文
  6.         if (this.detectAllHandlerAdapters) {
  7.             Map<String, HandlerAdapter> matchingBeans =
  8.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
  9.             if (!matchingBeans.isEmpty()) {
  10.                 this.handlerAdapters = new ArrayList<>(matchingBeans.values());
  11.                 AnnotationAwareOrderComparator.sort(this.handlerAdapters);
  12.             }
  13.         }
  14.         else {
  15.             // 否则直接获取bean
  16.             try {
  17.                 HandlerAdapter ha = context.getBean(HANDLER_ADAPTER_BEAN_NAME, HandlerAdapter.class);
  18.                 this.handlerAdapters = Collections.singletonList(ha);
  19.             }
  20.             catch (NoSuchBeanDefinitionException ex) {}
  21.         }
  23.         // 如果以上两种都没有定义，则获取默认的处理策略
  24.         if (this.handlerAdapters == null) {
  25.             this.handlerAdapters = getDefaultStrategies(context, HandlerAdapter.class);
  26.         }
  27.     }
  28. }
3.6.1.3. DispatcherServlet.initHandlerExceptionResolvers

DispatcherServlet.initHandlerExceptionResolvers

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     private void initHandlerExceptionResolvers(ApplicationContext context) {
  3.         this.handlerExceptionResolvers = null;
  5.         // 默认是探测所有的HandlerExceptionResolver，包括父上下文
  6.         if (this.detectAllHandlerExceptionResolvers) {
  7.             Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils
  8.                     .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
  9.             if (!matchingBeans.isEmpty()) {
  10.                 this.handlerExceptionResolvers = new ArrayList<>(matchingBeans.values());
  11.                 AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
  12.             }
  13.         }
  14.         else {
  15.             // 否则直接获取bean
  16.             try {
  17.                 HandlerExceptionResolver her =
  18.                         context.getBean(HANDLER_EXCEPTION_RESOLVER_BEAN_NAME, HandlerExceptionResolver.class);
  19.                 this.handlerExceptionResolvers = Collections.singletonList(her);
  20.             }
  21.             catch (NoSuchBeanDefinitionException ex) {}
  22.         }
  24.         // 如果以上两种都没有定义，则获取默认的处理策略
  25.         if (this.handlerExceptionResolvers == null) {
  26.             this.handlerExceptionResolvers = getDefaultStrategies(context, HandlerExceptionResolver.class);
  27.         }
  28.     }
  29. }
3.6.1.4. DispatcherServlet.initRequestToViewNameTranslator

DispatcherServlet.initRequestToViewNameTranslator

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     private void initRequestToViewNameTranslator(ApplicationContext context) {
  3.         try {
  4.             // 获取bean
  5.             this.viewNameTranslator =
  6.                     context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);
  7.         }
  8.         catch (NoSuchBeanDefinitionException ex) {
  9.             // 如果没有定义bean，则获取默认的处理策略
  10.             this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);
  11.         }
  12.     }
  13. }
3.6.1.5. DispatcherServlet.initViewResolvers

DispatcherServlet.initViewResolvers

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     private void initViewResolvers(ApplicationContext context) {
  3.         this.viewResolvers = null;
  5.         // 默认是探测所有的ViewResolver，包括父上下文
  6.         if (this.detectAllViewResolvers) {
  7.             Map<String, ViewResolver> matchingBeans =
  8.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, ViewResolver.class, true, false);
  9.             if (!matchingBeans.isEmpty()) {
  10.                 this.viewResolvers = new ArrayList<>(matchingBeans.values());
  11.                 AnnotationAwareOrderComparator.sort(this.viewResolvers);
  12.             }
  13.         }
  14.         else {
  15.             // 否则直接获取bean
  16.             try {
  17.                 ViewResolver vr = context.getBean(VIEW_RESOLVER_BEAN_NAME, ViewResolver.class);
  18.                 this.viewResolvers = Collections.singletonList(vr);
  19.             }
  20.             catch (NoSuchBeanDefinitionException ex) {}
  21.         }
  23.         // 如果以上两种都没有定义，则获取默认的处理策略
  24.         if (this.viewResolvers == null) {
  25.             this.viewResolvers = getDefaultStrategies(context, ViewResolver.class);
  26.         }
  27.     }
  28. }

3.6.2. DispatcherServlet.doService

刚刚解析完了 DispatcherServlet.onRefresh，现在来看看 DispatcherServlet.doService

  1. public class DispatcherServlet extends FrameworkServlet {
  2.     @Override
  3.     protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
  4.         // ... 代码省略
  6.         // 给请求对象添加一些上下文数据
  7.         request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
  8.         request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
  9.         request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
  10.         request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
  12.         // ... 代码省略
  14.         try {
  15.             doDispatch(request, response);
  16.         }
  17.         finally {
  18.             // ... 代码省略
  19.         }
  20.     }
  22.     protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  23.         HttpServletRequest processedRequest = request;
  24.         // 处理器链
  25.         HandlerExecutionChain mappedHandler = null;
  26.         // 是Multipart文件上传
  27.         boolean multipartRequestParsed = false;
  28.         // 异步处理管理器
  29.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  31.         try {
  32.             ModelAndView mv = null;
  33.             Exception dispatchException = null;
  35.             try {
  36.                 // 检测Multipart文件上传
  37.                 processedRequest = checkMultipart(request);
  38.                 multipartRequestParsed = (processedRequest != request);
  40.                 // 获取处理器，从handlerMappings中查找符合请求的处理器
  41.                 mappedHandler = getHandler(processedRequest);
  42.                 if (mappedHandler == null) {
  43.                     // 未找到处理器，404
  44.                     noHandlerFound(processedRequest, response);
  45.                     return;
  46.                 }
  48.                 // 获取处理器适配器，从handlerAdapters中查找符合处理器的适配器
  49.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  51.                 String method = request.getMethod();
  53.                 // 如果是GET或HEAD请求，检查Last-Modified
  54.                 boolean isGet = "GET".equals(method);
  55.                 if (isGet || "HEAD".equals(method)) {
  56.                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  57.                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  58.                         return;
  59.                     }
  60.                 }
  62.                 // 前置处理，调用处理器的preHandle方法，如果有一个不成功，返回
  63.                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  64.                     return;
  65.                 }
  67.                 // 调用处理器
  68.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  70.                 // ... 代码省略
  72.                 // 如果没有视图名字，添加默认的视图名
  73.                 applyDefaultViewName(processedRequest, mv);
  74.                 // 后置处理，调用处理器的postHandle方法
  75.                 mappedHandler.applyPostHandle(processedRequest, response, mv);
  76.             }
  77.             catch (Exception ex) {
  78.                 // ... 代码省略
  79.             }
  80.             catch (Throwable err) {
  81.                 // ... 代码省略
  82.             }
  84.             // 处理handler返回的结果
  85.             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  86.         }
  87.         catch (Exception ex) {
  88.             // ... 代码省略
  89.         }
  90.         catch (Throwable err) {
  91.             // ... 代码省略
  92.         }
  93.         finally {
  94.             // ... 代码省略
  95.         }
  96.     }
  98.     // 处理handler返回的结果
  99.     private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
  100.             @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
  101.             @Nullable Exception exception) throws Exception {
  103.         boolean errorView = false;
  105.         if (exception != null) {
  106.             // ... 代码省略，如果有异常，调用handlerExceptionResolvers处理
  107.         }
  109.         if (mv != null && !mv.wasCleared()) {
  110.             // 渲染视图
  111.             render(mv, request, response);
  112.             if (errorView) {
  113.                 WebUtils.clearErrorRequestAttributes(request);
  114.             }
  115.         }
  116.         // ... 代码省略
  117.     }
  119.     // 渲染视图
  120.     protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
  121.         // ... 代码省略
  123.         View view;
  124.         String viewName = mv.getViewName();
  125.         if (viewName != null) {
  126.             // 调用viewResolvers来解析视图
  127.             view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
  128.             // ... 代码省略
  129.         }
  130.         else {
  131.             // ... 代码省略
  132.         }
  134.         // ... 代码省略
  135.         try {
  136.             if (mv.getStatus() != null) {
  137.                 // 设置http状态码
  138.                 response.setStatus(mv.getStatus().value());
  139.             }
  140.             // 真实渲染
  141.             view.render(mv.getModelInternal(), request, response);
  142.         }
  143.         catch (Exception ex) {
  144.             // ... 代码省略
  145.         }
  146.     }
  147. }

3.6.3. 需要后面再解析的几个点

DispatcherServlet 这个类的解析基本上就差不多了，但还有几点没有解析：

这几点，我们后面再来解析。

4. ContextLoaderListener

先来看看 ContextLoaderListener 的继承关系：

  1. - ContextLoader
  2.   - ContextLoaderListener

ContextLoaderListener
比较简单，只有两个监听事件方法

  1. public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
  2.     @Override
  3.     public void contextInitialized(ServletContextEvent event) {
  4.         // ContextLoader.initWebApplicationContext
  5.         initWebApplicationContext(event.getServletContext());
  6.     }
  8.     @Override
  9.     public void contextDestroyed(ServletContextEvent event) {
  10.         // ContextLoader.closeWebApplicationContext
  11.         closeWebApplicationContext(event.getServletContext());
  12.         // 销毁上下文中以"org.springframework."开头的可销毁bean
  13.         ContextCleanupListener.cleanupAttributes(event.getServletContext());
  14.     }
  15. }

ContextLoader
的静态初始化

  1. public class ContextLoader {
  2.     static {
  3.         try {
  4.             // 从ContextLoader.properties文件中加载默认的策略
  5.             ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
  6.             defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
  7.         }
  8.         catch (IOException ex) {
  9.             throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
  10.         }
  11.     }
  12. }

ContextLoader.properties
文件的内容如下：

  1. # Default WebApplicationContext implementation class for ContextLoader.
  2. # Used as fallback when no explicit context implementation has been specified as context-param.
  3. # Not meant to be customized by application developers.
  5. org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext

ContextLoader.properties 文件中指明使用 XmlWebApplicationContext 作为默认的 Web 应用上下文环境

再来看看 ContextLoader
的 initWebApplicationContext 和 closeWebApplicationContext

4.1. ContextLoaderListener.initWebApplicationContext

ContextLoaderListener.initWebApplicationContext

  1. public class ContextLoader {
  2.     public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
  3.         // ... 代码省略
  5.         try {
  6.             // 如果没有上下文对象，则创建一个新的上下文
  7.             // 并调用 configureAndRefreshWebApplicationContext(cwac) 配置并刷新新的上下文
  8.             // 默认使用 XmlWebApplicationContext（基于XML加载）作为应用上下文
  9.             if (this.context == null) {
  10.                 this.context = createWebApplicationContext(servletContext);
  11.             }
  12.             if (this.context instanceof ConfigurableWebApplicationContext) {
  13.                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
  14.                 // 未激活
  15.                 if (!cwac.isActive()) {
  16.                     if (cwac.getParent() == null) {
  17.                         ApplicationContext parent = loadParentContext(servletContext);
  18.                         cwac.setParent(parent);
  19.                     }
  20.                     // 配置并刷新应用上下文
  21.                     configureAndRefreshWebApplicationContext(cwac, servletContext);
  22.                 }
  23.             }
  25.             // 把上下文注册到ServletContext中
  26.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
  28.             // ... 代码省略
  30.             return this.context;
  31.         }
  32.         catch (RuntimeException | Error ex) {
  33.             // ... 代码省略
  34.         }
  35.     }
  36. }

ContextLoader.configureAndRefreshWebApplicationContext 与 FrameworkServlet.configureAndRefreshWebApplicationContext
的处理基本上一致。

也就是说，当容器启动（如 Tomcat、Jetty、Undertow 等）时，Spring 框架会自动进行初始化。

4.2. ContextLoaderListener.closeWebApplicationContext

ContextLoaderListener.closeWebApplicationContext

  1. public class ContextLoader {
  2.     public void closeWebApplicationContext(ServletContext servletContext) {
  3.         try {
  4.             if (this.context instanceof ConfigurableWebApplicationContext) {
  5.                 // 调用上下文对象的close方法
  6.                 ((ConfigurableWebApplicationContext) this.context).close();
  7.             }
  8.         }
  9.         finally {
  10.             // ... 代码省略
  11.         }
  12.     }
  13. }

5. 综述

DispatcherServlet.init 与 ContextLoaderListener.contextInitialized 都会进行应用上下文的初始化，主要过程是：

  1. 初始化 Web 应用上下文，默认使用 XmlWebApplicationContext（基于 XML 加载）作为应用上下文，并调用 refresh 方法
  2. 实例化由 globalInitializerClasses 和 contextInitializerClasses 定义的类
  3. 实例化 WebMVC 必要的组件：MultipartResolver, LocaleResolver, ThemeResolver, HandlerMapping,
    HandlerAdapter, HandlerExceptionResolver, RequestToViewNameTranslator, ViewResolver, FlashMapManager

每个请求都会进入到 DispatcherServlet.service，其主要过程是：

  1. 初始化请求对象，以便应用后续处理
  2. 处理 Multipart 文件上传，获取处理器处理当前请求
  3. 如果当前请求处理发生异常，进行异常处理
  4. 进行视图渲染

6. 未完

到这里为止，解析仅仅止于 DispatcherServlet 与 ContextLoaderListener 两个类，下一篇将深入其他类，继续探索。

  • ConfigurableWebApplicationContext.refresh 刷新上下文
  • ApplicationContext.getBean 从上下文中获取 bean
  • DispatcherServlet.properties 文件中定义的策略处理
  • ContextLoader.properties 文件中定义的策略处理
  • View.render 视图渲染

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com