Spring MVC上下文容器在Web容器中是如何启动的（源码深入剖析）？

在Java Web开发中，理解Spring MVC如何与Tomcat等Web容器协同工作是掌握企业级应用开发的关键。本文将深入解析Spring MVC容器在Web容器中的启动过程，揭示父子容器协作的奥秘。

在上一篇中详细介绍了 Spring IOC容器在web容器中的启动过程，这篇进一步了解下Spring MVC容器（即 Web 应用上下文）是如何在web容器（如 Tomcat、Jetty）中启动并生效的。在 Spring MVC 中，MVC 容器（即 DispatcherServlet 的 Web 应用上下文）的初始化过程是一个精密的协作机制。以下是详细的启动流程和关键代码调用：

一、双容器架构：MVC容器与根容器的关系

Spring MVC采用父子容器设计，实现业务层与Web层的关注点分离：

• 根容器：由ContextLoaderListener创建，管理业务层和数据层Bean
• MVC容器：由DispatcherServlet创建，管理Web层组件
• 依赖规则：子容器可访问父容器的Bean，反之则不行

二、启动全流程解析

1. 启动流程全景图

Web 容器启动：

• Web 容器（如 Tomcat）启动时，会加载 web.xml（或 Servlet 3.0+ 的注解配置）。
• 容器根据配置初始化 ServletContext（全局上下文），作为整个 Web 应用的共享空间。
• 在 ServletContext 基础上展开Spring Web 容器的一系列启动初始化

2. 初始化根容器（Root WebApplicationContext）

2.1 Tomcat 中启动入口源码解析

源码入口：StandardContext.startInternal()

核心点：上面 Tomcat 源码中 listener.contextInitialized(event) 方法会执行到 Spring ContextLoaderListener.contextInitialized()方法， 从而初始化Spring Web 根上下文（IOC容器），建立起在Web环境中Spring IOC容器。

2.2 Spring 根上下文启动源码解析

源码入口：ContextLoaderListener.contextInitialized()

[提示]:详细解析过程可查阅： Spring IOC容器在web容器中的启动过程

3. 初始化 MVC 容器（DispatcherServlet 的 WebApplicationContext）

Tomcat 等 Web 容器（Servlet 容器）启动时调用 Servlet 的 init() 方法是一个由 Java Servlet 规范定义的标准过程，其细节如下：

3.1 Tomcat 中启动入口源码解析

源码入口：StandardContext.startInternal()

Servlet 加载机制： StandardContext.loadOnStartup()

核心代码：StandardWrapper.loadServlet()

核心点：上面的 Tomcat 源码中GenericServlet.init()方法实际会调用到 Spring DispatcherServlet.load()方法（DispatcherServlet的继承链：DispatcherServlet → FrameworkServlet → HttpServletBean→ HttpServlet→ GenericServlet），从而初始化Spring Web 根上下文（IOC容器），建立起在Web环境中Spring MVC容器来接收处理 HTTP 请求。

疑问点：为什么调用 servlet.init()?

• Servlet 规范要求，所有 Servlet 必须实现 javax.servlet.Servlet 接口；Java Servlet 规范（JSR 369）明确定义：

• “After the servlet object is instantiated, the container must initialize the servlet before it can handle requests. The container initializes the servlet by calling the init(ServletConfig) method.”

• load-on-startup 控制：在 web.xml 中配置的 <load-on-startup> 决定初始化时机；
  • 延迟加载（默认行为）：在 Tomcat 容器启动时，默认情况下 不会立即初始化 Servlet。Servlet 的初始化通常是延迟的（lazy loading），即在第一次接收到与该 Servlet 相关的请求时才会进行初始化。这种行为是由 Servlet 规范定义的，目的是为了节省资源。
  • 启动时加载（eager loading）：如果在 web.xml 中为 Servlet 配置了 <load-on-startup> 元素，Tomcat 会在容器启动时初始化该 Servlet。其值为一个整数，表示加载顺序。0或正值，值越小，优先级越高。负值或未指定，首次请求时初始化。

3.2 Spring MVC上下文启动源码解析

源码入口：DispatcherServlet.init()

• 配置web.xml：

由于继承关系，实际初始化入口类为DispatcherServlet的父类HttpServletBean，源码位置：org.springframework.web.servlet.HttpServletBean

1. ★MVC容器初始化入口：HttpServletBean

2. 创建 MVC 容器：FrameworkServlet

3. 核心逻辑：initWebApplicationContext()

4. 创建MVC子容器：createWebApplicationContext()

5. 配置并刷新容器：configureAndRefreshWebApplicationContext()

6. 初始化 MVC 组件：DispatcherServlet 的 onRefresh()

3.3 核心启动流程

• DispatcherServlet 初始化时调用 init() 方法。
• 创建 子应用上下文（专用于 Web 层的容器），自动将根上下文设置为父容器。
• 加载 contextConfigLocation 指定的 MVC 配置（如 Controller、视图解析器等）。
• 刷新子上下文（refresh() 方法），初始化所有 MVC 相关的 组件Bean。

通过此流程，Spring MVC 实现了 Web 层组件的精确控制，同时通过父子容器隔离了业务层与 Web 层的 Bean 管理。

4. 关键设计解析

1. 父子容器设计的优势

• 关注点分离：业务层与Web层解耦
• 资源隔离：避免Controller污染业务层
• 灵活配置：不同容器可独立配置
• 依赖可控：子容器可访问父容器，反之不行
• 独立刷新：Web层重启不影响业务层

2. 设计意义与价值

1. 生命周期管理：
   • 容器完全控制 Servlet 的创建 → 初始化 → 服务 → 销毁
   • 保证资源有序初始化和释放
2. 依赖解耦：
   • Servlet 无需知道容器实现细节
   • 通过标准接口 ServletConfig 获取配置
3. 资源预加载：
   • load-on-startup 避免首次请求延迟
   • 特别适合 Spring MVC 这类重量级前端控制器
4. 扩展性：
   • Spring 通过重写 init() 插入自定义初始化逻辑
   • 实现父子容器、组件初始化等高级特性

三、调试技巧

关键断点位置：

• FrameworkServlet.initWebApplicationContext()
• AbstractApplicationContext.refresh()
• DispatcherServlet.initStrategies()
• RequestMappingHandlerMapping.afterPropertiesSet()

四、总结

Spring MVC在Web容器中的启动是一个精密的协作过程：整个启动过程由 Servlet 规范 驱动（监听器、Servlet 生命周期），Spring 在此基础上扩展上下文层次。

• Tomcat 通过load-on-startup机制触发Servlet初始化
• ContextLoaderListener 创建根容器管理业务Bean
• DispatcherServlet 创建子容器管理Web组件。
• 父子容器 通过setParent()建立层级关系。
• 父子容器refresh() 方法触发完整的Bean初始化流程

通过这种分层设计，Spring 实现了关注点分离（业务层 vs Web 层），同时确保依赖注入的正确性。 通过这套机制，Tomcat
等容器保证了 Spring MVC 这类框架能在正确的时间点初始化自己的核心组件，同时遵循 Java EE 标准规范。

End!

扩展

DispatcherServlet Diagram

Tomcat 中的完整调用栈

// Tomcat 启动入口
Bootstrap.main()
  → Catalina.load()
  → StandardServer.start()
    → StandardService.start()
      → StandardEngine.start()
        → StandardHost.start()
          → StandardContext.start()
            → StandardContext.startInternal()
              → StandardContext.fireLifecycleEvent()  // 触发监听器（初始化Spring Web根容器）
              → StandardContext.loadOnStartup()       // 关键：启动时加载Servlet
                → StandardWrapper.loadServlet()
                  → DispatcherServlet.init(ServletConfig)  // Spring MVC子容器入口
                    → HttpServletBean.init()
                      → FrameworkServlet.initServletBean()
                        → initWebApplicationContext()  // 初始化MVC容器

Servlet 3.0+ 无配置启动（Java Config）

通过实现 WebApplicationInitializer 接口替代 web.xml：

public class MyWebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext servletContext) {
        // 1. 创建根容器
        AnnotationConfigWebApplicationContext rootContext = new AnnotationConfigWebApplicationContext();
        rootContext.register(RootConfig.class);
        servletContext.addListener(new ContextLoaderListener(rootContext));

        // 2. 创建 MVC 容器（子容器）
        AnnotationConfigWebApplicationContext mvcContext = new AnnotationConfigWebApplicationContext();
        mvcContext.register(WebConfig.class);

        // 3. 注册 DispatcherServlet
        DispatcherServlet servlet = new DispatcherServlet(mvcContext);
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", servlet);
        registration.addMapping("/");
        registration.setLoadOnStartup(1);
    }
}