Spring Boot與Spring MVC整合啟動過程原始碼分析

阿新 • • 發佈：2019-12-31

開源專案推薦

Pepper Metrics是我與同事開發的一個開源工具(github.com/zrbcool/pep…)，其通過收集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,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,source);
    }
    else if (initializer instanceof DelegatingFilterProxyRegistrationBean) {
        String source = ((DelegatingFilterProxyRegistrationBean) initializer).getTargetBeanName();
        addServletContextInitializerBean(Filter.class,source);
    }
    else if (initializer instanceof ServletListenerRegistrationBean) {
        EventListener source = ((ServletListenerRegistrationBean<?>) initializer).getListener();
        addServletContextInitializerBean(EventListener.class,source);
    }
    else {
        addServletContextInitializerBean(ServletContextInitializer.class,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完成。

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

TomcatServletWebServerFactory

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容器管理，後面有用。

ServletWebServerApplicationContext

實際啟動時，啟動的是其子類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容器並生效的關鍵，我們來看下它是如何初始化的
spring-boot-autoconfigure/META-INF/spring.factories中有一段配置：

# 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,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);
    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

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

TomcatServletWebServerFactory

ServletWebServerApplicationContext

DispatcherServletRegistrationBean

Spring Boot與Spring MVC整合啟動過程原始碼分析

Spring、Spring Boot與Spring MVC

[Java EE]Spring Boot 與 Spring Cloud的關係/過去-現在-未來

Spring Boot與Spring Cloud版本對應

Spring啟動過程原始碼分析基本概念

Spring啟動過程原始碼分析(1)——AnnotationConfigApplicationContext之初始化Scanner和Reader

淺析Spring boot與Spring cloud 之間的關係

Spring boot與Spring cloud 之間的關係

Redis核心原理與實踐--Redis啟動過程原始碼分析

ContentProvider的啟動過程原始碼分析

Elastic-job-lite整合spring-boot與監控平臺搭建

Spring Boot Admin郵件警報整合過程解析

spring boot與ktor整合的實現方法

Spring Boot + Zookeeper + Dubbo + Seata 整合後，打jar包無法啟動

Activiti7 與 Spring Boot 及 Spring Security 整合踩坑記錄

Spring Boot定時+多執行緒執行過程解析

spring boot基於DRUID實現資料來源監控過程解析

Spring Boot 2和Redis例子實現過程解析

spring boot mybatis多資料來源解決方案過程解析

Spring Boot通過Junit實現單元測試過程解析

Spring Boot與Spring MVC整合啟動過程原始碼分析

開源專案推薦

從一個最簡單的Spring Boot Web專案聊起

聊聊SpringApplication.run

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

TomcatServletWebServerFactory

ServletWebServerApplicationContext

DispatcherServletRegistrationBean

相關推薦