Spring Boot與Spring MVC內建啟動過程源碼分析

開源項目推薦

是我與同僚開發的一個開源工具(

https://github.com/zrbcool/pepper-metrics)

，其通過收集jedis/mybatis/httpservlet/dubbo/motan的運作性能統計，并暴露成prometheus等主流時序資料庫相容資料，通過grafana展示趨勢。其插件化的架構也非常友善使用者擴充并內建其他開源元件。

請大家給個star，同時歡迎大家成為開發者送出PR一起完善項目。

從一個最簡單的Spring Boot Web項目聊起

我們知道，用spring-boot寫一個web項目非常容易，pom繼承spring-boot-parent然後引入依賴spring-boot-starter-web，再寫一個這樣的主啟動類，然後就可以去寫Controller了，十分簡單，就像這樣：

@SpringBootApplication
public class SampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SampleApplication.class, args);
    }
}
// 然後再寫一個Controller聲明一個Rest服務
@RestController
@RequestMapping("/perf")
public class PerfController {
    @RequestMapping("/trace")
    public Object trace() {
        Object result = yourLogic();
        return result;
    }
}

聊聊SpringApplication.run

可是我們思考過，這背後spring-boot到底做了什麼使我們的工作如此簡單，它如何将spring、spring-mvc、tomcat整合到一起的呢？接下來我們以項目啟動角度來分析整個初始化過程。

PS：下面代碼分析過程中，着重于流程的串接，調用到某個變量時，作者會直接給出這個變量的具體實作，讀者也許會産生困惑，但是不要停下來，先想當然的按照作者的思路把流程捋完，後面會針對各個主要的變量初始化及選擇實作的過程進行逐個解釋。

從SpringApplication.run說起：

方法定義如下

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return new SpringApplication(primarySources).run(args);
}
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    configureHeadlessProperty();
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting();
    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        configureIgnoreBeanInfo(environment);
        Banner printedBanner = printBanner(environment);
        context = createApplicationContext();//1)
        exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
                new Class[] { ConfigurableApplicationContext.class }, context);
        prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        refreshContext(context);//2)
        afterRefresh(context, applicationArguments);
        stopWatch.stop();
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
        listeners.started(context);
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, listeners);
        throw new IllegalStateException(ex);
    }

    try {
        listeners.running(context);
    }
    catch (Throwable ex) {
        handleRunFailure(context, ex, exceptionReporters, null);
        throw new IllegalStateException(ex);
    }
    return context;
}

我們來分解下這個run方法

先看1)context = createApplicationContext()

負責建立spring主容器，這個方法内部是根據具體項目運作時依賴的類來動态選擇實作的，如果是web項目則會選擇AnnotationConfigServletWebServerApplicationContext，至于選擇的規則及原因，這裡先忽略，後面會專門介紹（時空門：

ServletWebServerApplicationContext

）。

接下來我們重點看2)refreshContext(context)方法

其方法内部最終調用了((AbstractApplicationContext) applicationContext).refresh()方法，我們把這個方法展開

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        prepareRefresh();
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        prepareBeanFactory(beanFactory);
        try {
            postProcessBeanFactory(beanFactory);
            invokeBeanFactoryPostProcessors(beanFactory);
            registerBeanPostProcessors(beanFactory);
            initMessageSource();
            initApplicationEventMulticaster();
            onRefresh();//3)
            registerListeners();
            finishBeanFactoryInitialization(beanFactory);
            finishRefresh();
        }
        catch (BeansException ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("Exception encountered during context initialization - " +
                        "cancelling refresh attempt: " + ex);
            }
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
        finally {
            resetCommonCaches();
        }
    }
}

實際上，這裡我們的調用已經到了spring-context包，其實跟spring-boot已經沒啥關系了，這其實就是一個标準的SpringApplicationContext的标準啟動過程中refresh()部分，我們不是對spring啟動過程分解，是以我們隻關注與tomcat，spring-mvc結合的部分。

直接看3)onRefresh()方法，因為AnnotationConfigServletWebServerApplicationContext是ServletWebServerApplicationContext的子類，是以流程進入ServletWebServerApplicationContext的onRefresh()方法

@Override
protected void onRefresh() {
    super.onRefresh();
    try {
        createWebServer();//4)
    }
    catch (Throwable ex) {
        throw new ApplicationContextException("Unable to start web server", ex);
    }
}

可以看到這個4)createWebServer()，是我們的關鍵

private void createWebServer() {
    WebServer webServer = this.webServer;
    ServletContext servletContext = getServletContext();
    if (webServer == null && servletContext == null) {
        ServletWebServerFactory factory = getWebServerFactory();//5)
        this.webServer = factory.getWebServer(getSelfInitializer());//6)
    }
    else if (servletContext != null) {
        try {
            getSelfInitializer().onStartup(servletContext);
        }
        catch (ServletException ex) {
            throw new ApplicationContextException("Cannot initialize servlet context", ex);
        }
    }
    initPropertySources();
}

其中：

5)ServletWebServerFactory factory = getWebServerFactory();

上面這句擷取到的具體實作是TomcatServletWebServerFactory（時空門：

TomcatServletWebServerFactory

）

6)this.webServer = factory.getWebServer(getSelfInitializer());

先看6)中的getSelfInitializer()方法：

private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
    return this::selfInitialize;
}
private void selfInitialize(ServletContext servletContext) throws ServletException {
    prepareWebApplicationContext(servletContext);
    registerApplicationScope(servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
    }
}

這塊有點意思，傳回的是一個this::selfInitialize，方法定義是傳回org.springframework.boot.web.servlet.ServletContextInitializer，我們看下它是什麼定義

@FunctionalInterface
public interface ServletContextInitializer {
    void onStartup(ServletContext servletContext) throws ServletException;
}

@FunctionalInterface是java8中lambda支援的一種函數式接口selfInitialize這段邏輯在後面過程當中會被調用。

繼續看6)中this.webServer = factory.getWebServer(...)，我們看下實作：

@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
    Tomcat tomcat = new Tomcat();
    File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
    tomcat.setBaseDir(baseDir.getAbsolutePath());
    Connector connector = new Connector(this.protocol);
    tomcat.getService().addConnector(connector);
    customizeConnector(connector);
    tomcat.setConnector(connector);
    tomcat.getHost().setAutoDeploy(false);
    configureEngine(tomcat.getEngine());
    for (Connector additionalConnector : this.additionalTomcatConnectors) {
        tomcat.getService().addConnector(additionalConnector);
    }
    prepareContext(tomcat.getHost(), initializers);//7)
    return getTomcatWebServer(tomcat);
}

可以看到在裡面建立了Tomcat執行個體作為webServer的内部實作，然後向Tomcat的Service容器注入Connector，然後設定預設Host容器的AutoDeploy屬性及其他的Tomcat初始化工作，最重要的一行是7)

我們來看一下：

protected void prepareContext(Host host, ServletContextInitializer[] initializers) {
    File documentRoot = getValidDocumentRoot();
    TomcatEmbeddedContext context = new TomcatEmbeddedContext();
    if (documentRoot != null) {
        context.setResources(new LoaderHidingResourceRoot(context));
    }
    ...//省略我們不關注的部分代碼
    ServletContextInitializer[] initializersToUse = mergeInitializers(initializers);//8)
    host.addChild(context);//将context加入host作為host的子容器
    configureContext(context, initializersToUse);//9)
    postProcessContext(context);
}

我們可以看到其調用host.addChild(context)将context加入host作為host的子容器，然後

其中8)查找所有ServletContextInitializer實作并合并為一個數組，然後調用9)configureContext方法，我們來看一下：

protected void configureContext(Context context, ServletContextInitializer[] initializers) {
    TomcatStarter starter = new TomcatStarter(initializers);//10)
    if (context instanceof TomcatEmbeddedContext) {
        TomcatEmbeddedContext embeddedContext = (TomcatEmbeddedContext) context;
        embeddedContext.setStarter(starter);
        embeddedContext.setFailCtxIfServletStartFails(true);
    }
    context.addServletContainerInitializer(starter, NO_CLASSES);//11)
    ...//忽略
}

10)建立了TomcatStarter對象，并将starter加入context的conainerInitializer清單，見11)，這樣在tomcat的容器啟動過程中就會調用到這個TomcatStarter執行個體。

我們來看下TomcatStarter做了什麼

class TomcatStarter implements ServletContainerInitializer {
    ...
    private final ServletContextInitializer[] initializers;
    ...
    TomcatStarter(ServletContextInitializer[] initializers) {
        this.initializers = initializers;
    }
    ...
    @Override
    public void onStartup(Set<Class<?>> classes, ServletContext servletContext) throws ServletException {
        try {
            for (ServletContextInitializer initializer : this.initializers) {
                initializer.onStartup(servletContext);
            }
        }
        catch (Exception ex) {
            this.startUpException = ex;
            if (logger.isErrorEnabled()) {
                logger.error("Error starting Tomcat context. Exception: " + ex.getClass().getName() + ". Message: "
                        + ex.getMessage());
            }
        }
    }
    ...
}

可以看到TomcatStarter相當于hook了context啟動的事件，然後調用所有注入的initializers的onStartup方法，似曾相識是嗎？這就是前面說的@FunctionalInterface函數接口，接下來我們就深入看下前面提到的那個initializer的onStartup的具體内容

//ServletWebServerApplicationContext類當中
private org.springframework.boot.web.servlet.ServletContextInitializer getSelfInitializer() {
    return this::selfInitialize;
}
private void selfInitialize(ServletContext servletContext) throws ServletException {
    prepareWebApplicationContext(servletContext);
    registerApplicationScope(servletContext);
    WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
    for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
        beans.onStartup(servletContext);
    }
}

可以看到其對getServletContextInitializerBeans()的每個ServletContextInitializer均調用了onStartup方法

protected Collection<ServletContextInitializer> getServletContextInitializerBeans() {
    return new ServletContextInitializerBeans(getBeanFactory());
}

看看new ServletContextInitializerBeans(getBeanFactory())做了什麼

@SafeVarargs
public ServletContextInitializerBeans(ListableBeanFactory beanFactory,
        Class<? extends ServletContextInitializer>... initializerTypes) {
    this.initializers = new LinkedMultiValueMap<>();
    this.initializerTypes = (initializerTypes.length != 0) ? Arrays.asList(initializerTypes)
            : Collections.singletonList(ServletContextInitializer.class);
    addServletContextInitializerBeans(beanFactory);
    addAdaptableBeans(beanFactory);
    List<ServletContextInitializer> sortedInitializers = this.initializers.values().stream()
            .flatMap((value) -> value.stream().sorted(AnnotationAwareOrderComparator.INSTANCE))
            .collect(Collectors.toList());
    this.sortedList = Collections.unmodifiableList(sortedInitializers);
    logMappings(this.initializers);
}

可以看到其從beanFactory中擷取spring容器中所有的ServletContextInitializer實作，這裡關于內建的部分在ServletRegistrationBean中，ServletRegistrationBean的注入過程參考：

時空門：Dispatcherservletregistrationbean

private void addServletContextInitializerBeans(ListableBeanFactory beanFactory) {
    for (Class<? extends ServletContextInitializer> initializerType : this.initializerTypes) {
        for (Entry<String, ? extends ServletContextInitializer> initializerBean : getOrderedBeansOfType(beanFactory,
                initializerType)) {
            addServletContextInitializerBean(initializerBean.getKey(), initializerBean.getValue(), beanFactory);
        }
    }
}
private void addServletContextInitializerBean(String beanName, ServletContextInitializer initializer,
        ListableBeanFactory beanFactory) {
    if (initializer instanceof ServletRegistrationBean) {
        Servlet source = ((ServletRegistrationBean<?>) initializer).getServlet();
        addServletContextInitializerBean(Servlet.class, beanName, initializer, beanFactory, source);
    }
    else if (initializer instanceof FilterRegistrationBean) {
        Filter source = ((FilterRegistrationBean<?>) initializer).getFilter();
        addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
    }
    else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
        String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
        addServletContextInitializerBean(Filter.class, beanName, initializer, beanFactory, source);
    }
    else if (initializer instanceof ServletListenerRegistrationBean) {
        EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
        addServletContextInitializerBean(EventListener.class, beanName, initializer, beanFactory, source);
    }
    else {
        addServletContextInitializerBean(ServletContextInitializer.class, beanName, initializer, beanFactory,
                initializer);
    }
}

然後流程就順了，我們會調用到ServletRegistrationBean的onStartup方法，最終會調用到servletContext.addServlet的Servlet3.0的标準将DispatchServlet注入到servlet容器中攔截所有的請求。

見下面代碼：

//RegistrationBean
@Override
public final void onStartup(ServletContext servletContext) throws ServletException {
    String description = getDescription();
    if (!isEnabled()) {
        logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
        return;
    }
    register(description, servletContext);
}
//DynamicRegistrationBean
@Override
protected final void register(String description, ServletContext servletContext) {
    D registration = addRegistration(description, servletContext);
    if (registration == null) {
        logger.info(
                StringUtils.capitalize(description) + " was not registered " + "(possibly already registered?)");
        return;
    }
    configure(registration);
}
//ServletRegistrationBean
@Override
protected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) {
    String name = getServletName();
    return servletContext.addServlet(name, this.servlet);
}

至此所有內建完畢，啟動過程交給tomcat完成。

沒講完的故事：各個依賴的元件是如何初始化的

spring-boot-autoconfigure/META-INF/spring.factories中有一段配置：

...
# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
...

然後我們來看下ServletWebServerFactoryAutoConfiguration類

@Configuration
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@ConditionalOnClass(ServletRequest.class)
@ConditionalOnWebApplication(type = Type.SERVLET)
@EnableConfigurationProperties(ServerProperties.class)
@Import({ ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class,
        ServletWebServerFactoryConfiguration.EmbeddedTomcat.class,
        ServletWebServerFactoryConfiguration.EmbeddedJetty.class,
        ServletWebServerFactoryConfiguration.EmbeddedUndertow.class })
public class ServletWebServerFactoryAutoConfiguration {
    ...
}

其中@Import部分引入了ServletWebServerFactoryConfiguration.EmbeddedTomcat.class，深入看一下

@Configuration
class ServletWebServerFactoryConfiguration {
    @Configuration
    @ConditionalOnClass({ Servlet.class, Tomcat.class, UpgradeProtocol.class })
    @ConditionalOnMissingBean(value = ServletWebServerFactory.class, search = SearchStrategy.CURRENT)
    public static class EmbeddedTomcat {
        @Bean
        public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
            return new TomcatServletWebServerFactory();
        }
    }
    ...
}

這塊Spring Boot根據@ConditionalOnClass判斷目前運作時環境是否符合條件，即包含了tomcat的jar包，如果滿足則建立TomcatServletWebServerFactory的Bean執行個體加入spring容器管理，後面有用。

實際啟動時，啟動的是其子類AnnotationConfigServletWebServerApplicationContext，我們來看下SpringApplication類，實際上SpringApplication在運作時根據情況決定使用哪種ApplicationContext

檢視createApplicationContext()方法

那麼這個this.webApplicationType又是哪來的值呢？

我們看下這個構造方法

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

WebApplicationType.deduceFromClasspath()用來自動識别這個值，看下實作：

static WebApplicationType deduceFromClasspath() {
    if (ClassUtils.isPresent(WEBFLUX_INDICATOR_CLASS, null) && !ClassUtils.isPresent(WEBMVC_INDICATOR_CLASS, null)
            && !ClassUtils.isPresent(JERSEY_INDICATOR_CLASS, null)) {
        return WebApplicationType.REACTIVE;
    }
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;
        }
    }
    return WebApplicationType.SERVLET;
}

可以看到它是通過判斷classloader中是否有Servlet相關的class來判斷的，是以是運作時判斷的。

DispatcherServletRegistrationBean

DispatcherServletRegistrationBean是保證我們的DispatcherServlet被注入到Servlet容器并生效的關鍵，我們來看下它是如何初始化的

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\

看看實作

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass(DispatcherServlet.class)
@AutoConfigureAfter(ServletWebServerFactoryAutoConfiguration.class)
public class DispatcherServletAutoConfiguration {
    @Configuration
    @Conditional(DispatcherServletRegistrationCondition.class)
    @ConditionalOnClass(ServletRegistration.class)
    @EnableConfigurationProperties(WebMvcProperties.class)
    @Import(DispatcherServletConfiguration.class)
    protected static class DispatcherServletRegistrationConfiguration {

        private final WebMvcProperties webMvcProperties;

        private final MultipartConfigElement multipartConfig;

        public DispatcherServletRegistrationConfiguration(WebMvcProperties webMvcProperties,
                ObjectProvider<MultipartConfigElement> multipartConfigProvider) {
            this.webMvcProperties = webMvcProperties;
            this.multipartConfig = multipartConfigProvider.getIfAvailable();
        }

        @Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
        @ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
        public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet) {
            DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet,
                    this.webMvcProperties.getServlet().getPath());
            registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
            registration.setLoadOnStartup(this.webMvcProperties.getServlet().getLoadOnStartup());
            if (this.multipartConfig != null) {
                registration.setMultipartConfig(this.multipartConfig);
            }
            return registration;
        }

    }
}

可以看到，其像spring容器注冊了DispatcherServletRegistrationBean的Bean執行個體，看一下它的繼承關系：

其父類ServletRegistrationBean類有如下方法：

@Override
protected ServletRegistration.Dynamic addRegistration(String description, ServletContext servletContext) {
    String name = getServletName();
    return servletContext.addServlet(name, this.servlet);
}

其調用了ServletContext.addServlet方法将DispatchServlet加入到Servlet容器，這是Servlet3.0中注冊servlet的方法。

那麼你也許會問，addRegistration又是什麼時機調用的呢？

根據繼承關系，檢視其父類的父類RegistrationBean，其有一個

@Override
public final void onStartup(ServletContext servletContext) throws ServletException {
    String description = getDescription();
    if (!isEnabled()) {
        logger.info(StringUtils.capitalize(description) + " was not registered (disabled)");
        return;
    }
    register(description, servletContext);
}

register方法是一個模闆方法，調用子類DynamicRegistrationBean的實作

@Override
protected final void register(String description, ServletContext servletContext) {
    D registration = addRegistration(description, servletContext);
    if (registration == null) {
        logger.info(StringUtils.capitalize(description) + " was not registered " + "(possibly already registered?)");
        return;
    }
    configure(registration);
}

addRegistration方法又是一個模闆方法，實作就是前面ServletRegistrationBean的addRegistration實作，而onStartup方法會在SpringApplication.run()方法的流程中被調用到，講主流程的時候已經講到，這裡不再贅述

這樣就将DispatchServlet與Tomcat進行了內建，DispatchServlet使用模闆方法設計模式，将具體的請求配置設定給不同的handler處理，這個後面會講到，本篇就主要專注在Spring Boot與Spring MVC及Tomcat的內建原理部分。

Spring Boot與Spring MVC內建啟動過程源碼分析

開源項目推薦

從一個最簡單的Spring Boot Web項目聊起

聊聊SpringApplication.run

沒講完的故事：各個依賴的元件是如何初始化的

DispatcherServletRegistrationBean

繼續閱讀

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

用mybatis的generator插件在項目中自動生成dao及entity

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

從mybatis到mybatis plus(mp)

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method