@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// SpringApplication.run() 內(nèi)部
public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
    return new SpringApplication(primarySource).run(args);  // 先構(gòu)造，再運(yùn)行
}

static WebApplicationType deduceFromClasspath() {
    if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", null)
            && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", null)) {
        return WebApplicationType.REACTIVE;  // WebFlux
    }
    for (String className : SERVLET_INDICATOR_CLASSES) {  // Servlet 相關(guān)類
        if (!ClassUtils.isPresent(className, null)) {
            return WebApplicationType.NONE;  // 非 Web
        }
    }
    return WebApplicationType.SERVLET;  // Spring MVC（默認(rèn)）
}

public ConfigurableApplicationContext run(String... args) {
    // 1. 啟動(dòng)計(jì)時(shí)器
    StartupStep startupStep = this.applicationStartup.start("spring.boot.application.starting");
    
    // 2. 創(chuàng)建 DefaultBootstrapContext（引導(dǎo)上下文）
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    
    ConfigurableApplicationContext context = null;
    
    // 3. 配置 Headless 模式（無(wú)顯示器環(huán)境）
    configureHeadlessProperty();
    
    // 4. 發(fā)布啟動(dòng)事件（監(jiān)聽器可以在此介入）
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    
    try {
        // 5. 封裝命令行參數(shù)
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        
        // 6. 【關(guān)鍵】準(zhǔn)備 Environment（加載配置文件）
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        
        // 7. 打印 Banner
        Banner printedBanner = printBanner(environment);
        
        // 8. 【關(guān)鍵】創(chuàng)建 ApplicationContext（根據(jù)類型創(chuàng)建）
        context = createApplicationContext();
        context.setApplicationStartup(this.applicationStartup);
        
        // 9. 【核心】準(zhǔn)備 Context（加載自動(dòng)配置在此?。?
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        
        // 10. 【核心】刷新 Context（Bean 定義加載 + 實(shí)例化）
        refreshContext(context);
        
        // 11. 后置處理
        afterRefresh(context, applicationArguments);
        
        startupStep.end();
        listeners.started(context);
        
        // 12. 執(zhí)行 Runner（ApplicationRunner / CommandLineRunner）
        callRunners(context, applicationArguments);
        
    } catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    
    listeners.running(context);
    return context;
}

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    
    // 1. 創(chuàng)建或獲取 Environment（StandardServletEnvironment）
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    
    // 2. 配置 PropertySources 和 Profiles
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    
    // 3. 【關(guān)鍵】發(fā)布環(huán)境準(zhǔn)備事件，ConfigFileApplicationListener 響應(yīng)
    //    這里加載 application.yml / application-{profile}.yml
    listeners.environmentPrepared(bootstrapContext, environment);
    
    return environment;
}

protected ConfigurableApplicationContext createApplicationContext() {
    return this.applicationContextFactory.apply(this.webApplicationType);
}

// 根據(jù)類型創(chuàng)建不同上下文
switch (webApplicationType) {
    case SERVLET:
        // AnnotationConfigServletWebServerApplicationContext
        return new ServletWebServerApplicationContext();
    case REACTIVE:
        // AnnotationConfigReactiveWebServerApplicationContext  
        return new ReactiveWebServerApplicationContext();
    default:
        // AnnotationConfigApplicationContext
        return new ApplicationContext();
}

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    
    // 1. 設(shè)置 Environment
    context.setEnvironment(environment);
    
    // 2. 后置處理 Context（注冊(cè) beanNameGenerator、resourceLoader 等）
    postProcessApplicationContext(context);
    
    // 3. 【關(guān)鍵】執(zhí)行 ApplicationContextInitializer
    applyInitializers(context);
    
    // 4. 發(fā)布 ContextPrepared 事件
    listeners.contextPrepared(context);
    
    // 5. 注冊(cè) Spring Boot 特殊 Bean
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    
    // 6. 【核心】加載主類（@SpringBootApplication 所在類）
    Set<Object> sources = getAllSources();
    load(context, sources.toArray(new Object[0]));  // 注冊(cè)為 BeanDefinition
    
    // 7. 發(fā)布 ContextLoaded 事件
    listeners.contextLoaded(context);
}

public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 準(zhǔn)備刷新（設(shè)置啟動(dòng)時(shí)間、狀態(tài)等）
        prepareRefresh();
        
        // 2. 獲取 BeanFactory（DefaultListableBeanFactory）
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        
        // 3. 準(zhǔn)備 BeanFactory（注冊(cè)類加載器、表達(dá)式解析器等）
        prepareBeanFactory(beanFactory);
        
        try {
            // 4. 子類擴(kuò)展（ServletContext 相關(guān)處理）
            postProcessBeanFactory(beanFactory);
            
            // 5. 【關(guān)鍵】執(zhí)行 BeanFactoryPostProcessor
            //    ConfigurationClassPostProcessor 在這里處理 @Configuration 類
            invokeBeanFactoryPostProcessors(beanFactory);
            
            // 6. 注冊(cè) BeanPostProcessor
            registerBeanPostProcessors(beanFactory);
            
            // 7. 初始化 MessageSource
            initMessageSource();
            
            // 8. 初始化 ApplicationEventMulticaster
            initApplicationEventMulticaster();
            
            // 9. 子類擴(kuò)展（創(chuàng)建 WebServer，如 Tomcat）
            onRefresh();
            
            // 10. 注冊(cè)監(jiān)聽器
            registerListeners();
            
            // 11. 【關(guān)鍵】實(shí)例化所有非懶加載的單例 Bean
            finishBeanFactoryInitialization(beanFactory);
            
            // 12. 完成刷新（發(fā)布 ContextRefreshedEvent）
            finishRefresh();
        }
        // ...
    }
}

// ConfigurationClassPostProcessor 處理 @Configuration 類
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 解析 @Configuration 類，包括 @ComponentScan、@Import、@Bean 等
    processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}

@SpringBootApplication  // 組合注解
public class Application { }

// 等價(jià)于：
@Configuration
@EnableAutoConfiguration      // 【核心】開啟自動(dòng)配置
@ComponentScan                // 組件掃描
public class Application { }

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage      // 將主類所在包注冊(cè)為自動(dòng)配置包
@Import(AutoConfigurationImportSelector.class)  // 【核心】導(dǎo)入自動(dòng)配置類
public @interface EnableAutoConfiguration {}

public class AutoConfigurationImportSelector implements 
        DeferredImportSelector, BeanClassLoaderAware, ... {
    
    @Override
    public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // 1. 檢查是否啟用自動(dòng)配置（spring.boot.enableautoconfiguration）
        if (!isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        }
        
        // 2. 從 META-INF/spring-autoconfigure-metadata.properties 加載元數(shù)據(jù)
        AutoConfigurationMetadata autoConfigurationMetadata = 
            AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
        
        // 3. 【關(guān)鍵】獲取候選自動(dòng)配置類
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        
        // 4. 去重
        configurations = removeDuplicates(configurations);
        
        // 5. 獲取需要排除的類（@EnableAutoConfiguration(exclude=...)）
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        
        // 6. 檢查排除類合法性
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        
        // 7. 【關(guān)鍵】按條件過(guò)濾（@Conditional 評(píng)估）
        configurations = getConfigurationClassFilter().filter(configurations);
        
        // 8. 發(fā)布自動(dòng)配置導(dǎo)入事件
        fireAutoConfigurationImportEvents(configurations, exclusions);
        
        return StringUtils.toStringArray(configurations);
    }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
        AnnotationAttributes attributes) {
    // 從 META-INF/spring.factories 加載
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
        getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
    
    Assert.notEmpty(configurations, 
        "No auto configuration classes found in META-INF/spring.factories");
    
    return configurations;
}

// spring.factories 示例（Spring Boot 2.7+ 改為 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports）
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
...（約 100+ 個(gè)）

private List<String> filter(List<String> configurations, AutoConfigurationMetadata autoConfigurationMetadata) {
    long startTime = System.nanoTime();
    String[] candidates = StringUtils.toStringArray(configurations);
    boolean[] skip = new boolean[candidates.length];
    boolean skipped = false;
    
    // 獲取所有條件過(guò)濾器（OnClassCondition, OnBeanCondition, OnPropertyCondition 等）
    for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
        invokeAwareMethods(filter);
        
        // 批量匹配條件（優(yōu)化性能，避免每個(gè)類單獨(dú)檢查）
        boolean[] match = filter.match(candidates, autoConfigurationMetadata);
        
        for (int i = 0; i < match.length; i++) {
            if (!match[i]) {
                skip[i] = true;
                candidates[i] = null;  // 標(biāo)記為跳過(guò)
                skipped = true;
            }
        }
    }
    
    // 收集通過(guò)的類
    if (!skipped) {
        return configurations;
    }
    List<String> result = new ArrayList<>(candidates.length);
    for (int i = 0; i < candidates.length; i++) {
        if (!skip[i]) {
            result.add(candidates[i]);
        }
    }
    return result;
}