一、springboot啟動原理及相關流程概覽
springboot是基於spring的新型的輕量級框架，最厲害的地方當屬自動配置。那我們就可以根據啟動流程和相關原理來看看，如何實現傳奇的自動配置
二、springboot的啟動類入口
用過springboot的技術人員很顯而易見的兩者之間的差別就是視覺上很直觀的：springboot有自己獨立的啟動類（獨立程序）
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
從上面代碼可以看出，Annotation定義（@SpringBootApplication）和類定義（SpringApplication.run）最為耀眼，所以要揭開SpringBoot的神秘面紗，我們要從這兩位開始就可以了。
三、單單是SpringBootApplication接口用到了這些注解
@Target(ElementType.TYPE) // 注解的適用范圍，其中TYPE用於描述類、接口（包括包注解類型）或enum聲明
@Retention(RetentionPolicy.RUNTIME) // 注解的生命周期，保留到class文件中（三個生命周期）
@Documented // 表明這個注解應該被javadoc記錄
@Inherited // 子類可以繼承該注解
@SpringBootConfiguration // 繼承了Configuration，表示當前是注解類
@EnableAutoConfiguration // 開啟springboot的注解功能，springboot的四大神器之一，其借助@import的幫助
@ComponentScan(excludeFilters = { // 掃描路徑設置（具體使用待確認）
@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
...
}
在其中比較重要的有三個注解，分別是：
1）@SpringBootConfiguration // 繼承了Configuration，表示當前是注解類
2）@EnableAutoConfiguration // 開啟springboot的注解功能，springboot的四大神器之一，其借助@import的幫助
3）@ComponentScan(excludeFilters = { // 掃描路徑設置（具體使用待確認）
接下來對三個注解一一詳解，增加對springbootApplication的理解
1）@Configuration注解
按照原來xml配置文件的形式，在springboot中我們大多用配置類來解決配置問題
配置bean方式的不同：
a）xml配置文件的形式配置bean
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd" default-lazy-init="true"> <!--bean定義--> </beans>
b）javaconfiguration的配置形式配置bean
@Configuration
public class MockConfiguration{
//bean定義
}
注入bean方式的不同：
a）xml配置文件的形式注入bean
<bean id="mockService" class="..MockServiceImpl"> ... </bean>
b）javaconfiguration的配置形式注入bean
@Configuration
public class MockConfiguration{
@Bean
public MockService mockService(){
return new MockServiceImpl();
}
}
任何一個標注了@Bean的方法，其返回值將作為一個bean定義注冊到Spring的IoC容器，方法名將默認成該bean定義的id。
表達bean之間依賴關系的不同：
a）xml配置文件的形式表達依賴關系
<bean id="mockService" class="..MockServiceImpl"> <propery name ="dependencyService" ref="dependencyService" /> </bean> <bean id="dependencyService" class="DependencyServiceImpl"></bean>
b）javaconfiguration配置的形式表達依賴關系
@Configuration
public class MockConfiguration{
@Bean
public MockService mockService(){
return new MockServiceImpl(dependencyService());
}
@Bean
public DependencyService dependencyService(){
return new DependencyServiceImpl();
}
}
注：所以SpringBoot的啟動類最好是放在root package下，因為默認不指定basePackages。
3) @EnableAutoConfiguration
此注解顧名思義是可以自動配置，所以應該是springboot中最為重要的注解。
在spring框架中就提供了各種以@Enable開頭的注解，例如： @EnableScheduling、@EnableCaching、@EnableMBeanExport等； @EnableAutoConfiguration的理念和做事方式其實一脈相承簡單概括一下就是，借助@Import的支持，收集和注冊特定場景相關的bean定義。
-
- @EnableScheduling是通過@Import將Spring調度框架相關的bean定義都加載到IoC容器【定時任務、時間調度任務】
- @EnableMBeanExport是通過@Import將JMX相關的bean定義加載到IoC容器【監控JVM運行時狀態】
@EnableAutoConfiguration也是借助@Import的幫助，將所有符合自動配置條件的bean定義加載到IoC容器。
@EnableAutoConfiguration作為一個復合Annotation,其自身定義關鍵信息如下：
@SuppressWarnings("deprecation")
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage【重點注解】
@Import(EnableAutoConfigurationImportSelector.class)【重點注解】
public @interface EnableAutoConfiguration {
...
}
其中最重要的兩個注解已經標注：1、@AutoConfigurationPackage【重點注解】2、@Import(EnableAutoConfigurationImportSelector.class)【重點注解】
當然還有其中比較重要的一個類就是：EnableAutoConfigurationImportSelector.class
AutoConfigurationPackage注解：
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry) {
register(registry, new PackageImport(metadata).getPackageName());
}
Import(AutoConfigurationImportSelector.class)注解：
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
AnnotationAttributes attributes = getAttributes(annotationMetadata);
List<String> configurations = getCandidateConfigurations(annotationMetadata,attributes);
configurations = removeDuplicates(configurations);
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
configurations = filter(configurations, autoConfigurationMetadata);
fireAutoConfigurationImportEvents(configurations, exclusions);
return StringUtils.toStringArray(configurations);
}
自動配置幕后英雄：SpringFactoriesLoader詳解
public abstract class SpringFactoriesLoader {
//...
public static <T> List<T> loadFactories(Class<T> factoryClass, ClassLoader classLoader) {
...
}
public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
....
}
}
四、springboot啟動流程概覽圖
深入探索SpringApplication執行流程
public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
return new SpringApplication(sources).run(args);
}
- 根據classpath里面是否存在某個特征類（org.springframework.web.context.ConfigurableWebApplicationContext）來決定是否應該創建一個為Web應用使用的ApplicationContext類型。
- 使用SpringFactoriesLoader在應用的classpath中查找並加載所有可用的ApplicationContextInitializer。
- 使用SpringFactoriesLoader在應用的classpath中查找並加載所有可用的ApplicationListener。
- 推斷並設置main方法的定義類。
@SuppressWarnings({ "unchecked", "rawtypes" }) private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } this.webEnvironment = deduceWebEnvironment(); setInitializers((Collection) getSpringFactoriesInstances( ApplicationContextInitializer.class)); setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); this.mainApplicationClass = deduceMainApplicationClass(); }2） SpringApplication實例初始化完成並且完成設置后，就開始執行run方法的邏輯了，方法執行伊始，首先遍歷執行所有通過SpringFactoriesLoader可以查找到並加載的SpringApplicationRunListener。調用它們的started()方法，告訴這些SpringApplicationRunListener，“嘿，SpringBoot應用要開始執行咯！”。
-
public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; FailureAnalyzers analyzers = null; configureHeadlessProperty(); SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); try { ApplicationArguments applicationArguments = new DefaultApplicationArguments( args); ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); Banner printedBanner = printBanner(environment); context = createApplicationContext(); analyzers = new FailureAnalyzers(context); prepareContext(context, environment, listeners, applicationArguments, printedBanner); // 核心點：會打印springboot的啟動標志，直到server.port端口啟動 refreshContext(context); afterRefresh(context, applicationArguments); listeners.finished(context, null); stopWatch.stop(); if (this.logStartupInfo) { new StartupInfoLogger(this.mainApplicationClass) .logStarted(getApplicationLog(), stopWatch); } return context; } catch (Throwable ex) { handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex); } }3） 創建並配置當前Spring Boot應用將要使用的Environment（包括配置要使用的PropertySource以及Profile）。
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,ApplicationArguments applicationArguments) {
// Create and configure the environment
ConfigurableEnvironment environment = getOrCreateEnvironment();
configureEnvironment(environment, applicationArguments.getSourceArgs());
listeners.environmentPrepared(environment);
if (!this.webEnvironment) {
environment = new EnvironmentConverter(getClassLoader()).convertToStandardEnvironmentIfNecessary(environment);
}
return environment;
}
4） 遍歷調用所有SpringApplicationRunListener的environmentPrepared()的方法，告訴他們：“當前SpringBoot應用使用的Environment准備好了咯！”。
public void environmentPrepared(ConfigurableEnvironment environment) {
for (SpringApplicationRunListener listener : this.listeners) {
listener.environmentPrepared(environment);
}
}
private Banner printBanner(ConfigurableEnvironment environment) {
if (this.bannerMode == Banner.Mode.OFF) {
return null;
}
ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader: new DefaultResourceLoader(getClassLoader());
SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(resourceLoader, this.banner);
if (this.bannerMode == Mode.LOG) {
return bannerPrinter.print(environment, this.mainApplicationClass, logger);
}
return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}
6） 根據用戶是否明確設置了applicationContextClass類型以及初始化階段的推斷結果，決定該為當前SpringBoot應用創建什么類型的ApplicationContext並創建完成，然后根據條件決定是否添加ShutdownHook，決定是否使用自定義的BeanNameGenerator，決定是否使用自定義的ResourceLoader，當然，最重要的，將之前准備好的Environment設置給創建好的ApplicationContext使用。
7） ApplicationContext創建好之后，SpringApplication會再次借助Spring-FactoriesLoader，查找並加載classpath中所有可用的ApplicationContext-Initializer，然后遍歷調用這些ApplicationContextInitializer的initialize（applicationContext）方法來對已經創建好的ApplicationContext進行進一步的處理。
@SuppressWarnings({ "rawtypes", "unchecked" })
protected void applyInitializers(ConfigurableApplicationContext context) {
for (ApplicationContextInitializer initializer : getInitializers()) {
Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class);
Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
initializer.initialize(context);
}
}
8） 遍歷調用所有SpringApplicationRunListener的contextPrepared()方法。
private void prepareContext(ConfigurableApplicationContext context,ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
ApplicationArguments applicationArguments, Banner printedBanner) { context.setEnvironment(environment); postProcessApplicationContext(context); applyInitializers(context); listeners.contextPrepared(context); if (this.logStartupInfo) { logStartupInfo(context.getParent() == null); logStartupProfileInfo(context); } // Add boot specific singleton beans context.getBeanFactory().registerSingleton("springApplicationArguments",applicationArguments); if (printedBanner != null) { context.getBeanFactory().registerSingleton("springBootBanner", printedBanner); } // Load the sources Set<Object> sources = getSources(); Assert.notEmpty(sources, "Sources must not be empty"); load(context, sources.toArray(new Object[sources.size()])); listeners.contextLoaded(context); }
9)最核心的一步，將之前通過@EnableAutoConfiguration獲取的所有配置以及其他形式的IoC容器配置加載到已經准備完畢的ApplicationContext。
private void prepareAnalyzer(ConfigurableApplicationContext context,FailureAnalyzer analyzer) {
if (analyzer instanceof BeanFactoryAware) {
((BeanFactoryAware) analyzer).setBeanFactory(context.getBeanFactory());
}
}
10） 遍歷調用所有SpringApplicationRunListener的contextLoaded()方法。
public void contextLoaded(ConfigurableApplicationContext context) {
for (SpringApplicationRunListener listener : this.listeners) {
listener.contextLoaded(context);
}
}
11) 調用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。
private void refreshContext(ConfigurableApplicationContext context) {
refresh(context);
if (this.registerShutdownHook) {
try {
context.registerShutdownHook();
}catch (AccessControlException ex) {
// Not allowed in some environments.
}
}
}
12） 查找當前ApplicationContext中是否注冊有CommandLineRunner，如果有，則遍歷執行它們。
private void callRunners(ApplicationContext context, ApplicationArguments args) {
List<Object> runners = new ArrayList<Object>();
runners.addAll(context.getBeansOfType(ApplicationRunner.class).values());
runners.addAll(context.getBeansOfType(CommandLineRunner.class).values());
AnnotationAwareOrderComparator.sort(runners);
for (Object runner : new LinkedHashSet<Object>(runners)) {
if (runner instanceof ApplicationRunner) {
callRunner((ApplicationRunner) runner, args);
}
if (runner instanceof CommandLineRunner) {
callRunner((CommandLineRunner) runner, args);
}
}
}
public void finished(ConfigurableApplicationContext context, Throwable exception) {
for (SpringApplicationRunListener listener : this.listeners) {
callFinishedListener(listener, context, exception);
}
}
