启动流程源码剖析

// SpringApplication.java
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);
}

// SpringApplication.java
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));

    // 1. 推断应用类型（Servlet / Reactive / None）
    this.webApplicationType = WebApplicationType.deduceFromClasspath();

    // 2. 从 spring.factories 加载 ApplicationContextInitializer
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));

    // 3. 从 spring.factories 加载 ApplicationListener
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

    // 4. 推断主配置类（main 方法所在类）
    this.mainApplicationClass = deduceMainApplicationClass();
}

// WebApplicationType.java
static WebApplicationType deduceFromClasspath() {
    // 如果有 Reactive 的 DispatcherHandler 且没有 Servlet 的 DispatcherServlet
    if (ClassUtils.isPresent("org.springframework.web.reactive.DispatcherHandler", null)
        && !ClassUtils.isPresent("org.springframework.web.servlet.DispatcherServlet", null)) {
        return REACTIVE;
    }
    // 如果没有 Servlet 或 Spring MVC 的核心类
    for (String className : SERVLET_INDICATOR_CLASSES) {
        if (!ClassUtils.isPresent(className, null)) {
            return NONE;
        }
    }
    // 默认：Servlet Web 应用
    return SERVLET;
}

// SpringApplication.java
private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // 创建 Environment（Servlet → StandardServletEnvironment）
    ConfigurableEnvironment environment = getOrCreateEnvironment();

    // 配置 Environment：命令行参数、Profile 等
    configureEnvironment(environment, applicationArguments.getSourceArgs());

    // 将 ConfigurationProperties 绑定到 SpringApplication
    ConfigurationPropertySources.attach(environment);

    // 发布 EnvironmentPrepared 事件
    listeners.environmentPrepared(environment);

    return environment;
}

// SpringApplication.java
protected ConfigurableApplicationContext createApplicationContext() {
    return this.applicationContextFactory.create(this.webApplicationType);
}

// ApplicationContextFactory 默认实现
switch (webApplicationType) {
    case SERVLET:
        return new AnnotationConfigServletWebServerApplicationContext();
    case REACTIVE:
        return new AnnotationConfigReactiveWebServerApplicationContext();
    default:
        return new AnnotationConfigApplicationContext();
}

// SpringApplication.java
private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner banner) {

    // 1. 设置 Environment
    context.setEnvironment(environment);

    // 2. 后处理 ApplicationContext（设置 BeanNameGenerator、ResourceLoader 等）
    postProcessApplicationContext(context);

    // 3. 执行所有 ApplicationContextInitializer
    applyInitializers(context);

    // 4. 发布 ApplicationContextInitializedEvent
    listeners.contextPrepared(context);

    // 5. 注册特殊 Bean（bootstrap 拦截器等）
    bootstrapContext.close();

    // 6. 注册主配置类的 BeanDefinition
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "No sources found");
    load(context, sources.toArray(new Object[0]));

    // 7. 发布 ApplicationPreparedEvent
    listeners.contextLoaded(context);
}

// AbstractApplicationContext.java
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // 1. 准备刷新：记录启动时间、设置状态标志
        prepareRefresh();

        // 2. 获取 BeanFactory（刚创建的空工厂）
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

        // 3. 配置 BeanFactory：注册标准 BeanPostProcessor
        prepareBeanFactory(beanFactory);

        try {
            // 4. 子类后处理：注册 Web 相关的 Scope 等
            postProcessBeanFactory(beanFactory);

            // 5. 执行 BeanFactoryPostProcessor（关键！）
            invokeBeanFactoryPostProcessors(beanFactory);

            // 6. 注册 BeanPostProcessor
            registerBeanPostProcessors(beanFactory);

            // 7. 初始化 MessageSource（国际化）
            initMessageSource();

            // 8. 初始化事件广播器
            initApplicationEventMulticaster();

            // 9. 子类特殊初始化：启动内嵌 Web 容器
            onRefresh();

            // 10. 注册监听器
            registerListeners();

            // 11. 初始化所有单例 Bean（非 lazy-init）
            finishBeanFactoryInitialization(beanFactory);

            // 12. 完成刷新：发布 ContextRefreshedEvent
            finishRefresh();
        } catch (BeansException ex) {
            destroyBeans();
            cancelRefresh(ex);
            throw ex;
        }
    }
}

// ServletWebServerApplicationContext.java
protected void onRefresh() {
    super.onRefresh();
    try {
        createWebServer();  // 创建并启动 Tomcat/Jetty/Undertow
    } 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) {
        // 获取 ServletWebServerFactory（TomcatServletWebServerFactory 等）
        ServletWebServerFactory factory = getWebServerFactory();
        this.webServer = factory.getWebServer(getSelfInitializer());
    }
    // ...
}

// AbstractApplicationContext.java
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // 初始化 ConversionService
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME)
        && beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }

    // 注册嵌入式值解析器（解析 ${...} 占位符）
    if (!beanFactory.hasEmbeddedValueResolver()) {
        beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolveRequiredPlaceholders(strVal));
    }

    // 初始化所有单例 Bean
    beanFactory.preInstantiateSingletons();
}

@Component
public class StartupListener {

    @EventListener
    public void onReady(ApplicationReadyEvent event) {
        // 所有 Bean 已就绪，可以执行预热逻辑
        log.info("应用已就绪，开始预热缓存...");
    }

    @EventListener
    public void onFailed(ApplicationFailedEvent event) {
        // 启动失败，发送告警
        log.error("应用启动失败：{}", event.getException().getMessage());
    }
}

// 在容器创建之前生效的事件，需要通过 spring.factories 注册
public class EarlyListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // 修改 Environment 配置
        event.getEnvironment().getSystemProperties().put("custom.key", "custom.value");
    }
}

## META-INF/spring.factories
org.springframework.context.ApplicationListener=\
  com.example.EarlyListener

// 自定义 Initializer
public class MyInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableApplicationContext context) {
        // 在容器刷新前添加自定义 BeanDefinition
        context.getBeanFactory().registerSingleton("myBean", new MyBean());

        // 或修改 Environment
        context.getEnvironment().getSystemProperties().put("my.key", "my.value");
    }
}

## META-INF/spring.factories
org.springframework.context.ApplicationContextInitializer=\
  com.example.MyInitializer

// 或通过代码注册
SpringApplication app = new SpringApplication(Application.class);
app.addInitializers(new MyInitializer());
app.run(args);

// 自定义 EnvironmentPostProcessor
public class MyEnvironmentPostProcessor implements EnvironmentPostProcessor {
    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
                                       SpringApplication application) {
        // 根据运行环境动态设置配置
        String env = environment.getProperty("app.env", "dev");

        Map<String, Object> defaults = new HashMap<>();
        if ("prod".equals(env)) {
            defaults.put("server.tomcat.max-threads", "500");
            defaults.put("spring.datasource.hikari.maximum-pool-size", "50");
        } else {
            defaults.put("server.tomcat.max-threads", "100");
            defaults.put("spring.datasource.hikari.maximum-pool-size", "10");
        }

        // 添加默认属性（优先级最低，可被其他配置源覆盖）
        environment.getPropertySources()
            .addLast(new MapPropertySource("myDefaults", defaults));
    }
}

## META-INF/spring.factories
org.springframework.boot.env.EnvironmentPostProcessor=\
  com.example.MyEnvironmentPostProcessor

// SpringFactoriesLoader.java
public static <T> List<T> loadFactories(Class<T> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }
    // 加载所有 META-INF/spring.factories 中指定类型的实现类名
    List<String> factoryImplementationNames = loadFactoryNames(factoryType, classLoaderToUse);
    // 实例化每个实现类
    List<T> result = new ArrayList<>(factoryImplementationNames.size());
    for (String factoryImplementationName : factoryImplementationNames) {
        result.add(instantiateFactory(factoryImplementationName, factoryType, classLoaderToUse));
    }
    AnnotationAwareOrderComparator.sort(result);  // 按 @Order 排序
    return result;
}

// ApplicationRunner：接收 ApplicationArguments（解析好的参数）
@Component
@Order(1)  // 数字越小优先级越高
public class MyApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        // args.getOptionValues("key") 获取选项参数
        // args.getNonOptionArgs() 获取非选项参数
        log.info("ApplicationRunner 执行，参数：{}", args.getSourceArgs());
    }
}

// CommandLineRunner：接收原始 String[]
@Component
@Order(2)
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) throws Exception {
        log.info("CommandLineRunner 执行，参数：{}", Arrays.toString(args));
    }
}

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setLazyInitialization(true);  // 所有单例 Bean 延迟初始化
        app.run(args);
    }
}

## 或通过配置
spring:
  main:
    lazy-initialization: true

@SpringBootApplication(exclude = {
    DataSourceAutoConfiguration.class,     // 不需要数据库
    HibernateJpaAutoConfiguration.class,   // 不需要 JPA
    RedisAutoConfiguration.class           // 不需要 Redis
})
public class Application { ... }

## 使用 GraalVM 编译为原生镜像
mvn -Pnative native:compile

## 启动时间从秒级降到毫秒级
./target/myapp

## 推荐 JVM 启动参数
java -jar myapp.jar \
  -Xms512m -Xmx512m \              # 堆内存固定，避免动态扩展开销
  -XX:+UseG1GC \                    # G1 垃圾收集器
  -XX:MaxGCPauseMillis=200 \        # GC 停顿目标
  -XX:+HeapDumpOnOutOfMemoryError \ # OOM 时自动 dump
  -XX:HeapDumpPath=/logs/heap.hprof \
  -Djava.security.egd=file:/dev/./urandom \  # 加快 SecureRandom 初始化
  -Dspring.background-processor.init-delay=2s  # 后台处理器延迟

// SpringApplication.java
private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        DefaultBootstrapContext bootstrapContext,
        ApplicationArguments applicationArguments) {

    // 1. 创建或获取 Environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();

    // 2. 配置 Environment：设置命令行参数、Profile
    configureEnvironment(environment, applicationArguments.getSourceArgs());

    // 3. 将 ConfigurationPropertySources 附加到 Environment
    //    这一步把所有 PropertySource 包装为 ConfigurationPropertySource
    ConfigurationPropertySources.attach(environment);

    // 4. 发布 ApplicationEnvironmentPreparedEvent
    //    触发所有 EnvironmentPostProcessor 执行
    listeners.environmentPrepared(bootstrapContext, environment);

    // 5. 将默认属性移到末尾（确保优先级最低）
    DefaultPropertiesPropertySource.moveToEnd(environment);

    // 6. 断言必须的属性是否存在
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
        "Environment prefix cannot be set via properties");

    // 7. 绑定 spring.main.* 配置到 SpringApplication
    bindToSpringApplication(environment);

    // 8. 如果用户没有指定应用类型，根据配置再次推断
    if (!this.isCustomEnvironment) {
        environment = convertEnvironment(environment);
    }

    // 9. 创建 ConfigurationPropertySourcesPropertySource
    //    并添加到 Environment 的 PropertySource 列表首位
    ConfigurationPropertySources.finish(environment);

    return environment;
}

// SpringApplication.java
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // 1. 添加命令行参数转换的 PropertySource
    if (this.addCommandLineProperties && args.length > 0) {
        // 将 --key=value 格式的参数转为 PropertySource
        // 优先级：命令行非选项参数 > 命令行选项参数
        CommandLinePropertySource<?> commandLinePropertySource =
            new SimpleCommandLinePropertySource(args);
        environment.getPropertySources().addFirst(commandLinePropertySource);
    }

    // 2. 配置 ConversionService（类型转换器）
    ConfigurationPropertySources.attach(environment);

    // 3. 设置活跃 Profile
    Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);
    profiles.addAll(Arrays.asList(environment.getActiveProfiles()));
    environment.setActiveProfiles(profiles.toArray(new String[0]));
}

// ConfigDataEnvironmentPostProcessor.java
public class ConfigDataEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
                                       SpringApplication application) {
        // 1. 创建 ConfigDataEnvironment
        ConfigDataEnvironment configDataEnvironment =
            ConfigDataEnvironment.from(environment, this.resolvers, this.importers);

        // 2. 处理 ConfigData 导入
        //    包括 application.yml、application-{profile}.yml 等
        configDataEnvironment.processAndApply();
    }
}

// 自定义 PropertySource：从数据库加载配置
public class DatabasePropertySource extends PropertySource<JdbcTemplate> {

    private final Map<String, Object> properties = new ConcurrentHashMap<>();

    public DatabasePropertySource(String name, JdbcTemplate source) {
        super(name, source);
        loadProperties();
    }

    private void loadProperties() {
        // 从数据库加载配置
        List<Map<String, Object>> rows = getSource()
            .queryForList("SELECT config_key, config_value FROM app_config");
        for (Map<String, Object> row : rows) {
            properties.put((String) row.get("config_key"), row.get("config_value"));
        }
    }

    @Override
    public Object getProperty(String name) {
        return properties.get(name);
    }
}

// 通过 EnvironmentPostProcessor 注册自定义 PropertySource
public class DatabaseEnvironmentPostProcessor implements EnvironmentPostProcessor {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
                                       SpringApplication application) {
        // 从已有的数据源配置中获取连接信息
        String url = environment.getProperty("spring.datasource.url");
        String username = environment.getProperty("spring.datasource.username");
        String password = environment.getProperty("spring.datasource.password");

        if (url != null) {
            DataSource dataSource = DataSourceBuilder.create()
                .url(url).username(username).password(password).build();
            JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

            // 创建并注册 PropertySource（优先级高于 application.yml）
            DatabasePropertySource propertySource =
                new DatabasePropertySource("databaseConfig", jdbcTemplate);
            environment.getPropertySources().addAfter(
                "applicationConfigurationProperties", propertySource);
        }
    }
}

// SpringApplication.java
private Banner printBanner(ConfigurableEnvironment environment) {
    if (this.bannerMode == Banner.Mode.OFF) {
        return null;
    }

    // 如果没有自定义 Banner，使用默认的 Spring Boot Banner
    if (this.bannerMode == Banner.Mode.LOG) {
        // 输出到日志
    } else {
        // 输出到控制台
    }

    ResourceLoader resourceLoader = this.resourceLoader;
    if (resourceLoader == null) {
        resourceLoader = new DefaultResourceLoader(null);
    }

    // 查找 banner.txt 文件
    SpringApplicationBannerPrinter bannerPrinter =
        new SpringApplicationBannerPrinter(resourceLoader, this.banner);

    // 优先查找图片 Banner：banner.gif / banner.jpg / banner.png
    // 其次查找文本 Banner：banner.txt
    if (this.bannerMode == Mode.LOG) {
        return bannerPrinter.print(environment, this.mainApplicationClass, logger);
    }
    return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
}

${AnsiColor.BRIGHT_CYAN}
  ____  _     _       _
 / ___|| |__ (_)___  (_)___
| |    | '_ \| / __| | / __|
| |___ | | | | \__ \ | \__ \
 \____||_| |_|_|___/ |_|___/

${AnsiColor.DEFAULT}
:: Spring Boot ::  ${spring-boot.version}
:: Application ::  ${spring.application.name:vitepress}
:: Profile ::     ${spring.profiles.active:default}
:: Port ::        ${server.port:8080}

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setBanner((environment, sourceClass, out) -> {
            out.println("========================================");
            out.println("  自定义应用启动中...");
            out.println("  环境: " + environment.getActiveProfiles()[0]);
            out.println("  端口: " + environment.getProperty("server.port", "8080"));
            out.println("========================================");
        });
        app.setBannerMode(Banner.Mode.CONSOLE);  // 输出到控制台
        app.run(args);
    }
}

// 方式一：代码关闭
SpringApplication app = new SpringApplication(Application.class);
app.setBannerMode(Banner.Mode.OFF);
app.run(args);

// 方式二：配置关闭
spring:
  main:
    banner-mode: off

// 方式三：命令行关闭
java -jar myapp.jar --spring.main.banner-mode=off

// AbstractApplicationContext.java
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    // 1. 设置 ClassLoader
    beanFactory.setBeanClassLoader(getClassLoader());

    // 2. 注册标准表达式解析器（解析 #{...} SpEL 表达式）
    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));

    // 3. 注册属性编辑器注册器（处理 XML 配置中的类型转换）
    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

    // 4. 注册 ApplicationContextAwareProcessor（处理 Aware 接口回调）
    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));

    // 5. 忽略以下接口的自动装配（因为由 AwareProcessor 处理）
    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

    // 6. 注册特殊依赖的解析规则
    //    当 Bean 声明注入这些类型时，直接返回固定对象而非去容器查找
    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    beanFactory.registerResolvableDependency(ApplicationContext.class, this);

    // 7. 注册 ApplicationListenerDetector（检测实现了 ApplicationListener 的 Bean）
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

    // 8. 检测 LoadTimeWeaver（AOP 织入支持）
    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
        beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
        beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    }

    // 9. 注册默认的环境 Bean
    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    }
    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
        beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    }
}

// ApplicationContextAwareProcessor 核心逻辑
class ApplicationContextAwareProcessor implements BeanPostProcessor {

    private final ConfigurableApplicationContext applicationContext;

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 依次检查并注入 Aware 接口的依赖
        invokeAwareInterfaces(bean);
        return bean;
    }

    private void invokeAwareInterfaces(Object bean) {
        if (bean instanceof EnvironmentAware environmentAware) {
            environmentAware.setEnvironment(this.applicationContext.getEnvironment());
        }
        if (bean instanceof EmbeddedValueResolverAware resolverAware) {
            resolverAware.setEmbeddedValueResolver(this.applicationContext);
        }
        if (bean instanceof ResourceLoaderAware loaderAware) {
            loaderAware.setResourceLoader(this.applicationContext);
        }
        if (bean instanceof ApplicationEventPublisherAware publisherAware) {
            publisherAware.setApplicationEventPublisher(this.applicationContext);
        }
        if (bean instanceof MessageSourceAware sourceAware) {
            sourceAware.setMessageSource(this.applicationContext);
        }
        if (bean instanceof ApplicationContextAware contextAware) {
            contextAware.setApplicationContext(this.applicationContext);
        }
    }
}

// ConfigurationClassPostProcessor.java
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
    int registryId = registry.hashCode();
    // 防止重复处理
    if (this.registriesPostProcessed.contains(registryId)) {
        throw new IllegalStateException("postProcessBeanDefinitionRegistry already called");
    }
    this.registriesPostProcessed.add(registryId);
    processConfigBeanDefinitions(registry);
}

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    // 1. 从已有 BeanDefinition 中找出配置类
    List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    for (String beanName : registry.getBeanDefinitionNames()) {
        BeanDefinition beanDef = registry.getBeanDefinition(beanName);
        // 检查是否是 @Configuration 类
        if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // 2. 创建配置类解析器
    ConfigurationClassParser parser = new ConfigurationClassParser(
        this.metadataReaderFactory, this.problemReporter, this.environment,
        this.resourceLoader, this.componentScanAnnotationMemberNameFilter, registry);

    // 3. 解析配置类（递归处理 @Import、@ComponentScan 等）
    Set<ConfigurationClass> configClasses = new LinkedHashSet<>();
    do {
        // 解析每个配置类
        parser.parse(candidates);
        parser.validate();

        configClasses.addAll(parser.getConfigurationClasses());
        // 检查是否有新发现的配置类需要继续解析
        candidates = removeAlreadyParsed(classes, alreadyParsed);
    } while (!candidates.isEmpty());

    // 4. 读取配置类中定义的 Bean 并注册 BeanDefinition
    this.reader.loadBeanDefinitions(configClasses);
}

// AutoConfigurationImportSelector.java
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    }

    // 步骤 1：获取注解属性（exclude 等）
    AnnotationAttributes attributes = getAttributes(annotationMetadata);

    // 步骤 2：获取所有候选配置类（~140 个）
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

    // 步骤 3：去重
    configurations = removeDuplicates(configurations);

    // 步骤 4：排除指定的配置类
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);

    // 步骤 5：过滤——根据条件注解快速排除不满足的配置类
    //    使用 AutoConfigurationImportFilter 进行高效过滤
    //    不需要实际加载配置类，只检查 @ConditionalOnClass 等注解元数据
    configurations = getConfigurationClassFilter().filter(configurations);

    // 步骤 6：触发自动配置导入事件
    fireAutoConfigurationImportEvents(configurations, exclusions);

    return new AutoConfigurationEntry(configurations, exclusions);
}

// PostProcessorRegistrationDelegate.java
public static void registerBeanPostProcessors(
        ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

    // 1. 获取所有 BeanPostProcessor 的 BeanName
    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;

    // 2. 分类处理
    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();

    for (String ppName : postProcessorNames) {
        if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
            priorityOrderedPostProcessors.add(pp);
            if (pp instanceof MergedBeanDefinitionPostProcessor) {
                internalPostProcessors.add(pp);
            }
        } else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
            orderedPostProcessorNames.add(ppName);
        } else {
            nonOrderedPostProcessorNames.add(ppName);
        }
    }

    // 3. 按 PriorityOrdered → Ordered → 无排序 的顺序注册
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        orderedPostProcessors.add(pp);
        // ...
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, orderedPostProcessors);

    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
        nonOrderedPostProcessors.add(pp);
        // ...
    }
    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

    // 4. 最后注册 MergedBeanDefinitionPostProcessor
    sortPostProcessors(internalPostProcessors, beanFactory);
    registerBeanPostProcessors(beanFactory, internalPostProcessors);

    // 5. 注册 ApplicationListenerDetector
    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

// AbstractApplicationContext.java
protected void finishRefresh() {
    // 1. 清除资源缓存
    clearResourceCaches();

    // 2. 初始化 LifecycleProcessor（生命周期处理器）
    initLifecycleProcessor();

    // 3. 调用 LifecycleProcessor.onRefresh()——启动所有 SmartLifecycle Bean
    getLifecycleProcessor().onRefresh();

    // 4. 发布 ContextRefreshedEvent
    publishEvent(new ContextRefreshedEvent(this));

    // 5. 向 MBeanServer 注册 JMX 信息（如果启用）
    if (!NativeDetector.inNativeImage()) {
        LiveBeansView.registerApplicationContext(this);
    }
}

// 自定义 Lifecycle Bean
@Component
public class MyLifecycleBean implements SmartLifecycle {

    private volatile boolean running = false;

    @Override
    public void start() {
        log.info("MyLifecycleBean 启动");
        this.running = true;
    }

    @Override
    public void stop() {
        log.info("MyLifecycleBean 停止");
        this.running = false;
    }

    @Override
    public void stop(Runnable callback) {
        // 支持异步停止，完成后调用 callback
        new Thread(() -> {
            try {
                Thread.sleep(1000);  // 模拟优雅停机
                stop();
            } finally {
                callback.run();
            }
        }).start();
    }

    @Override
    public boolean isRunning() {
        return this.running;
    }

    @Override
    public boolean isAutoStartup() {
        return true;  // 容器刷新时自动启动
    }

    @Override
    public int getPhase() {
        return 0;  // 数字越小越先启动、越后停止
    }
}

// SpringApplication.java
public ConfigurableApplicationContext run(String... args) {
    // ...
    try {
        // 注册 Shutdown Hook
        if (this.registerShutdownHook) {
            shutdownHook.registerApplicationContext(context);
        }
        // ...
    } catch (Throwable ex) {
        handleRunFailure(context, ex, listeners);
    }
}

// AbstractApplicationContext.java
protected void doClose() {
    // 检查是否正在运行
    if (this.active.get() && this.closed.compareAndSet(false, true)) {
        // 1. 发布 ContextClosedEvent
        publishEvent(new ContextClosedEvent(this));

        // 2. 停止所有 Lifecycle Bean
        if (this.lifecycleProcessor != null) {
            this.lifecycleProcessor.onClose();
        }

        // 3. 销毁所有单例 Bean
        destroyBeans();

        // 4. 关闭 BeanFactory
        closeBeanFactory();

        // 5. 子类清理
        onClose();

        // 6. 重置状态
        this.active.set(false);
    }
}

## application.yml
server:
  shutdown: graceful  # 启用优雅停机

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s  # 每个关闭阶段超时时间

// Spring Boot 2.3+ 优雅停机工作原理
// 1. 接收 SIGTERM 信号
// 2. Web Server 停止接收新请求
// 3. 等待现有请求处理完成（最多 30s）
// 4. 关闭 Spring 容器
// 5. 销毁所有 Bean

// 自定义优雅停机的线程池
@Configuration
public class AsyncConfig {

    @Bean
    public TaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setWaitForTasksToCompleteOnShutdown(true);  // 等待任务完成
        executor.setAwaitTerminationSeconds(60);  // 最多等 60 秒
        executor.initialize();
        return executor;
    }
}

## Kubernetes 部署配置
## 确保 Pod 优雅终止
spec:
  terminationGracePeriodSeconds: 60
  containers:
    - name: myapp
      lifecycle:
        preStop:
          exec:
            command: ["sh", "-c", "sleep 10"]  # 等待 Service 注册表更新

// 自定义 BootstrapRegistryInitializer
public class MyBootstrapRegistryInitializer implements BootstrapRegistryInitializer {

    @Override
    public void initialize(BootstrapRegistry registry) {
        // 在 ApplicationContext 创建之前注册基础设施 Bean
        registry.register(MyInfrastructureService.class, context ->
            new MyInfrastructureService(context.get(ClassLoader.class))
        );
    }
}

// 注册方式
SpringApplication app = new SpringApplication(Application.class);
app.addBootstrapRegistryInitializer(new MyBootstrapRegistryInitializer());
app.run(args);

## 或通过 spring.factories 注册
org.springframework.boot.BootstrapRegistryInitializer=\
com.example.MyBootstrapRegistryInitializer

// Spring Boot 启动失败处理
private void handleRunFailure(ConfigurableApplicationContext context,
        Throwable exception, SpringApplicationRunListeners listeners) {

    try {
        // 1. 尝试分析异常
        FailureAnalyzers analyzers = null;
        if (context != null) {
            analyzers = new FailureAnalyzers(context);
        }

        // 2. 如果有匹配的 Analyzer，输出友好的错误报告
        FailureAnalysis analysis = analyzeFailure(exception, analyzers);
        if (analysis != null) {
            reportFailure(analysis);
        } else {
            // 3. 没有 Analyzer 能处理，输出原始异常堆栈
            log.error("Application run failed", exception);
        }
    } catch (Throwable ex) {
        log.error("Unable to provide failure analysis", ex);
    } finally {
        // 4. 清理资源
        if (context != null) {
            context.close();
        }
        listeners.failed(context, exception);
    }
}

// 自定义 FailureAnalyzer：处理 Redis 连接失败
public class RedisConnectionFailureAnalyzer extends AbstractFailureAnalyzer<RedisConnectionFailureException> {

    @Override
    protected FailureAnalysis analyze(Throwable rootFailure,
                                      RedisConnectionFailureException cause) {
        return new FailureAnalysis(
            // 问题描述
            "Redis 连接失败: " + cause.getMessage(),
            // 建议的修复方案
            "请检查以下配置:\n" +
            "1. Redis 服务是否已启动\n" +
            "2. spring.data.redis.host 和 port 是否正确\n" +
            "3. 如果是远程 Redis，检查防火墙和网络连通性\n" +
            "4. 如果不需要 Redis，排除 RedisAutoConfiguration:\n" +
            "   @SpringBootApplication(exclude = RedisAutoConfiguration.class)",
            cause
        );
    }
}

## META-INF/spring.factories
org.springframework.boot.diagnostics.FailureAnalyzer=\
com.example.RedisConnectionFailureAnalyzer

// AOT 处理生成的代码（构建时自动生成）
// target/generated/aot/com/example/Application__BeanDefinitions.java
public class Application__BeanDefinitions implements BeanDefinitionsSource {

    @Override
    public void accept(BeanDefinitionRegistry registry) {
        // 预先生成的 BeanDefinition 注册代码
        // 跳过了运行时的类路径扫描和条件判断
        registerBeanDefinition(registry, "myController", MyController.class);
        registerBeanDefinition(registry, "myService", MyService.class);
    }
}

// Spring Boot 3.x 启动事件序列
@Component
public class StartupEventListener {

    // 容器就绪前的可用性状态变化
    @EventListener
    public void onAvailabilityChange(AvailabilityChangeEvent<ReadinessState> event) {
        if (event.getState() == ReadinessState.ACCEPTING_TRAFFIC) {
            // 应用已准备好接收流量
            log.info("应用已就绪，可以接收请求");
        } else if (event.getState() == ReadinessState.REFUSING_TRAFFIC) {
            // 应用拒绝流量（正在关闭）
            log.info("应用正在关闭，拒绝新请求");
        }
    }

    // 存活状态变化
    @EventListener
    public void onLivenessChange(AvailabilityChangeEvent<LivenessState> event) {
        if (event.getState() == LivenessState.CORRECT) {
            // 应用内部状态正常
            log.info("应用存活状态正常");
        } else if (event.getState() == LivenessState.BROKEN) {
            // 应用内部状态异常（如死锁、资源耗尽）
            log.error("应用存活状态异常！");
        }
    }
}

// 从远程配置中心（如 Nacos）加载配置
public class NacosConfigEnvironmentPostProcessor implements EnvironmentPostProcessor, Ordered {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment,
                                       SpringApplication application) {
        String serverAddr = environment.getProperty("nacos.server-addr", "localhost:8848");
        String namespace = environment.getProperty("nacos.namespace", "public");
        String dataId = environment.getProperty("nacos.data-id", "application");

        try {
            // 从 Nacos 拉取配置
            NacosConfigService configService = new NacosConfigService(serverAddr, namespace);
            String config = configService.getConfig(dataId, "DEFAULT_GROUP", 5000);

            if (config != null) {
                // 将远程配置解析为 PropertySource 并添加到 Environment
                YamlPropertySourceLoader loader = new YamlPropertySourceLoader();
                List<PropertySource<?>> propertySources =
                    loader.load("nacosConfig", new ByteArrayResource(config.getBytes()));

                // 优先级高于 application.yml，低于命令行参数
                for (PropertySource<?> ps : propertySources) {
                    environment.getPropertySources().addAfter("applicationConfigurationProperties", ps);
                }
                log.info("从 Nacos 加载配置成功: dataId={}", dataId);
            }
        } catch (NacosException e) {
            log.warn("从 Nacos 加载配置失败，使用本地配置: {}", e.getMessage());
        }
    }

    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE - 1;  // 尽早执行
    }
}

// 使用 BufferingApplicationStartup 记录启动耗时
@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        // 开启启动步骤记录
        app.setApplicationStartup(new BufferingApplicationStartup(2048));
        ConfigurableApplicationContext context = app.run(args);

        // 分析启动耗时
        analyzeStartupTime(context);
    }

    private static void analyzeStartupTime(ConfigurableApplicationContext context) {
        ApplicationStartup startup = context.getApplicationStartup();
        if (!(startup instanceof BufferingApplicationStartup buffering)) {
            return;
        }

        List<StartupStep> steps = buffering.drain();

        // 1. 找出最耗时的 10 个步骤
        System.out.println("=== 启动耗时 Top 10 ===");
        steps.stream()
            .sorted(Comparator.comparing(
                (StartupStep s) -> s.getDuration().toMillis()).reversed())
            .limit(10)
            .forEach(s -> System.out.printf(
                "%-50s %5dms%n", s.getName(), s.getDuration().toMillis()));

        // 2. 按 Category 分组统计
        System.out.println("\n=== 分类耗时统计 ===");
        Map<String, Long> categoryTime = steps.stream()
            .collect(Collectors.groupingBy(
                s -> s.getName().split("\\.")[0],
                Collectors.summingLong(s -> s.getDuration().toMillis())));

        categoryTime.entrySet().stream()
            .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
            .forEach(e -> System.out.printf("%-30s %5dms%n", e.getKey(), e.getValue()));

        // 3. Bean 初始化耗时统计
        System.out.println("\n=== Bean 初始化耗时 Top 10 ===");
        steps.stream()
            .filter(s -> s.getName().equals("spring.bean.instantiate"))
            .sorted(Comparator.comparing(
                (StartupStep s) -> s.getDuration().toMillis()).reversed())
            .limit(10)
            .forEach(s -> {
                String beanName = s.getTags().stream()
                    .filter(t -> t.getKey().equals("beanName"))
                    .map(StartupStep.Tag::getValue)
                    .findFirst().orElse("unknown");
                System.out.printf("%-50s %5dms%n", beanName, s.getDuration().toMillis());
            });
    }
}

// 根据 Profile 动态注册不同的 Bean
public class ProfileAwareInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    @Override
    public void initialize(ConfigurableApplicationContext context) {
        String[] activeProfiles = context.getEnvironment().getActiveProfiles();

        if (Arrays.asList(activeProfiles).contains("dev")) {
            // 开发环境：注册 Mock 服务
            context.getBeanFactory().registerSingleton("paymentService",
                new MockPaymentService());
            context.getBeanFactory().registerSingleton("notificationService",
                new MockNotificationService());
        } else if (Arrays.asList(activeProfiles).contains("prod")) {
            // 生产环境：注册真实服务
            // 这里只注册 BeanDefinition，实际实例化由 Spring 管理
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(RealPaymentService.class);
            context.getBeanFactory().registerBeanDefinition("paymentService", beanDefinition);
        }
    }
}

// 使用文件锁防止同一应用重复启动
public class SingleInstanceInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {

    private FileLock fileLock;
    private FileOutputStream fileOutputStream;

    @Override
    public void initialize(ConfigurableApplicationContext context) {
        try {
            String lockFile = System.getProperty("java.io.tmpdir") +
                "/myapp-" + context.getEnvironment().getProperty("server.port", "8080") + ".lock";

            fileOutputStream = new FileOutputStream(lockFile);
            fileLock = fileOutputStream.getChannel().tryLock();

            if (fileLock == null) {
                throw new IllegalStateException(
                    "应用已在运行中！请先停止已有实例。锁定文件: " + lockFile);
            }

            // 注册关闭钩子释放文件锁
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                try {
                    if (fileLock != null) fileLock.release();
                    if (fileOutputStream != null) fileOutputStream.close();
                    new File(lockFile).delete();
                } catch (IOException e) {
                    // 忽略关闭异常
                }
            }));
        } catch (IOException e) {
            throw new RuntimeException("无法创建实例锁定文件", e);
        }
    }
}

// 启动完成后自动执行健康检查
@Component
@Order(1)
public class StartupHealthChecker implements ApplicationRunner {

    private final Environment environment;
    private final ApplicationContext applicationContext;

    public StartupHealthChecker(Environment environment,
                                ApplicationContext applicationContext) {
        this.environment = environment;
        this.applicationContext = applicationContext;
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        String appName = environment.getProperty("spring.application.name", "unknown");
        String port = environment.getProperty("server.port", "8080");
        String[] activeProfiles = environment.getActiveProfiles();

        log.info("========== 启动自检 ==========");
        log.info("应用名称: {}", appName);
        log.info("服务端口: {}", port);
        log.info("活跃 Profile: {}", Arrays.toString(activeProfiles));

        // 检查关键 Bean 是否存在
        checkBean("dataSource", "数据源");
        checkBean("redisConnectionFactory", "Redis 连接工厂");

        // 检查关键配置
        checkProperty("spring.datasource.url", "数据库连接地址");
        checkProperty("spring.data.redis.host", "Redis 主机地址");

        log.info("========== 自检完成 ==========");
    }

    private void checkBean(String beanName, String description) {
        if (applicationContext.containsBean(beanName)) {
            log.info("√ {} ({}) 已加载", description, beanName);
        } else {
            log.warn(" {} ({}) 未加载", description, beanName);
        }
    }

    private void checkProperty(String key, String description) {
        String value = environment.getProperty(key);
        if (value != null) {
            log.info("√ {}: {}", description, maskSensitive(value));
        } else {
            log.warn(" {} 未配置 ({})", description, key);
        }
    }

    private String maskSensitive(String value) {
        // 脱敏处理
        if (value.contains("password") || value.contains("secret")) {
            return "******";
        }
        return value;
    }
}

## 开启 debug 模式
java -jar myapp.jar --debug

## 或设置
debug: true

## 查看 Auto-Configuration 报告
## 查看 CONDITIONS EVALUATION REPORT

Error creating bean with name 'xxx': Unsatisfied dependency expressed through...

## 查看端口占用
lsof -i :8080

## 修改端口
java -jar myapp.jar --server.port=8081

// 使用 SpringBootStartupReport 分析启动耗时
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(Application.class);
        app.setApplicationStartup(new BufferingApplicationStartup(2048));
        ConfigurableApplicationContext context = app.run(args);

        // 输出启动耗时报告
        ApplicationStartup startup = context.getApplicationStartup();
        if (startup instanceof BufferingApplicationStartup buffering) {
            buffering.drain()
                .stream()
                .sorted(Comparator.comparing(StartupStep::getDuration).reversed())
                .limit(10)
                .forEach(step -> log.info("Step: {} - Duration: {}ms",
                    step.getName(), step.getDuration().toMillis()));
        }
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

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

org.springframework.context.ApplicationContextException: Unable to start web server; nested exception is org.springframework.context.ApplicationContextException: Unable to start ServletWebServerApplicationContext due to missing ServletWebServerFactory bean.
	at org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext.onRefresh(ServletWebServerApplicationContext.java:155) ~[spring-boot-2.1.9.RELEASE.jar:2.1.9.RELEASE]
	......

/**
 * ......
 * @since 1.2.0
 */
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication

@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
        throws IOException {
    if (this.beanFactory instanceof ListableBeanFactory && getClass() == TypeExcludeFilter.class) {
        Collection<TypeExcludeFilter> delegates = ((ListableBeanFactory) this.beanFactory)
                .getBeansOfType(TypeExcludeFilter.class).values();
        for (TypeExcludeFilter delegate : delegates) {
            if (delegate.match(metadataReader, metadataReaderFactory)) {
                return true;
            }
        }
    }
    return false;
}

public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
        throws IOException {
    return isConfiguration(metadataReader) && isAutoConfiguration(metadataReader);
}

private boolean isConfiguration(MetadataReader metadataReader) {
    return metadataReader.getAnnotationMetadata().isAnnotated(Configuration.class.getName());
}

private boolean isAutoConfiguration(MetadataReader metadataReader) {
    return getAutoConfigurations().contains(metadataReader.getClassMetadata().getClassName());
}

protected List<String> getAutoConfigurations() {
    if (this.autoConfigurations == null) {
        this.autoConfigurations = SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class,
                this.beanClassLoader);
    }
    return this.autoConfigurations;
}

@Configuration
public @interface SpringBootConfiguration

@Configuration
public class ConfigurationDemo {
    @Bean
    public Date currentDate() {
        return new Date();
    }
}

public class MainApp {
    public static void main(String[] args) throws Exception {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigurationDemo.class);
        String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
        Stream.of(beanDefinitionNames).forEach(System.out::println);
    }
}

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
configurationDemo
currentDate

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver

/**
 * Return the parent bean factory, or {@code null} if there is none.
 */
@Nullable
BeanFactory getParentBeanFactory();

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver

public interface EnvironmentCapable {

/**
	 * Return the {@link Environment} associated with this component.
	 */
	Environment getEnvironment();

}

//ApplicationContext
public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
        MessageSource, ApplicationEventPublisher, ResourcePatternResolver {

@Nullable
    String getId();

String getApplicationName();

//......
}

//ConfigurableApplicationContext
public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {

void setId(String id);

void setParent(@Nullable ApplicationContext parent);

    //......
}

@SpringBootApplication
public class DemoApplication {

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

}

    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);
    }

private Set<Class<?>> primarySources;

public SpringApplication(Class<?>... primarySources) {
    this(null, primarySources);
}

@SuppressWarnings({ "unchecked", "rawtypes" })
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // resourceLoader为null
    this.resourceLoader = resourceLoader;
    Assert.notNull(primarySources, "PrimarySources must not be null");
    // 将传入的DemoApplication启动类放入primarySources中，这样应用就知道主启动类在哪里，叫什么了
    // SpringBoot一般称呼这种主启动类叫primarySource（主配置资源来源）
    this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));
    // 3.1 判断当前应用环境
    this.webApplicationType = WebApplicationType.deduceFromClasspath();
    // 3.2 设置初始化器
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    // 3.3 设置监听器
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // 3.4 确定主配置类
    this.mainApplicationClass = deduceMainApplicationClass();
}

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication(DemoApplication.class);
        springApplication.setWebApplicationType(WebApplicationType.SERVLET); //强制使用WebMvc环境
        springApplication.setBannerMode(Banner.Mode.OFF); //不打印Banner
        springApplication.run(args);
    }

}

private static final String[] SERVLET_INDICATOR_CLASSES = { "javax.servlet.Servlet",
        "org.springframework.web.context.ConfigurableWebApplicationContext" };
private static final String WEBMVC_INDICATOR_CLASS = "org.springframework." + "web.servlet.DispatcherServlet";
private static final String WEBFLUX_INDICATOR_CLASS = "org." + "springframework.web.reactive.DispatcherHandler";
private static final String JERSEY_INDICATOR_CLASS = "org.glassfish.jersey.servlet.ServletContainer";
private static final String SERVLET_APPLICATION_CONTEXT_CLASS = "org.springframework.web.context.WebApplicationContext";
private static final String REACTIVE_APPLICATION_CONTEXT_CLASS = "org.springframework.boot.web.reactive.context.ReactiveWebApplicationContext";

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;
}

public interface ApplicationContextInitializer<C extends ConfigurableApplicationContext>

public class ApplicationContextInitializerDemo implements ApplicationContextInitializer {

@Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        System.out.println("ApplicationContextInitializerDemo#initialize run...");
    }

}

@SpringBootApplication
public class DemoApplication {

public static void main(String[] args) {
        // SpringApplication.run(DemoApplication.class, args);
        SpringApplication springApplication = new SpringApplication(DemoApplication.class);
        springApplication.addInitializers(new ApplicationContextInitializerDemo());
        springApplication.run(args);
    }

}

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v2.1.9.RELEASE)

ApplicationContextInitializerDemo#initialize run...
1970-01-01 00:00:00.000  INFO 7876 --- [  restartedMain] com.example.demo.DemoApplication         : Starting DemoApplication on DESKTOP with PID 7876 (D:\IDEA\spring-boot-demo\target\classes started by LinkedBear in D:\IDEA\spring-boot-demo)
................

context.initializer.classes=com.example.demo.ApplicationContextInitializerDemo

org.springframework.context.ApplicationContextInitializer=com.example.demo.ApplicationContextInitializerDemo

public void setInitializers(Collection<? extends ApplicationContextInitializer<?>> initializers) {
    this.initializers = new ArrayList<>();
    this.initializers.addAll(initializers);
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type) {
    return getSpringFactoriesInstances(type, new Class<?>[] {});
}

private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    // Use names and ensure unique to protect against duplicates （使用名称并确保唯一，以防止重复）
    // 3.2.1 SpringFactoriesLoader.loadFactoryNames：加载指定类型的所有已配置组件的全限定类名
    Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    // 3.2.2 createSpringFactoriesInstances：创建这些组件的实例
    List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

## Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\
org.springframework.boot.context.ContextIdApplicationContextInitializer,\
org.springframework.boot.context.config.DelegatingApplicationContextInitializer,\
org.springframework.boot.web.context.ServerPortInfoApplicationContextInitializer

## Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener

private <T> List<T> createSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes,
        ClassLoader classLoader, Object[] args, Set<String> names) {
    List<T> instances = new ArrayList<>(names.size());
    for (String name : names) {
        try {
            // 反射创建这些对象
            Class<?> instanceClass = ClassUtils.forName(name, classLoader);
            Assert.isAssignable(type, instanceClass);
            Constructor<?> constructor = instanceClass.getDeclaredConstructor(parameterTypes);
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        }
        catch (Throwable ex) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

import java.util.EventListener;

public interface ApplicationListener<E extends ApplicationEvent> extends EventListener

// 加载所有类型为ApplicationListener的已配置的组件的全限定类名
setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));

## Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.ClearCachesApplicationListener,\
org.springframework.boot.builder.ParentContextCloserApplicationListener,\
org.springframework.boot.context.FileEncodingApplicationListener,\
org.springframework.boot.context.config.AnsiOutputApplicationListener,\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.config.DelegatingApplicationListener,\
org.springframework.boot.context.logging.ClasspathLoggingApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener,\
org.springframework.boot.liquibase.LiquibaseServiceLocatorApplicationListener

## Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

private Class<?> deduceMainApplicationClass() {
    try {
        StackTraceElement[] stackTrace = new RuntimeException().getStackTrace();
        for (StackTraceElement stackTraceElement : stackTrace) {
            // 从本方法开始往上爬，哪一层调用栈上有main方法，方法对应的类就是主配置类
            if ("main".equals(stackTraceElement.getMethodName())) {
                return Class.forName(stackTraceElement.getClassName());
            }
        }
    }
    catch (ClassNotFoundException ex) {
        // Swallow and continue
    }
    return null;
}

private final Set<Object> sources = new LinkedHashSet<Object>();

private void initialize(Object[] sources) {
    // sources为null时没有终止应用继续启动
    // sources为SpringBoot1.x中使用的成员，SpringBoot2.x保留了它，但启动过程中不再使用
    if (sources != null && sources.length > 0) {
        this.sources.addAll(Arrays.asList(sources));
    }
    // deduceWebEnvironment方法在SpringApplication中，没有抽取成一个工具方法
    // 且SpringBoot1.x使用Spring4.x版本，没有WebFlux模块，故这里面只判断是否为WebMvc环境
    this.webEnvironment = deduceWebEnvironment();
    setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    this.mainApplicationClass = deduceMainApplicationClass();
}

public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
    return new SpringApplication(primarySources).run(args);
}

public ConfigurableApplicationContext run(String... args) {
    // 4.1 创建StopWatch对象
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    // 4.2 创建空的IOC容器，和一组异常报告器
    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
    // 4.3 配置与awt相关的信息
    configureHeadlessProperty();
    // 4.4 获取SpringApplicationRunListeners，并调用starting方法（回调机制）
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 【回调】首次启动run方法时立即调用。可用于非常早期的初始化（准备运行时环境之前）。
    listeners.starting();
    try {
        // 将main方法的args参数封装到一个对象中
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 4.5 准备运行时环境
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        //.............
    }

public void start() throws IllegalStateException {
    start("");
}

public void start(String taskName) throws IllegalStateException {
    if (this.currentTaskName != null) {
        throw new IllegalStateException("Can't start StopWatch: it's already running");
    }
    this.currentTaskName = taskName;
    // 记录启动时的当前系统时间
    this.startTimeMillis = System.currentTimeMillis();
}

    ConfigurableApplicationContext context = null;
    Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

public interface SpringBootExceptionReporter {
    boolean reportException(Throwable failure);
}

    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null;

private void configureHeadlessProperty() {
    System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
            System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

public static String getProperty(String key) {
    checkKey(key);
    SecurityManager sm = getSecurityManager();
    if (sm != null) {
        sm.checkPropertyAccess(key);
    }
    // 从Properties中取值
    return props.getProperty(key);
}

public static String getProperty(String key, String def) {
    checkKey(key);
    SecurityManager sm = getSecurityManager();
    if (sm != null) {
        sm.checkPropertyAccess(key);
    }
    // 从Properties中取值，如果取不到，返回默认值
    return props.getProperty(key, def);
}

public static String setProperty(String key, String value) {
    checkKey(key);
    SecurityManager sm = getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new PropertyPermission(key,
            SecurityConstants.PROPERTY_WRITE_ACTION));
    }

    return (String) props.setProperty(key, value);
}

private SpringApplicationRunListeners getRunListeners(String[] args) {
    Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
    // 又是调getSpringFactoriesInstances方法，取spring.factories中所有SpringApplicationRunListener
    return new SpringApplicationRunListeners(logger,
            getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args));
}

/**
 * Listener for the SpringApplication code run method.
 * SpringApplicationRunListeners are loaded via the SpringFactoriesLoader
 * and should declare a public constructor that accepts a SpringApplication
 * instance and a String[] of arguments. A new
 * SpringApplicationRunListener instance will be created for each run.
 *
 * 监听SpringApplication运行方法。
 * SpringApplication是SpringFactoriesLoader，应该声明一个接受SpringApplication实例和String[]参数的公共构造函数。
 * 将为每次运行创建一个新的SpringApplicationRunListener的instance。
 */
public interface SpringApplicationRunListener {

/**
     * Called immediately when the run method has first started. Can be used for very
     * early initialization.
     * 首次启动run方法时立即调用。可用于非常早期的初始化。
     */
    void starting();

/**
     * Called once the environment has been prepared, but before the
     * ApplicationContext has been created.
     * 准备好环境（Environment构建完成），但在创建ApplicationContext之前调用。
     */
    void environmentPrepared(ConfigurableEnvironment environment);

/**
     * Called once the ApplicationContext has been created and prepared, but
     * before sources have been loaded.
     * 在创建和构建ApplicationContext之后，但在加载之前调用。
     */
    void contextPrepared(ConfigurableApplicationContext context);

/**
     * Called once the application context has been loaded but before it has been
     * refreshed.
     * ApplicationContext已加载但在刷新之前调用。
     */
    void contextLoaded(ConfigurableApplicationContext context);

/**
     * The context has been refreshed and the application has started but
     * CommandLineRunners and ApplicationRunners have not been called.
     * @since 2.0.0
     * ApplicationContext已刷新，应用程序已启动，但尚未调用CommandLineRunners和ApplicationRunners。
     */
    void started(ConfigurableApplicationContext context);

/**
     * Called immediately before the run method finishes, when the application context has
     * been refreshed and all CommandLineRunners and ApplicationRunners have been called.
     * @since 2.0.0
     * 在运行方法彻底完成之前立即调用，刷新ApplicationContext并调用所有CommandLineRunners和ApplicationRunner。
     */
    void running(ConfigurableApplicationContext context);

    /**
     * Called when a failure occurs when running the application.
     * @since 2.0.0
     * 在运行应用程序时失败时调用。
     */
    void failed(ConfigurableApplicationContext context, Throwable exception);
}

    //......
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(); //【回调】首次启动run方法时立即调用。可用于非常早期的初始化（准备运行时环境之前）。
    try {
        // 将main方法的args参数封装到一个对象中
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
        //......

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // Create and configure the environment
    // 4.5.1 创建运行时环境
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    // 4.5.2 配置运行时环境
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    // 【回调】SpringApplicationRunListener的environmentPrepared方法（Environment构建完成，但在创建ApplicationContext之前）
    listeners.environmentPrepared(environment);
    // 4.5.3 环境与应用绑定
    bindToSpringApplication(environment);
    if (!this.isCustomEnvironment) {
        environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment,
                deduceEnvironmentClass());
    }
    ConfigurationPropertySources.attach(environment);
    return environment;
}

private ConfigurableEnvironment getOrCreateEnvironment() {
    if (this.environment != null) {
        return this.environment;
    }
    // 判断当前Web应用类型
    switch (this.webApplicationType) {
        case SERVLET:
            return new StandardServletEnvironment();
        case REACTIVE:
            return new StandardReactiveWebEnvironment();
        default:
            return new StandardEnvironment();
    }
}

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    if (this.addConversionService) {
        ConversionService conversionService = ApplicationConversionService.getSharedInstance();
        environment.setConversionService((ConfigurableConversionService) conversionService);
    }
    configurePropertySources(environment, args);
    configureProfiles(environment, args);
}

protected void bindToSpringApplication(ConfigurableEnvironment environment) {
    try {
        Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
    }
    catch (Exception ex) {
        throw new IllegalStateException("Cannot bind to SpringApplication", ex);
    }
}

public <T> BindResult<T> bind(String name, Bindable<T> target) {
    return bind(ConfigurationPropertyName.of(name), target, null);
}

public <T> BindResult<T> bind(ConfigurationPropertyName name, Bindable<T> target, BindHandler handler) {
    Assert.notNull(name, "Name must not be null");
    Assert.notNull(target, "Target must not be null");
    handler = (handler != null) ? handler : BindHandler.DEFAULT;
    Context context = new Context();
    T bound = bind(name, target, handler, context, false);
    return BindResult.of(bound);
}

Manifest-Version: 1.0
Implementation-Title: demo
Implementation-Version: 0.0.1-SNAPSHOT
Start-Class: com.example.demo.DemoApplication
Spring-Boot-Classes: BOOT-INF/classes/
Spring-Boot-Lib: BOOT-INF/lib/
Build-Jdk-Spec: 1.8
Spring-Boot-Version: 2.1.9.RELEASE
Created-By: Maven Archiver 3.4.0
Main-Class:org.springframework.boot.loader.JarLauncher

public class JarLauncher extends ExecutableArchiveLauncher {

static final String BOOT_INF_CLASSES = "BOOT-INF/classes/";

static final String BOOT_INF_LIB = "BOOT-INF/lib/";

public JarLauncher() {
    }

protected JarLauncher(Archive archive) {
        super(archive);
    }

@Override
    protected boolean isNestedArchive(Archive.Entry entry) {
        if (entry.isDirectory()) {
            return entry.getName().equals(BOOT_INF_CLASSES);
        }
        return entry.getName().startsWith(BOOT_INF_LIB);
    }

public static void main(String[] args) throws Exception {
        new JarLauncher().launch(args);
    }

}

public static void main(String[] args) throws Exception {
    new JarLauncher().launch(args);
}

// 这个方法是一个入口点，且应该被一个public static void main(String[] args)调用
protected void launch(String[] args) throws Exception {
    //注册URL协议并清除应用缓存
    JarFile.registerUrlProtocolHandler();
    //设置类加载路径
    ClassLoader classLoader = createClassLoader(getClassPathArchives());
    //执行main方法
    launch(args, getMainClass(), classLoader);
}

private static final String MANIFEST_NAME = "META-INF/MANIFEST.MF";

private static final String PROTOCOL_HANDLER = "java.protocol.handler.pkgs";

private static final String HANDLERS_PACKAGE = "org.springframework.boot.loader";

public static void registerUrlProtocolHandler() {
    String handlers = System.getProperty(PROTOCOL_HANDLER, "");
    System.setProperty(PROTOCOL_HANDLER,
           ("".equals(handlers) ? HANDLERS_PACKAGE : handlers + "|" + HANDLERS_PACKAGE));
    resetCachedUrlHandlers();
}

// 重置任何缓存的处理程序，以防万一已经使用了jar协议。
// 我们通过尝试设置null URLStreamHandlerFactory来重置处理程序，除了清除处理程序缓存之外，它应该没有任何效果。
private static void resetCachedUrlHandlers() {
    try {
        URL.setURLStreamHandlerFactory(null);
    }
    catch (Error ex) {
        // Ignore
    }
}

protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
    List<URL> urls = new ArrayList<>(archives.size());
    for (Archive archive : archives) {
        urls.add(archive.getUrl());
    }
    return createClassLoader(urls.toArray(new URL[0]));
}

protected List<Archive> getClassPathArchives() throws Exception {
    List<Archive> archives = new ArrayList<>(this.archive.getNestedArchives(this::isNestedArchive));
    postProcessClassPathArchives(archives);
    return archives;
}

private final Archive archive;

public ExecutableArchiveLauncher() {
    try {
        this.archive = createArchive();
    }
    catch (Exception ex) {
        throw new IllegalStateException(ex);
    }
}

protected final Archive createArchive() throws Exception {
    ProtectionDomain protectionDomain = getClass().getProtectionDomain();
    CodeSource codeSource = protectionDomain.getCodeSource();
    URI location = (codeSource != null) ? codeSource.getLocation().toURI() : null;
    String path = (location != null) ? location.getSchemeSpecificPart() : null;
    if (path == null) {
        throw new IllegalStateException("Unable to determine code source archive");
    }
    File root = new File(path);
    if (!root.exists()) {
        throw new IllegalStateException("Unable to determine code source archive from " + root);
    }
    return (root.isDirectory() ? new ExplodedArchive(root) : new JarFileArchive(root));
}

/**
 * An archive that can be launched by the Launcher
 */
public interface Archive extends Iterable<Archive.Entry>

public List<Archive> getNestedArchives(EntryFilter filter) throws IOException {
    List<Archive> nestedArchives = new ArrayList<>();
    for (Entry entry : this) {
        if (filter.matches(entry)) {
            nestedArchives.add(getNestedArchive(entry));
        }
    }
    return Collections.unmodifiableList(nestedArchives);
}

protected boolean isNestedArchive(Archive.Entry entry) {
    if (entry.isDirectory()) {
        return entry.getName().equals(BOOT_INF_CLASSES);
    }
    return entry.getName().startsWith(BOOT_INF_LIB);
}

// 在使用之前调用后处理存档条目。实现可以添加和删除Entry。
protected void postProcessClassPathArchives(List<Archive> archives) throws Exception {
}

// 为指定的归档文件创建一个类加载器
protected ClassLoader createClassLoader(List<Archive> archives) throws Exception {
    List<URL> urls = new ArrayList<>(archives.size());
    for (Archive archive : archives) {
        urls.add(archive.getUrl());
    }
    return createClassLoader(urls.toArray(new URL[0]));
}

protected ClassLoader createClassLoader(URL[] urls) throws Exception {
    return new LaunchedURLClassLoader(urls, getClass().getClassLoader());
}

public LaunchedURLClassLoader(URL[] urls, ClassLoader parent) {
    super(urls, parent);
}

launch(args, getMainClass(), classLoader);

protected String getMainClass() throws Exception {
    Manifest manifest = this.archive.getManifest();
    String mainClass = null;
    if (manifest != null) {
        mainClass = manifest.getMainAttributes().getValue("Start-Class");
    }
    if (mainClass == null) {
        throw new IllegalStateException("No 'Start-Class' manifest entry specified in " + this);
    }
    return mainClass;
}

// 根据一个Archive文件和一个完全配置好的ClassLoader启动应用。
protected void launch(String[] args, String mainClass, ClassLoader classLoader) throws Exception {
    Thread.currentThread().setContextClassLoader(classLoader);
    createMainMethodRunner(mainClass, args, classLoader).run();
}

protected MainMethodRunner createMainMethodRunner(String mainClass, String[] args, ClassLoader classLoader) {
    return new MainMethodRunner(mainClass, args);
}

// 用于Launcher调用main方法的辅助类。使用当前线程上下文类加载器加载包含main方法的类。
public class MainMethodRunner {

private final String mainClassName;

private final String[] args;

public MainMethodRunner(String mainClass, String[] args) {
        this.mainClassName = mainClass;
        this.args = (args != null) ? args.clone() : null;
    }

public void run() throws Exception {
        Class<?> mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);
        Method mainMethod = mainClass.getDeclaredMethod("main", String[].class);
        mainMethod.invoke(null, new Object[] { this.args });
    }

}