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 boolean logStartupInfo = true;

private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;

/**
 * Run the Spring application, creating and refreshing a new
 * {@link ApplicationContext}.
 * @param args the application arguments (usually passed from a Java main method)
 * @return a running {@link ApplicationContext}
 */
public ConfigurableApplicationContext run(String... args) {
    long startTime = System.nanoTime();
    // 创建启动上下文
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    // 该变量记录Spring中的应用上下文
    ConfigurableApplicationContext context = null;
    // 配置headless属性
    configureHeadlessProperty();
    // 获取SpringApplicationRunLister数组并封装成SpringApplicationRunListeners
    SpringApplicationRunListeners listeners = getRunListeners(args);
    /*
     * 启动listener，内部会遍历各个SpringApplicationRunLister，
     * 对于默认的EventPublishingRunListener而言，内部会通过事件广播器向各个ApplicationListener广播starting事件。
     */
    listeners.starting(bootstrapContext, this.mainApplicationClass);

    /*
     * 这里简要对事件处理做一个总结(以starting事件为例，其他类型事件相似)：
     * SpringApplicationRunListeners.starting ->
     * 遍历SpringApplicationRunListener，依次调用每个listener的starting方法 ->
     * EventPublishingRunListener.starting ->
     * initialMulticaster.multicastEvent(ApplicationStartingEvent) 或者 context.publishEvent
     *
     * EventPublishingRunListener内部针对不同的事件处理的方式有区别，有些是通过initialMulticaster.multicastEvent处理的，
     * 另外有些是通过context.publishEvent来处理的，这是为什么？
     * contextLoad事件是不同事件广播方式的分水岭，因为该事件发生时，context才算初始化完成，之后才能利用context.publishEvent来发布事件。
     *
     */

    try {
        // 创建应用参数对象
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 加载属性配置
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        // 配置spring.beaninfo.ignore属性
        configureIgnoreBeanInfo(environment);
        // 打印banner (此功能华而不实，跳过)
        Banner printedBanner = printBanner(environment);
        // 创建应用上下文
        context = createApplicationContext();
        // 设置应用上下文的startup，应用上下文本身的启动也有很多阶段，所以可以用该startup来记录
        context.setApplicationStartup(this.applicationStartup);
        // 准备应用上下文和属性对象之间的关联
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 初始化（刷新）应用上下文, 这里最终调用的是特别熟悉且重要和复杂的AbstractApplicationContext#refresh()方法
        refreshContext(context);
        // 执行应用上下文刷新之后的操作，默认是空操作
        afterRefresh(context, applicationArguments);
        // 计算启动耗时
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        // 打印启动耗时到日志中
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        // 通知listener，应用上下文启动完毕
        listeners.started(context, timeTakenToStartup);
        // 调用runner
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 处理异常
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        // 计算应用上下文准备时间
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        // 通知listener，应用上下文准备完毕
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 异常处理
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    // 返回应用上下文对象
    return context;
}

private DefaultBootstrapContext createBootstrapContext() {
    // 直接创建默认启动上下文实例
    DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
    // 通过构造流程中创建的初始化器对上下文实例进行初始化，默认情况下bootstrapRegistryInitializers列表的长度为0
    this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
    return bootstrapContext;
}

private static final String SYSTEM_PROPERTY_JAVA_AWT_HEADLESS = "java.awt.headless";

private boolean headless = true;

private void configureHeadlessProperty() {
    // 这里其实是在设置`java.awt.headless`属性的默认值， this.headless默认值是true。
    System.setProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS,
            System.getProperty(SYSTEM_PROPERTY_JAVA_AWT_HEADLESS, Boolean.toString(this.headless)));
}

private ApplicationStartup applicationStartup = ApplicationStartup.DEFAULT;

	private SpringApplicationRunListeners getRunListeners(String[] args) {
		// 实例化SpringApplicationRunListener子类的时查找对应构造器的参数类型
		Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
		/*
		 * 从spring.factories文件中加载SpringApplicationRunListener相关配置，并实例化这些配置类的对象，
		 * 然后作为参数（第二个参数）构造SpringApplicationRunListeners
		 * 默认仅提供了一个，即EventPublishingRunListener, 参考文件spring-boot-project/spring-boot/src/main/resources/META-INF/spring.factories
		 */
		return new SpringApplicationRunListeners(logger,
				getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
				this.applicationStartup);
	}

/**
 * Instruments the application startup phase using {@link StartupStep steps}.
 * <p>The core container and its infrastructure components can use the {@code ApplicationStartup}
 * to mark steps during the application startup and collect data about the execution context
 * or their processing time.
 *
 * @author Brian Clozel
 * @since 5.3
 */
public interface ApplicationStartup {

	/**
	 * Default "no op" {@code ApplicationStartup} implementation.
	 * <p>This variant is designed for minimal overhead and does not record data.
	 */
	ApplicationStartup DEFAULT = new DefaultApplicationStartup();

	/**
	 * Create a new step and marks its beginning.
	 * <p>A step name describes the current action or phase. This technical
	 * name should be "." namespaced and can be reused to describe other instances of
	 * the same step during application startup.
	 * @param name the step name
	 */
	StartupStep start(String name);

}

class SpringApplicationRunListeners {

	private final Log log;

	private final List<SpringApplicationRunListener> listeners;

	private final ApplicationStartup applicationStartup;

	SpringApplicationRunListeners(Log log, Collection<? extends SpringApplicationRunListener> listeners,
			ApplicationStartup applicationStartup) {
		this.log = log;
		this.listeners = new ArrayList<>(listeners);
		this.applicationStartup = applicationStartup;
	}

	void starting(ConfigurableBootstrapContext bootstrapContext, Class<?> mainApplicationClass) {
		// 调用每一个listener的starting方法
		doWithListeners("spring.boot.application.starting", (listener) -> listener.starting(bootstrapContext),
				(step) -> {
					if (mainApplicationClass != null) {
						step.tag("mainApplicationClass", mainApplicationClass.getName());
					}
				});
	}

	void environmentPrepared(ConfigurableBootstrapContext bootstrapContext, ConfigurableEnvironment environment) {
		doWithListeners("spring.boot.application.environment-prepared",
				(listener) -> listener.environmentPrepared(bootstrapContext, environment));
	}

	void contextPrepared(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-prepared", (listener) -> listener.contextPrepared(context));
	}

	void contextLoaded(ConfigurableApplicationContext context) {
		doWithListeners("spring.boot.application.context-loaded", (listener) -> listener.contextLoaded(context));
	}

	void started(ConfigurableApplicationContext context, Duration timeTaken) {
		doWithListeners("spring.boot.application.started", (listener) -> listener.started(context, timeTaken));
	}

	void ready(ConfigurableApplicationContext context, Duration timeTaken) {
		doWithListeners("spring.boot.application.ready", (listener) -> listener.ready(context, timeTaken));
	}

	void failed(ConfigurableApplicationContext context, Throwable exception) {
		doWithListeners("spring.boot.application.failed",
				(listener) -> callFailedListener(listener, context, exception), (step) -> {
					step.tag("exception", exception.getClass().toString());
					step.tag("message", exception.getMessage());
				});
	}

	private void callFailedListener(SpringApplicationRunListener listener, ConfigurableApplicationContext context,
			Throwable exception) {
		try {
			listener.failed(context, exception);
		}
		catch (Throwable ex) {
			if (exception == null) {
				ReflectionUtils.rethrowRuntimeException(ex);
			}
			if (this.log.isDebugEnabled()) {
				this.log.error("Error handling failed", ex);
			}
			else {
				String message = ex.getMessage();
				message = (message != null) ? message : "no error message";
				this.log.warn("Error handling failed (" + message + ")");
			}
		}
	}

	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction) {
		doWithListeners(stepName, listenerAction, null);
	}

	private void doWithListeners(String stepName, Consumer<SpringApplicationRunListener> listenerAction,
			Consumer<StartupStep> stepAction) {
		/*
		 * 创建表示启动步骤的对象
		 * 这里的this.applicationStartup默认情况下是DefaultApplicationStartup，start后创建的是DefaultStartupStep对象，
		 * 而DefaultStartupStep的tag和end都是空操作，即什么都不做。
		 */
		StartupStep step = this.applicationStartup.start(stepName);
		// 执行listener操作
		this.listeners.forEach(listenerAction);
		// 执行step操作
		if (stepAction != null) {
			stepAction.accept(step);
		}
		// 结束当前启动步骤
		step.end();
	}

}

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

	private final SpringApplication application;

	private final String[] args;

	private final SimpleApplicationEventMulticaster initialMulticaster;

	public EventPublishingRunListener(SpringApplication application, String[] args) {
		this.application = application;
		this.args = args;
		// 创建事件广播器
		this.initialMulticaster = new SimpleApplicationEventMulticaster();
		/*
		 * 这里的ApplicationListener是在构建SpringApplication的时候根据spring.factories中的配置来创建的；
		 * 而EventPublishingRunListener（作为SpringApplicationRunListener的子类）则是在SpringApplication的run方法执行的时候根据
		 * spring.factories中的配置来创建的，别搞混了这两种listener
		 */
		for (ApplicationListener<?> listener : application.getListeners()) {
			// 往事件广播器中注册事件监听器，便于后续将事件发送到事件监听器
			this.initialMulticaster.addApplicationListener(listener);
		}
	}

	@Override
	public int getOrder() {
		return 0;
	}

	@Override
	public void starting(ConfigurableBootstrapContext bootstrapContext) {
		// 广播starting事件
		this.initialMulticaster
				.multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
	}

	@Override
	public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
			ConfigurableEnvironment environment) {
		// 广播environmentPrepared事件
		this.initialMulticaster.multicastEvent(
				new ApplicationEnvironmentPreparedEvent(bootstrapContext, this.application, this.args, environment));
	}

	@Override
	public void contextPrepared(ConfigurableApplicationContext context) {
		// 广播applicationContextInitialized事件
		this.initialMulticaster
				.multicastEvent(new ApplicationContextInitializedEvent(this.application, this.args, context));
	}

	@Override
	public void contextLoaded(ConfigurableApplicationContext context) {
		for (ApplicationListener<?> listener : this.application.getListeners()) {
			if (listener instanceof ApplicationContextAware) {
				((ApplicationContextAware) listener).setApplicationContext(context);
			}
			context.addApplicationListener(listener);
		}
		// 广播applicationPrepared事件
		this.initialMulticaster.multicastEvent(new ApplicationPreparedEvent(this.application, this.args, context));
	}

	@Override
	public void started(ConfigurableApplicationContext context, Duration timeTaken) {
		context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
		// 发布applicationStarted事件
		AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
	}

	@Override
	public void ready(ConfigurableApplicationContext context, Duration timeTaken) {
		context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context, timeTaken));
		// 发布applicationReady事件
		AvailabilityChangeEvent.publish(context, ReadinessState.ACCEPTING_TRAFFIC);
	}

	@Override
	public void failed(ConfigurableApplicationContext context, Throwable exception) {
		ApplicationFailedEvent event = new ApplicationFailedEvent(this.application, this.args, context, exception);
		if (context != null && context.isActive()) {
			// Listeners have been registered to the application context so we should
			// use it at this point if we can
			context.publishEvent(event);
		}
		else {
			// An inactive context may not have a multicaster so we use our multicaster to
			// call all of the context's listeners instead
			if (context instanceof AbstractApplicationContext) {
				for (ApplicationListener<?> listener : ((AbstractApplicationContext) context)
						.getApplicationListeners()) {
					this.initialMulticaster.addApplicationListener(listener);
				}
			}
			this.initialMulticaster.setErrorHandler(new LoggingErrorHandler());
			this.initialMulticaster.multicastEvent(event);
		}
	}

	private static class LoggingErrorHandler implements ErrorHandler {

		private static final Log logger = LogFactory.getLog(EventPublishingRunListener.class);

		@Override
		public void handleError(Throwable throwable) {
			logger.warn("Error calling ApplicationEventListener", throwable);
		}

	}

}

private boolean isCustomEnvironment = false;

private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // Create and configure the environment
    // 获取或创建environment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    // 注意，这里调用的getSourceArgs()并不是返回内部的source属性（已解析参数），而是args（未解析参数）
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    // 如果environment中不存在名为configurationProperties的属性源，则创建新的对象并将其放在属性源列表中的第一个
    ConfigurationPropertySources.attach(environment);
    // 广播environmentPrepared事件
    listeners.environmentPrepared(bootstrapContext, environment);
    // 将默认属性源移动到列表末尾
    DefaultPropertiesPropertySource.moveToEnd(environment);
    // 确保environment中不包含environment-prefix属性
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
            "Environment prefix cannot be set via properties.");
    // 绑定environment和当前SpringApplication实例的关系
    bindToSpringApplication(environment);
    // 是否需要自定义environment，默认是false
    if (!this.isCustomEnvironment) {
        // 创建environmentConverter对象
        EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
        /*
         * 将environment对象转换为目标类型的实例，deduceEnvironmentClass()主要是区分Servlet和Reactive。
         * 因为是可以直接为SpringApplication实例设置environment属性的，所以这里是在确保设置的Environment类型和应用类型是一致的，
         * 如果不一致，会自动进行转换。
         */
        environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    // 这里为什么要再次attach？是为了确保configurationPropertySource位于列表中的第一个位置？
    ConfigurationPropertySources.attach(environment);
    return environment;
}

private ConfigurableEnvironment getOrCreateEnvironment() {
    // 如果已存在，则直接返回
    if (this.environment != null) {
        return this.environment;
    }
    /*
     * 如果不存在，则根据web应用类型创建不同类型的environment
     * 对于ApplicationServletEnvironment和ApplicationReactiveWebEnvironment，两者的实现一样，
     * 为什么不在这两者的基础上再抽象一层？
     */
    switch (this.webApplicationType) {
    case SERVLET:
        return new ApplicationServletEnvironment();
    case REACTIVE:
        return new ApplicationReactiveWebEnvironment();
    default:
        return new ApplicationEnvironment();
    }
}

class ApplicationServletEnvironment extends StandardServletEnvironment {

	@Override
	protected String doGetActiveProfilesProperty() {
		return null;
	}

	@Override
	protected String doGetDefaultProfilesProperty() {
		return null;
	}

	@Override
	protected ConfigurablePropertyResolver createPropertyResolver(MutablePropertySources propertySources) {
		// 创建属性解析器
		return ConfigurationPropertySources.createPropertyResolver(propertySources);
	}

}

public static ConfigurablePropertyResolver createPropertyResolver(MutablePropertySources propertySources) {
    return new ConfigurationPropertySourcesPropertyResolver(propertySources);
}

protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // 该属性默认为true
    if (this.addConversionService) {
        // 设置转换服务，用于转换属性，比如替换属性中的占位符
        environment.setConversionService(new ApplicationConversionService());
    }
    // 设置属性源
    configurePropertySources(environment, args);
    // 设置Profiles，默认是空操作
    configureProfiles(environment, args);
}

public ApplicationConversionService() {
    this(null);
}

public ApplicationConversionService(StringValueResolver embeddedValueResolver) {
    this(embeddedValueResolver, false);
}

private ApplicationConversionService(StringValueResolver embeddedValueResolver, boolean unmodifiable) {
    if (embeddedValueResolver != null) {
        setEmbeddedValueResolver(embeddedValueResolver);
    }
    configure(this);
    this.unmodifiable = unmodifiable;
}

protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
    // 从environment对象中获取属性源，==== 该方法的目的是把命令行参数注入到environment的属性中 ====
    MutablePropertySources sources = environment.getPropertySources();
    // 如果默认属性配置存在，则将其追加在sources对象中
    if (!CollectionUtils.isEmpty(this.defaultProperties)) {
        DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
    }
    // addCommandLineProperties属性默认为true
    /*
     * 注意，下面调用的SimpleCommandLinePropertySource构造器内部会对args进行解析
     * 也可以发现其处理参数的顺序，命令行参数会被放在第一个的位置
     */
    if (this.addCommandLineProperties && args.length > 0) {
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        if (sources.contains(name)) { // 如果存在名为commandLineArgs的属性
            PropertySource<?> source = sources.get(name);
            CompositePropertySource composite = new CompositePropertySource(name);
            /*
             * 这里创建名称为springApplicationCommandLineArgs的命令行属性源，
             * 然后作为属性源添加到复合属性源中
             */
            composite.addPropertySource(
                    new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
            // 继续添加已存在的属性源
            composite.addPropertySource(source);
            // 替换已存在的同名属性源
            sources.replace(name, composite);
        }
        else { // 如果不存在名为commandLineArgs的配置，则创建一个，并放在sources中的第一个位置
            // 使用默认名称commandLineArgs
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}

private static final String ATTACHED_PROPERTY_SOURCE_NAME = "configurationProperties";

public static void attach(Environment environment) {
    // 要求environment必须是可配置的
    Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
    // 获取environment中的所有属性源
    MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
    // 获取名为configurationProperties的属性源
    PropertySource<?> attached = getAttached(sources);
    // 如果attached这个属性源不存在，或者所封装的source不是environment中的属性源，那么新建一个对象。
    if (attached == null || !isUsingSources(attached, sources)) {
        // 创建新的配置属性源对象
        attached = new ConfigurationPropertySourcesPropertySource(ATTACHED_PROPERTY_SOURCE_NAME,
                // 将其他属性源封装为一个Spring的配置属性源
                new SpringConfigurationPropertySources(sources));
    }
    // 从原有的属性源列表中移除掉
    sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
    // 将配置属性源添加到列表中的第一个
    sources.addFirst(attached);
}

private static boolean isUsingSources(PropertySource<?> attached, MutablePropertySources sources) {
    return attached instanceof ConfigurationPropertySourcesPropertySource
            // 这里是在判断attached这个属性源封装的source和参数sources是否是同一个对象
            && ((SpringConfigurationPropertySources) attached.getSource()).isUsingSources(sources);
}

static PropertySource<?> getAttached(MutablePropertySources sources) {
    // 从属性源集合中获取名为configurationProperties的属性源
    return (sources != null) ? sources.get(ATTACHED_PROPERTY_SOURCE_NAME) : null;
}

public EnvironmentPostProcessorApplicationListener() {
    this(EnvironmentPostProcessorsFactory::fromSpringFactories, new DeferredLogs());
}

/**
 * Create a new {@link EnvironmentPostProcessorApplicationListener} with post
 * processors created by the given factory.
 * @param postProcessorsFactory the post processors factory
 */
public EnvironmentPostProcessorApplicationListener(EnvironmentPostProcessorsFactory postProcessorsFactory) {
    this((classloader) -> postProcessorsFactory, new DeferredLogs());
}

EnvironmentPostProcessorApplicationListener(
        Function<ClassLoader, EnvironmentPostProcessorsFactory> postProcessorsFactory, DeferredLogs deferredLogs) {
    this.postProcessorsFactory = postProcessorsFactory;
    this.deferredLogs = deferredLogs;
}

# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor,\
org.springframework.boot.context.config.ConfigDataEnvironmentPostProcessor,\
org.springframework.boot.env.RandomValuePropertySourceEnvironmentPostProcessor,\
org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor,\
org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor,\
org.springframework.boot.reactor.DebugAgentEnvironmentPostProcessor

@Override
public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ApplicationEnvironmentPreparedEvent) {
        onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    }
    if (event instanceof ApplicationPreparedEvent) {
        onApplicationPreparedEvent();
    }
    if (event instanceof ApplicationFailedEvent) {
        onApplicationFailedEvent();
    }
}

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
    ConfigurableEnvironment environment = event.getEnvironment();
    SpringApplication application = event.getSpringApplication();
    // 获取并遍历后置处理器
    for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
            event.getBootstrapContext())) {
        // 后置处理
        postProcessor.postProcessEnvironment(environment, application);
    }
}

List<EnvironmentPostProcessor> getEnvironmentPostProcessors(ResourceLoader resourceLoader,
        ConfigurableBootstrapContext bootstrapContext) {
    ClassLoader classLoader = (resourceLoader != null) ? resourceLoader.getClassLoader() : null;
    EnvironmentPostProcessorsFactory postProcessorsFactory = this.postProcessorsFactory.apply(classLoader);
    // 获取后置处理器
    return postProcessorsFactory.getEnvironmentPostProcessors(this.deferredLogs, bootstrapContext);
}

public static final String NAME = "defaultProperties";

public static void moveToEnd(ConfigurableEnvironment environment) {
    moveToEnd(environment.getPropertySources());
}

public static void moveToEnd(MutablePropertySources propertySources) {
    // 移除默认属性源
    PropertySource<?> propertySource = propertySources.remove(NAME);
    if (propertySource != null) {
        // 将默认属性源添加到列表末尾
        propertySources.addLast(propertySource);
    }
}

protected void bindToSpringApplication(ConfigurableEnvironment environment) {
    try {
        // 将spring.main开头的属性办定到当前类实例中
        Binder.get(environment).bind("spring.main", Bindable.ofInstance(this));
    }
    catch (Exception ex) {
        throw new IllegalStateException("Cannot bind to SpringApplication", ex);
    }
}

StandardEnvironment convertEnvironmentIfNecessary(ConfigurableEnvironment environment,
        Class<? extends StandardEnvironment> type) {
    // 如果environment对象就是目标类型的实例，
    if (type.equals(environment.getClass())) {
        // 则直接转换
        return (StandardEnvironment) environment;
    }
    // 转换environment对象
    return convertEnvironment(environment, type);
}

private StandardEnvironment convertEnvironment(ConfigurableEnvironment environment,
        Class<? extends StandardEnvironment> type) {
    // 创建目标类型的Environment实例
    StandardEnvironment result = createEnvironment(type);
    // 设置激活的profiles
    result.setActiveProfiles(environment.getActiveProfiles());
    // 设置转换服务
    result.setConversionService(environment.getConversionService());
    // 复制属性源
    copyPropertySources(environment, result);
    return result;
}

private void configureIgnoreBeanInfo(ConfigurableEnvironment environment) {
    // 如果不存在名为spring.beaninfo.ignore的系统属性，那么从environment中获取然后设置到系统属性中
    if (System.getProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME) == null) {
        // 从environment中获取属性
        Boolean ignore = environment.getProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME,
                Boolean.class, Boolean.TRUE);
        // 设置到系统属性中
        System.setProperty(CachedIntrospectionResults.IGNORE_BEANINFO_PROPERTY_NAME, ignore.toString());
    }
}

private ApplicationContextFactory applicationContextFactory = ApplicationContextFactory.DEFAULT;

protected ConfigurableApplicationContext createApplicationContext() {
    /*
     * applicationContextFactory的默认值是ApplicationContextFactory.DEFAULT，
     * 但也可以通过setApplicationContextFactory方法来设置
     */
    return this.applicationContextFactory.create(this.webApplicationType);
}

# Application Context Factories
org.springframework.boot.ApplicationContextFactory=\
org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext.Factory,\
org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext.Factory

static class Factory implements ApplicationContextFactory {

    // 创建servlet应用上下文实例
    @Override
    public ConfigurableApplicationContext create(WebApplicationType webApplicationType) {
        return (webApplicationType != WebApplicationType.SERVLET) ? null
                : new AnnotationConfigServletWebServerApplicationContext();
    }

}

private void prepareContext(DefaultBootstrapContext bootstrapContext, ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // 应用上下文关联environment对象
    context.setEnvironment(environment);
    // 应用上下文后置处理
    postProcessApplicationContext(context);
    // 执行应用上下文初始化器
    applyInitializers(context);
    /*
     * 事件通知
     * 在Spring Cloud中会执行到BootstrapApplicationListener
     */
    listeners.contextPrepared(context);
    // 关闭启动上下文
    bootstrapContext.close(context);
    if (this.logStartupInfo) {
        logStartupInfo(context.getParent() == null); // 打印启动日志
        logStartupProfileInfo(context); // 打印profile日志
    }
    // Add boot specific singleton beans
    // 获取beanFactory并注册springApplicationArguments、 printedBanner为单例bean，另外还设置是否允许循环依赖、是否允许覆盖beanDefinition的属性
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    beanFactory.registerSingleton("springApplicationArguments", applicationArguments);
    if (printedBanner != null) {
        beanFactory.registerSingleton("springBootBanner", printedBanner);
    }
    if (beanFactory instanceof AbstractAutowireCapableBeanFactory) {
        // 设置是否允许循环依赖， 默认为false (boolean类型的默认值)。
        ((AbstractAutowireCapableBeanFactory) beanFactory).setAllowCircularReferences(this.allowCircularReferences);
        if (beanFactory instanceof DefaultListableBeanFactory) {
            // 设置是否允许覆盖beanDefinition的属性
            ((DefaultListableBeanFactory) beanFactory)
                    .setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);
        }
    }

    // 下面添加bean工厂后置处理器
    if (this.lazyInitialization) {
        context.addBeanFactoryPostProcessor(new LazyInitializationBeanFactoryPostProcessor());
    }
    context.addBeanFactoryPostProcessor(new PropertySourceOrderingBeanFactoryPostProcessor(context));
    // Load the sources
    // 获取全部配置源
    Set<Object> sources = getAllSources();
    Assert.notEmpty(sources, "Sources must not be empty");
    // 将配置源中的bean注册到beanFactory中
    load(context, sources.toArray(new Object[0]));
    // 广播应用上下文加载完成事件
    listeners.contextLoaded(context);
}

private boolean addConversionService = true;

protected void postProcessApplicationContext(ConfigurableApplicationContext context) {
    // 如果存在beanNameGenerator，那么注册到beanFactory上
    if (this.beanNameGenerator != null) {
        context.getBeanFactory().registerSingleton(AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR,
                this.beanNameGenerator);
    }
    // 如果存在resourceLoader，那么注册到applicationContext上
    if (this.resourceLoader != null) {
        if (context instanceof GenericApplicationContext) {
            ((GenericApplicationContext) context).setResourceLoader(this.resourceLoader);
        }
        if (context instanceof DefaultResourceLoader) {
            ((DefaultResourceLoader) context).setClassLoader(this.resourceLoader.getClassLoader());
        }
    }
    // （addConversionService默认为true）注册转换服务
    if (this.addConversionService) {
        context.getBeanFactory().setConversionService(context.getEnvironment().getConversionService());
    }
}