SpringBoot啟動流程總結

米老鼠的世界 2021-06-08

展開全文

一直很好奇SpringBoot這么一個大怪物，啟動的時候做了哪些事情，然后看了很多老師講的教學視頻，然后自己想好好整理一下，做下學習筆記下次也方便自己閱讀

1.執行main方法

public static void main(String[] args) {
    //代碼很簡單SpringApplication.run();
SpringApplication.run(ConsumerApp.class, args);
}

public static ConfigurableApplicationContext run(Class<?> primarySource,
String... args) {
        //這個里面調用了run() 方法，我們轉到定義
return run(new Class<?>[] { primarySource }, args);
}
//這個run方法代碼也很簡單，就做了兩件事情
//1、new了一個SpringApplication() 這么一個對象
//2、執行new出來的SpringApplication()對象的run()方法
public static ConfigurableApplicationContext run(Class<?>[] primarySources,
String[] args) {
return new SpringApplication(primarySources).run(args);
}

上面代碼主要做了兩件事情。第一步new了一個SpringApplication對象，第二部調用了run()方法。接下來我們一起看下new SpringApplication() 主要做了什么事情。

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
this.resourceLoader = resourceLoader;
Assert.notNull(primarySources, "PrimarySources must not be null");
//1、先把主類保存起來
this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
//2、判斷運行項目的類型
this.webApplicationType = WebApplicationType.deduceFromClasspath();
//3、掃描當前路徑下META-INF/spring.factories文件的，加載ApplicationContextInitializer接口實例
setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
//4、掃描當前路徑下META-INF/spring.factories文件的，加載ApplicationListener接口實例
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
this.mainApplicationClass = deduceMainApplicationClass();
}

利用SPI機制掃描 META-INF/spring.factories 這個文件，并且加載 ApplicationContextInitializer、ApplicationListener 接口實例。

1、ApplicationContextInitializer 這個類當springboot上下文Context初始化完成后會調用

2、ApplicationListener 當springboot啟動時事件change后都會觸發

下面我們來自定義ApplicationContextInitializer、ApplicationListener 接口實現類，然后Debug來看下效果。

/**
 * Context初始化后調用類
 * @author ShiMinChen
 *
 */
public class StarterApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("applicationContext 初始化完成 ... ");
}
}

public class StarterApplicationListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        System.out.println(event.toString());
        System.out.println("ApplicationListener .... " + System.currentTimeMillis());
    }
}

我們需要把這兩個類集成到springboot里面去，其實操作也挺簡單的

然后在META-INF/spring.factories 文件配置那兩個類

org.springframework.context.ApplicationContextInitializer=\
org.admin.starter.test.listener.StarterApplicationContextInitializer
org.springframework.context.ApplicationListener=\
  org.admin.starter.test.listener.StarterApplicationListener

4、我們代碼DEBUG一下，在loadSpringFactories() 方法打一個斷點

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
MultiValueMap<String, String> result = cache.get(classLoader);
if (result != null)
return result;
try {
Enumeration<URL> urls = (classLoader != null ?
classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
result = new LinkedMultiValueMap<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
for (Map.Entry<?, ?> entry : properties.entrySet()) {
List<String> factoryClassNames = Arrays.asList(
StringUtils.commaDelimitedListToStringArray((String) entry.getValue()));
result.addAll((String) entry.getKey(), factoryClassNames);
}
}
cache.put(classLoader, result);
            // 端點打在這里就行了
return result;
}
catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]", ex);
}
}

總結：上面就是SpringApplication初始化的代碼，new SpringApplication()沒做啥事情，利用SPI機制主要加載了META-INF/spring.factories 下面定義的事件監聽器接口實現類

2.執行run() 方法

public ConfigurableApplicationContext run(String... args) {
        <!--1、這個是一個計時器，沒什么好說的-->
StopWatch stopWatch = new StopWatch();
stopWatch.start();
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
        <!--2、這個也不是重點，就是設置了一些環境變量-->
        configureHeadlessProperty();
        <!--3、獲取事件監聽器SpringApplicationRunListener類型，并且執行starting()方法-->
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
            <!--4、把參數args封裝成DefaultApplicationArguments，這個了解一下就知道-->
ApplicationArguments applicationArguments = new DefaultApplicationArguments(
args);
            <!--5、這個很重要準備環境了，并且把環境跟spring上下文綁定好，并且執行environmentPrepared()方法-->
ConfigurableEnvironment environment = prepareEnvironment(listeners,
applicationArguments);
            <!--6、判斷一些環境的值，并設置一些環境的值-->
configureIgnoreBeanInfo(environment);
            <!--7、打印banner-->
Banner printedBanner = printBanner(environment);
            <!--8、創建上下文，根據項目類型創建上下文-->
context = createApplicationContext();
            <!--9、獲取異常報告事件監聽-->
exceptionReporters = getSpringFactoriesInstances(
SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
            <!--10、準備上下文，執行完成后調用contextPrepared()方法,contextLoaded()方法-->
prepareContext(context, environment, listeners, applicationArguments,
printedBanner);
            <!--11、這個是spring啟動的代碼了，這里就回去里面就回去掃描并且初始化單實列bean了-->
            //這個refreshContext()加載了bean，還啟動了內置web容器，需要細細的去看看
refreshContext(context);
            <!--12、啥事情都沒有做-->
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass)
.logStarted(getApplicationLog(), stopWatch);
}
            <!--13、執行ApplicationRunListeners中的started()方法-->
listeners.started(context);
            <!--執行Runner（ApplicationRunner和CommandLineRunner）-->
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, listeners, exceptionReporters, ex);
throw new IllegalStateException(ex);
}
listeners.running(context);
return context;
}

2.1 createApplicationContext()

一起來看下context = createApplicationContext(); 這段代碼，這段代碼主要是根據項目類型創建上下文，并且會注入幾個核心組件類。

protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, please specify an ApplicationContextClass", ex);
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}

public AnnotationConfigServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
   super(beanFactory);
       //1：會去注入一些spring核心組件
   this.reader = new AnnotatedBeanDefinitionReader(this);
   this.scanner = new ClassPathBeanDefinitionScanner(this);
}

Web類型項目創建上下文對象 AnnotationConfigServletWebServerApplicationContext 。這里會把 ConfigurationClassPostProcessor 、AutowiredAnnotationBeanPostProcessor 等一些核心組件加入到Spring容器（扯淡有點遠，這是spring容器啟動的一些知識點，去了解一下對理解springboot有很大的幫助）

2.2 refreshContext()

下面一起來看下refreshContext(context) 這個方法，這個方法啟動spring的代碼加載了bean，還啟動了內置web容器

private void refreshContext(ConfigurableApplicationContext context) {
        // 轉到定義看看
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}
catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}

protected void refresh(ApplicationContext applicationContext) {
Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        //看看refresh()方法去
((AbstractApplicationContext) applicationContext).refresh();
}

轉到AbstractApplicationContext - >refresh()方法里面發現這是spring容器啟動代碼

@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}

spring容器啟動代碼就不說了，這里主要看一下onRefresh() 這個方法。轉到定義發現這個方法里面啥都沒有，這明顯是一個鉤子方法，它會鉤到它子類重寫onRefresh()方法。所以去看子類里面的onRefresh()

protected void onRefresh() throws BeansException {
    //這是一個空方法，AbstractApplicationContext 這個類是一個抽象類，
    //所以我們要找到集成AbstractApplicationContext的子類，去看子類里面的onRefresh()
// For subclasses: do nothing by default.
}

我們這里是一個Web項目，所以我們就去看 ServletWebServerApplicationContext 這個類，我還是把類的關系圖貼一下

我們就去看 ServletWebServerApplicationContext 這個類下面的 onRefresh() 方法

protected void onRefresh() {
super.onRefresh();
try {
            //看到內置容器的影子了，進去看看
createWebServer();
}
catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}

private void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
            //1、這個獲取webServerFactory還是要進去看看
ServletWebServerFactory factory = getWebServerFactory();
this.webServer = factory.getWebServer(getSelfInitializer());
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context",
ex);
}
}
initPropertySources();
}

我們繼續看下getWebServletFactory() 這個方法，這個里面其實就是選擇出哪種類型的web容器了

protected ServletWebServerFactory getWebServerFactory() {
// Use bean names so that we don't consider the hierarchy
String[] beanNames = getBeanFactory()
.getBeanNamesForType(ServletWebServerFactory.class);
if (beanNames.length == 0) {
throw new ApplicationContextException(
"Unable to start ServletWebServerApplicationContext due to missing "
+ "ServletWebServerFactory bean.");
}
if (beanNames.length > 1) {
throw new ApplicationContextException(
"Unable to start ServletWebServerApplicationContext due to multiple "
+ "ServletWebServerFactory beans : "
+ StringUtils.arrayToCommaDelimitedString(beanNames));
}
return getBeanFactory().getBean(beanNames[0], ServletWebServerFactory.class);
}

我們再回頭去看factory.getWebServer(getSelfInitializer()) ，轉到定義就會看到很熟悉的名字tomcat

public WebServer getWebServer(ServletContextInitializer... initializers) {
        //tomcat這位大哥出現了
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);
return getTomcatWebServer(tomcat);
}