@SpringBootApplicationpublicclassDemoApplication{
publicstaticvoidmain(String[] args)
    {
SpringApplication.run(DemoApplication.class, args);
    }
}

@SuppressWarnings("deprecation")
privateList<BootstrapRegistryInitializer>getBootstrapRegistryInitializersFromSpringFactories() {
ArrayList<BootstrapRegistryInitializer>initializers=newArrayList<>();
//从spring.factories中获取Bootstrapper集合，遍历转化为BootstrapRegistryInitializer并存入initializersgetSpringFactoriesInstances(Bootstrapper.class).stream()
            .map((bootstrapper) -> ((BootstrapRegistryInitializer) bootstrapper::initialize))
            .forEach(initializers::add);
//从spring.factories中获取BootstrapRegistryInitializer集合并存入initializers，最后返回initializers集合initializers.addAll(getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
returninitializers;
}

publicclassApplicationInitimplementsApplicationContextInitializer {
@Overridepublicvoidinitialize(ConfigurableApplicationContextapplicationContext) {
System.out.println("加载自定义ApplicationContextInitializer...");
    }
}

#ApplicationContextInitializersorg.springframework.context.ApplicationContextInitializer=\com.ruoyi.web.controller.common.ApplicationInit

publicConfigurableApplicationContextrun(String... args) {
//实例化一个计时器，统计项目启动时间StopWatchstopWatch=newStopWatch();
//启动计时器stopWatch.start();
//初始化上下文对象DefaultBootstrapContextbootstrapContext=createBootstrapContext();
//定义可配置上下文ConfigurableApplicationContextcontext=null;
//设置系统headless属性默认值是trueconfigureHeadlessProperty();
//从spring.factories中获取运行监听器 getRunListenersSpringApplicationRunListenerslisteners=getRunListeners(args);
//启动监听器listeners.starting(bootstrapContext, this.mainApplicationClass);
try {
//在命令行下启动应用带的参数ApplicationArgumentsapplicationArguments=newDefaultApplicationArguments(args);
//准备环境 prepareEnvironmentConfigurableEnvironmentenvironment=prepareEnvironment(listeners, bootstrapContext, applicationArguments);
// 配置忽略的beanconfigureIgnoreBeanInfo(environment);
//打印在src/main/resources下放入名字是banner的自定义文件BannerprintedBanner=printBanner(environment);
//根据webApplicationType调用工厂类创建应用程序上下文容器context=createApplicationContext();
//设置一个启动器，设置应用程序启动context.setApplicationStartup(this.applicationStartup);
//配置容器的基本信息prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
//刷新容器refreshContext(context);
//在刷新上下文后调用afterRefresh(context, applicationArguments);
//计时器停止stopWatch.stop();
if (this.logStartupInfo) {
//打印启动完成的日志newStartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
        }
//监听应用上下文启动完成所有的运行监听器调用 started() 方法listeners.started(context);
//遍历所有的 runner，调用 run 方法callRunners(context, applicationArguments);
    }
catch (Throwableex) {
//异常处理，如果run过程发生异常handleRunFailure(context, ex, listeners);
thrownewIllegalStateException(ex);
    }
try {
//所有的运行监听器调用running()方法,监听应用上下文listeners.running(context);
    }
catch (Throwableex) {
//异常处理handleRunFailure(context, ex, null);
thrownewIllegalStateException(ex);
    }
//返回最终构建的容器对象ConfigurableApplicationContextreturncontext;
}

privateConfigurableEnvironmentprepareEnvironment(SpringApplicationRunListenerslisteners,
DefaultBootstrapContextbootstrapContext, ApplicationArgumentsapplicationArguments) {
// 创建和配置环境ConfigurableEnvironmentenvironment=getOrCreateEnvironment();
//配置 property sources 和 profilesconfigureEnvironment(environment, applicationArguments.getSourceArgs());
//将environment.getPropertySources()放在第一个位置ConfigurationPropertySources.attach(environment);
//运行监听器通知所有监听器环境准备完成listeners.environmentPrepared(bootstrapContext, environment);
//Move the 'defaultProperties' property source so that it's the last sourceDefaultPropertiesPropertySource.moveToEnd(environment);
Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
"Environment prefix cannot be set via properties.");
//Bind the environment to the {@link SpringApplication}bindToSpringApplication(environment);
//环境转换成StandardEnvironmentif (!this.isCustomEnvironment) {
environment=convertEnvironment(environment);
    }
ConfigurationPropertySources.attach(environment);
//返回环境配置对象ConfigurableEnvironmentreturnenvironment;
}

privatevoidprepareContext(DefaultBootstrapContextbootstrapContext, ConfigurableApplicationContextcontext,
ConfigurableEnvironmentenvironment, SpringApplicationRunListenerslisteners,
ApplicationArgumentsapplicationArguments, BannerprintedBanner) {
//设置容器的环境变量context.setEnvironment(environment);
//设置容器的ResourceLoader、ClassLoader、ConversionServicepostProcessApplicationContext(context);
//获取所有初始化器调用initialize()初始化applyInitializers(context);
//触发所有 SpringApplicationRunListener监听器的contextPrepared事件方法listeners.contextPrepared(context);
bootstrapContext.close(context);
if (this.logStartupInfo) {
//打印启动日志logStartupInfo(context.getParent() ==null);
logStartupProfileInfo(context);
    }
// Add boot specific singleton beans 添加启动特定的单例beanConfigurableListableBeanFactorybeanFactory=context.getBeanFactory();
beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
if (printedBanner!=null) {
beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
if (beanFactoryinstanceofDefaultListableBeanFactory) {
        ((DefaultListableBeanFactory) beanFactory)
                .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
    }
if (this.lazyInitialization) {
context.addBeanFactoryPostProcessor(newLazyInitializationBeanFactoryPostProcessor());
    }
// Load the sources 加载所有的资源Set<Object>sources=getAllSources();
//断言资源必须非空Assert.notEmpty(sources, "Sources must not be empty");
//Load beans into the application context 加载启动类 the context to load beans into 将启动类注入容器load(context, sources.toArray(newObject[0]));
//触发所有SpringApplicationRunListener监听器contextLoaded方法listeners.contextLoaded(context);
}

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