本文將通過閱讀原始碼方式分析SpringBoot應用的啟動流程，不涉及Spring啟動部分(有相應的文章介紹)，
本文不會對各個流程做展開分析，后續會有文章介紹詳細流程，
SpringApplication類
應用啟動入口
使用以下方式啟動一個SpringBoot應用：
@SpringBootApplication
public class SpringBootDemoApplication {
public static void main(String[] args) {
SpringApplication.run(SpringBootDemoApplication.class, args);
}
}
run方法
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
return run(new Class<?>[] { primarySource }, args);
}
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);
// 獲取應用env
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
configureIgnoreBeanInfo(environment);
// 列印banner
Banner printedBanner = printBanner(environment);
// 創建ApplicationContext
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
// 一些準備作業
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// refresh ApplicationContext
refreshContext(context);
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
}
// 呼叫listener
listeners.started(context);
// 呼叫ApplicationRunner和CommandLineRunner
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;
}
獲取應用env
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments) {
// 創建StandardServletEnvironment, 會初始化四個PropertySource:
// servletConfigInitParams, servletContextInitParams, systemProperties, systemEnvironment
// 比如-Dserver.port=8888會在systemProperties中
ConfigurableEnvironment environment = getOrCreateEnvironment();
// 添加defaultProperties和命令列配置引數即CommandLinePropertySource
// 通常都沒有這兩個配置
configureEnvironment(environment, applicationArguments.getSourceArgs());
// 使用ConfigurationPropertySourcesPropertySource封裝并暴露所有的PropertySource集
ConfigurationPropertySources.attach(environment);
// 添加ApplicationEnvironmentPreparedEvent事件并觸發multicastEvent加載應用組態檔
listeners.environmentPrepared(environment);
// 將spring.main.xx配置加載到SpringApplication物件
bindToSpringApplication(environment);
if (!this.isCustomEnvironment) {
environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
deduceEnvironmentClass());
}
ConfigurationPropertySources.attach(environment);
return environment;
}
加載組態檔的入口在ConfigFileApplicationListener類中：
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
addPropertySources(environment, application.getResourceLoader());
}
protected void addPropertySources(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
// 添加RandomValuePropertySource
RandomValuePropertySource.addToEnvironment(environment);
// 加載組態檔
new Loader(environment, resourceLoader).load();
}
加載組態檔的原始碼較多，此處不做記錄，簡單梳理一下流程：
- 加載active profile組態檔
- 如果配置了spring.config.additional-location或spring.config.location引數，會使用它們作為組態檔，如果這兩個引數值是目錄，則會從這兩個目錄下查找組態檔
- 默認從classpath:/,classpath:/config/,file:./,file:./config/*/,file:./config/目錄下查找application-xx.properties或application-xx.yml檔案
- 使用PropertiesPropertySourceLoader和YamlPropertySourceLoader決議組態檔
- 會將配置引數封裝成OriginTrackedMapPropertySource型別物件，使用applicationConfig: [classpath:/application-dev.yml]之類的字串作為PropertySource的名稱
- 加載默認的application.properties或application.yml檔案
- 決議出來的所有PropertySource都會添加到environment的propertySources中，propertySources是一個MutablePropertySources物件，管理著所有的PropertySource集，在這個程序中，添加的先后順序決定了配置的優先級
創建ApplicationContext
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
// AnnotationConfigServletWebServerApplicationContext類
contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
// AnnotationConfigReactiveWebServerApplicationContext類
contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
// AnnotationConfigApplicationContext類
contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
}
} catch (ClassNotFoundException ex) {
throw new IllegalStateException("Unable create a default ApplicationContext", ex);
}
}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
}
prepareContext
private void prepareContext(
ConfigurableApplicationContext context, ConfigurableEnvironment environment,
SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments,
Banner printedBanner) {
context.setEnvironment(environment);
postProcessApplicationContext(context);
// Apply any ApplicationContextInitializers to the context before it is refreshed.
// ApplicationContextInitializers集是在創建SpringApplication物件的時候初始化的
applyInitializers(context);
// 觸發contextPrepared事件
listeners.contextPrepared(context);
if (this.logStartupInfo) {
logStartupInfo(context.getParent() == null);
logStartupProfileInfo(context);
}
// 獲取BeanFactory并注冊必要的Bean
ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
// 注冊啟動引數
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
// 注冊banner printer
if (printedBanner != null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
}
// 設定是否允許Bean覆寫，使用spring.main.allowBeanDefinitionOverriding引數配置
if (beanFactory instanceof DefaultListableBeanFactory) {
((DefaultListableBeanFactory) beanFactory)
.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
}
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
}
// Load the sources
Set<Object> sources = getAllSources();
// 將SpringApplication.run(Xxx.class, args)方法傳入的Class注冊到容器
// 使用AnnotatedBeanDefinitionReader.register(Class<?>...)方法注冊啟動類
load(context, sources.toArray(new Object[0]));
// 觸發contextLoaded事件
listeners.contextLoaded(context);
}
refreshApplicationContext
protected void refresh(ConfigurableApplicationContext applicationContext) {
applicationContext.refresh();
}
呼叫的是ServletWebServerApplicationContext的refresh方法：
public final void refresh() throws BeansException, IllegalStateException {
try {
super.refresh();
} catch (RuntimeException ex) {
// 關閉web server
WebServer webServer = this.webServer;
if (webServer != null) {
webServer.stop();
}
throw ex;
}
}
絕大多數的refresh邏輯都在AbstractApplicationContext類里面，ServletWebServerApplicationContext中會在onRefresh階段創建webServer：
protected void onRefresh() {
super.onRefresh();
try {
createWebServer();
} catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}
呼叫ApplicationRunner和CommandLineRunner
private void callRunners(ApplicationContext context, ApplicationArguments args) {
List<Object> runners = new ArrayList<>();
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
AnnotationAwareOrderComparator.sort(runners);
for (Object runner : new LinkedHashSet<>(runners)) {
if (runner instanceof ApplicationRunner) {
callRunner((ApplicationRunner) runner, args);
}
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
SpringBootApplication注解
指示一個配置類，該類宣告一個或多個@Bean方法，并觸發自動配置和組件掃描，這是一個方便的注解，相當于宣告@Configuration、@EnableAutoConfiguration和@ComponentScan注解，
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
/**
* Exclude specific auto-configuration classes such that they will never be applied.
*/
@AliasFor(annotation = EnableAutoConfiguration.class)
Class<?>[] exclude() default {};
/**
* Exclude specific auto-configuration class names such that they will never be
* applied.
*/
@AliasFor(annotation = EnableAutoConfiguration.class)
String[] excludeName() default {};
/**
* Base packages to scan for annotated components. Use scanBasePackageClasses
* for a type-safe alternative to String-based package names.
*/
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
/**
* Type-safe alternative to scanBasePackages for specifying the packages to
* scan for annotated components. The package of each class specified will be scanned.
*/
@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
/**
* The BeanNameGenerator class to be used for naming detected components
* within the Spring container.
*/
@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
/**
* Specify whether @Bean methods should get proxied in order to enforce
* bean lifecycle behavior, e.g. to return shared singleton bean instances even in
* case of direct @Bean method calls in user code. This feature requires
* method interception, implemented through a runtime-generated CGLIB subclass which
* comes with limitations such as the configuration class and its methods not being
* allowed to declare final.
*/
@AliasFor(annotation = Configuration.class)
boolean proxyBeanMethods() default true;
}
SpringBootConfiguration注解
指示一個類提供Spring Boot application @Configuration功能，可以替代Spring的標準@Configuration注解，以便可以自動找到配置類，
應用程式應該只標注一個@SpringBootConfiguration，大多數SpringBoot應用程式將從@SpringBootApplication繼承它，
@Configuration
public @interface SpringBootConfiguration {
@AliasFor(annotation = Configuration.class)
boolean proxyBeanMethods() default true;
}
EnableAutoConfiguration注解
啟用SpringBoot自動裝配功能，嘗試猜測和配置可能需要的組件Bean，
自動裝配類通常是根據類路徑和定義的Bean來應用的，例如，如果類路徑上有tomcat-embedded.jar，那么可能需要一個TomcatServletWebServerFactory(除非已經定義了自己的Servlet WebServerFactory Bean)，
自動裝配試圖盡可能地智能化，并將隨著開發者定義自己的配置而取消自動裝配相沖突的配置，開發者可以使用exclude()排除不想使用的配置，也可以通過spring.autoconfig.exclude屬性排除這些配置，自動裝配總是在用戶定義的Bean注冊之后應用，
用@EnableAutoConfiguration注解標注的類所在包具有特定的意義，通常用作默認掃描的包，通常建議將@EnableAutoConfiguration(如果沒有使用@SpringBootApplication注解)放在根包中，以便可以搜索所有子包和類，
自動裝配類是普通的Spring @Configuration類，使用SpringFactoriesLoader機制定位，通常使用@Conditional方式裝配，最常用的是@ConditionalOnClass和@ConditionalOnMissingBean注解，
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
/**
* Exclude specific auto-configuration classes such that they will never be applied.
*/
Class<?>[] exclude() default {};
/**
* Exclude specific auto-configuration class names such that they will never be
* applied.
* 當類路徑下沒有指定的類時，可以使用這個屬性指定排除的類
*/
String[] excludeName() default {};
}
AutoConfigurationPackage注解
Registers packages with AutoConfigurationPackages. When no base packages or base package classes are specified, the package of the annotated class is registered.
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
}
AutoConfigurationImportSelector類
DeferredImportSelector介面的實作類，處理自動裝配，匯出所有需要自動裝配的類，
創建WebServer
SpringBoot會在onRefresh階段創建webServer，首先從spring容器獲取ServletWebServerFactory，然后呼叫getWebServer方法創建webServer，
getWebServer方法需要傳入ServletContextInitializer集來初始化ServletContext，
@FunctionalInterface
public interface ServletContextInitializer {
void onStartup(ServletContext servletContext) throws ServletException;
}
我們開發者如果需要使用ServletContextInitializer來初始化ServletContext的話，也可以撰寫一個實作類，然后將其注冊到spring容器即可，
另外，SpringBoot還會自動裝配DispatcherServletAutoConfiguration類，這個類會創建DispatcherServlet和DispatcherServletRegistrationBean，DispatcherServlet是SpringWebMvc的最核心組件，DispatcherServletRegistrationBean實作了ServletContextInitializer介面，可以將DispatcherServlet注冊到ServletContext，以TomcatServletWebServerFactory為例，這個類會通過TomcatStarter來呼叫所有的ServletContextInitializer，TomcatStarter實作了ServletContainerInitializer介面，Tomcat的ServletContext在啟動階段會呼叫ServletContainerInitializer的onStartup方法來初始化Servlet容器，
SpringBoot啟動流程
- 初始化environment應用配置引數：servletConfigInitParams, servletContextInitParams, systemProperties, systemEnvironment及組態檔等
- 創建ApplicationContext物件，SpringBoot應用默認使用的是AnnotationConfigServletWebServerApplicationContext類
- prepareContext階段：觸發一些事件，將啟動類注冊到Spring容器
- refresh階段：掃描應用組件，自動裝配
- onRefresh階段：創建并初始化WebServer
- 呼叫ApplicationRunner和CommandLineRunner
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/555239.html
標籤：其他
上一篇：Scala基本語法
下一篇：返回列表