// SpringApplication類方法
public ConfigurableApplicationContext run(String... args) {
    // 記錄應(yīng)用啟動(dòng)的開始時(shí)間
    long startTime = System.nanoTime();
    // 1.創(chuàng)建引導(dǎo)上下文，用于管理應(yīng)用啟動(dòng)時(shí)的依賴和資源
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;
    // 配置無頭模式屬性，以支持在無圖形環(huán)境下運(yùn)行
    // 將系統(tǒng)屬性 java.awt.headless 設(shè)置為 true
    configureHeadlessProperty();
    // 2.獲取Spring應(yīng)用啟動(dòng)監(jiān)聽器，用于在應(yīng)用啟動(dòng)的各個(gè)階段執(zhí)行自定義邏輯
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 3.發(fā)布開始事件、通知ApplicationListener監(jiān)聽器
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    try {
        // 4.解析應(yīng)用參數(shù)
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        // 5.準(zhǔn)備應(yīng)用環(huán)境，包括讀取配置文件和設(shè)置環(huán)境變量
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);
        // 配置是否忽略 BeanInfo，以加快啟動(dòng)速度
        configureIgnoreBeanInfo(environment);
        // 6.打印啟動(dòng)Banner
        Banner printedBanner = printBanner(environment);
        // 7.創(chuàng)建應(yīng)用程序上下文
        context = createApplicationContext();
        // 設(shè)置應(yīng)用啟動(dòng)的上下文，用于監(jiān)控和管理啟動(dòng)過程
        context.setApplicationStartup(this.applicationStartup);
        // 8.準(zhǔn)備應(yīng)用上下文，包括加載配置、添加 Bean 等
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);
        // 9.刷新上下文，完成 Bean 的加載和依賴注入
        refreshContext(context);
        // 10.刷新后的一些操作，如事件發(fā)布等
        afterRefresh(context, applicationArguments);
        // 計(jì)算啟動(dòng)應(yīng)用程序的時(shí)間，并記錄日志
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }
        // 11.通知監(jiān)聽器應(yīng)用啟動(dòng)完成
        listeners.started(context, timeTakenToStartup);
        // 12.調(diào)用應(yīng)用程序中的 `CommandLineRunner` 或 `ApplicationRunner`，以便執(zhí)行自定義的啟動(dòng)邏輯
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 13.處理啟動(dòng)過程中發(fā)生的異常，并通知監(jiān)聽器
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        // 14.計(jì)算應(yīng)用啟動(dòng)完成至準(zhǔn)備就緒的時(shí)間，并通知監(jiān)聽器
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 處理準(zhǔn)備就緒過程中發(fā)生的異常
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }
    // 返回已啟動(dòng)并準(zhǔn)備就緒的應(yīng)用上下文
    return context;
}

// SpringApplication類屬性方法
// 引導(dǎo)注冊初始化器
private List<BootstrapRegistryInitializer> bootstrapRegistryInitializers;
private DefaultBootstrapContext createBootstrapContext() {
    // 創(chuàng)建一個(gè) DefaultBootstrapContext 實(shí)例，用于管理應(yīng)用啟動(dòng)時(shí)的資源和依賴
    DefaultBootstrapContext bootstrapContext = new DefaultBootstrapContext();
    // 遍歷 bootstrapRegistryInitializers 集合中的每個(gè) initializer，
    // 并調(diào)用它們的 initialize 方法，將 bootstrapContext 作為參數(shù)傳入。
    // 這一步確保每個(gè) initializer 都可以對 bootstrapContext 進(jìn)行相應(yīng)的配置，
    // 為應(yīng)用程序的啟動(dòng)過程準(zhǔn)備所需的資源。
    this.bootstrapRegistryInitializers.forEach((initializer) -> initializer.initialize(bootstrapContext));
    // 返回已完成初始化的 DefaultBootstrapContext 對象
    return bootstrapContext;
}

public interface BootstrapRegistry {
    // 注冊特定類型到注冊表。如果指定的類型已注冊且未以單例形式獲取，則將替換。
    <T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier);
    // 如果尚未存在，則注冊特定類型到注冊表。
    <T> void registerIfAbsent(Class<T> type, InstanceSupplier<T> instanceSupplier);
    // 返回給定類型是否已經(jīng)注冊。
    <T> boolean isRegistered(Class<T> type);
    // 返回給定類型的已注冊 {@link InstanceSupplier}，如果沒有則返回 null。
    <T> InstanceSupplier<T> getRegisteredInstanceSupplier(Class<T> type);
    // 添加 {@link ApplicationListener}，當(dāng) {@link BootstrapContext} 關(guān)閉且
    // {@link ApplicationContext} 準(zhǔn)備就緒時(shí)，將調(diào)用該監(jiān)聽器，并傳遞 {@link BootstrapContextClosedEvent}。
    void addCloseListener(ApplicationListener<BootstrapContextClosedEvent> listener);
    // 提供所需時(shí)創(chuàng)建實(shí)際實(shí)例的供應(yīng)者。
    @FunctionalInterface
    interface InstanceSupplier<T> {
        // 工廠方法，在需要時(shí)創(chuàng)建實(shí)例。
        T get(BootstrapContext context);
        // 返回所提供實(shí)例的作用域。
        default Scope getScope() {
            return Scope.SINGLETON;
        }
        // 返回一個(gè)具有更新 {@link Scope} 的新 {@link InstanceSupplier}。
        default InstanceSupplier<T> withScope(Scope scope) {
            Assert.notNull(scope, "Scope must not be null");
            InstanceSupplier<T> parent = this;
            return new InstanceSupplier<T>() {
                @Override
                public T get(BootstrapContext context) {
                    return parent.get(context);
                }
                @Override
                public Scope getScope() {
                    return scope;
                }
            };
        }
        // 工廠方法，用于為給定實(shí)例創(chuàng)建 {@link InstanceSupplier}。
        static <T> InstanceSupplier<T> of(T instance) {
            return (registry) -> instance;
        }
        // 工廠方法，用于從 {@link Supplier} 創(chuàng)建 {@link InstanceSupplier}。
        static <T> InstanceSupplier<T> from(Supplier<T> supplier) {
            return (registry) -> (supplier != null) ? supplier.get() : null;
        }
    }
    // 實(shí)例的作用域。
    enum Scope {
        // 單例實(shí)例。 {@link InstanceSupplier} 將僅被調(diào)用一次，并且每次都將返回相同的實(shí)例。
        SINGLETON,
        // 原型實(shí)例。 {@link InstanceSupplier} 將在每次需要實(shí)例時(shí)調(diào)用。
        PROTOTYPE
    }
}

public interface BootstrapContext {
	// 如果類型已注冊，則從上下文中返回實(shí)例。如果之前未訪問過該實(shí)例，則會(huì)創(chuàng)建該實(shí)例
	<T> T get(Class<T> type) throws IllegalStateException;
	// 如果類型已注冊，則返回上下文中的實(shí)例。如果尚未訪問該實(shí)例，則將創(chuàng)建它。
    // 如果類型未注冊，則返回指定的替代實(shí)例。
	<T> T getOrElse(Class<T> type, T other);
    // 如果類型已注冊，則返回上下文中的實(shí)例。如果尚未訪問該實(shí)例，則將創(chuàng)建它。
    // 如果類型未注冊，則使用指定的供應(yīng)者提供的實(shí)例。
	<T> T getOrElseSupply(Class<T> type, Supplier<T> other);
    // 如果類型已注冊，則返回上下文中的實(shí)例。如果尚未訪問該實(shí)例，則將創(chuàng)建它。
    // 如果類型未注冊，則拋出由供應(yīng)者提供的異常。
	<T, X extends Throwable> T getOrElseThrow(Class<T> type, Supplier<? extends X> exceptionSupplier) throws X;
	// 返回給定類型是否存在注冊
	<T> boolean isRegistered(Class<T> type);
}

public interface ConfigurableBootstrapContext extends BootstrapRegistry, BootstrapContext {
}

public class DefaultBootstrapContext implements ConfigurableBootstrapContext {
	// 存儲(chǔ)實(shí)例供應(yīng)者的映射
	private final Map<Class<?>, InstanceSupplier<?>> instanceSuppliers = new HashMap<>();
	// 存儲(chǔ)已創(chuàng)建實(shí)例的映射
	private final Map<Class<?>, Object> instances = new HashMap<>();
	// 事件廣播器，用于發(fā)布應(yīng)用事件
	private final ApplicationEventMulticaster events = new SimpleApplicationEventMulticaster();
	@Override
	public <T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier) {
		// 注冊特定類型的實(shí)例供應(yīng)者
		register(type, instanceSupplier, true);
	}
	@Override
	public <T> void registerIfAbsent(Class<T> type, InstanceSupplier<T> instanceSupplier) {
		// 如果尚未注冊，則注冊特定類型的實(shí)例供應(yīng)者
		register(type, instanceSupplier, false);
	}
	private <T> void register(Class<T> type, InstanceSupplier<T> instanceSupplier, boolean replaceExisting) {
		// 檢查類型和實(shí)例供應(yīng)者是否為空
		Assert.notNull(type, "Type must not be null");
		Assert.notNull(instanceSupplier, "InstanceSupplier must not be null");
		synchronized (this.instanceSuppliers) {
			// 檢查類型是否已注冊
			boolean alreadyRegistered = this.instanceSuppliers.containsKey(type);
			if (replaceExisting || !alreadyRegistered) {
				// 確保實(shí)例尚未創(chuàng)建
				Assert.state(!this.instances.containsKey(type), () -> type.getName() + " has already been created");
				// 注冊實(shí)例供應(yīng)者
				this.instanceSuppliers.put(type, instanceSupplier);
			}
		}
	}
	@Override
	public <T> boolean isRegistered(Class<T> type) {
		// 檢查給定類型是否已注冊
		synchronized (this.instanceSuppliers) {
			return this.instanceSuppliers.containsKey(type);
		}
	}
	@Override
	@SuppressWarnings("unchecked")
	public <T> InstanceSupplier<T> getRegisteredInstanceSupplier(Class<T> type) {
		// 返回已注冊的實(shí)例供應(yīng)者
		synchronized (this.instanceSuppliers) {
			return (InstanceSupplier<T>) this.instanceSuppliers.get(type);
		}
	}
	@Override
	public <T> T get(Class<T> type) throws IllegalStateException {
		// 獲取指定類型的實(shí)例，如果未注冊則拋出異常
		return getOrElseThrow(type, () -> new IllegalStateException(type.getName() + " has not been registered"));
	}
	@Override
	public <T> T getOrElse(Class<T> type, T other) {
		// 獲取指定類型的實(shí)例，如果未注冊則返回其他提供的實(shí)例
		return getOrElseSupply(type, () -> other);
	}
	@Override
	public <T> T getOrElseSupply(Class<T> type, Supplier<T> other) {
		// 嘗試獲取指定類型的實(shí)例，如果未注冊則調(diào)用其他供應(yīng)者
		synchronized (this.instanceSuppliers) {
			InstanceSupplier<?> instanceSupplier = this.instanceSuppliers.get(type);
			return (instanceSupplier != null) ? getInstance(type, instanceSupplier) : other.get();
		}
	}
	@Override
	public <T, X extends Throwable> T getOrElseThrow(Class<T> type, Supplier<? extends X> exceptionSupplier) throws X {
		// 嘗試獲取指定類型的實(shí)例，如果未注冊則拋出由供應(yīng)者提供的異常
		synchronized (this.instanceSuppliers) {
			InstanceSupplier<?> instanceSupplier = this.instanceSuppliers.get(type);
			if (instanceSupplier == null) {
				throw exceptionSupplier.get();
			}
			return getInstance(type, instanceSupplier);
		}
	}
	@SuppressWarnings("unchecked")
	private <T> T getInstance(Class<T> type, InstanceSupplier<?> instanceSupplier) {
		// 獲取實(shí)例，如果尚未創(chuàng)建則調(diào)用實(shí)例供應(yīng)者
		T instance = (T) this.instances.get(type);
		if (instance == null) {
			instance = (T) instanceSupplier.get(this);
			// 如果作用域?yàn)閱卫?，則存儲(chǔ)該實(shí)例
			if (instanceSupplier.getScope() == Scope.SINGLETON) {
				this.instances.put(type, instance);
			}
		}
		return instance;
	}
	@Override
	public void addCloseListener(ApplicationListener<BootstrapContextClosedEvent> listener) {
		// 添加關(guān)閉監(jiān)聽器，當(dāng) BootstrapContext 關(guān)閉時(shí)觸發(fā)
		this.events.addApplicationListener(listener);
	}
	/**
	 * 當(dāng) {@link BootstrapContext} 關(guān)閉且 {@link ApplicationContext} 已準(zhǔn)備好時(shí)調(diào)用的方法。
	 * @param applicationContext 已準(zhǔn)備好的上下文
	 */
	public void close(ConfigurableApplicationContext applicationContext) {
		// 發(fā)布 BootstrapContext 關(guān)閉事件
		this.events.multicastEvent(new BootstrapContextClosedEvent(this, applicationContext));
	}
}

@FunctionalInterface
public interface BootstrapRegistryInitializer {
    // 此方法在應(yīng)用啟動(dòng)過程中被調(diào)用，允許實(shí)現(xiàn)者向注冊表注冊必要的組件或服務(wù)。
    // 注冊的組件隨后可以在應(yīng)用上下文中訪問。實(shí)現(xiàn)者應(yīng)僅注冊應(yīng)用所需的類型。
    void initialize(BootstrapRegistry registry);
}

public class MyBootstrapRegistryInitializer implements BootstrapRegistryInitializer {
    @Override
    public void initialize(BootstrapRegistry registry) {
        // 注冊一個(gè)自定義服務(wù)
        registry.register(MyCustomService.class, context -> new MyCustomService());
        System.out.println("MyBootstrapRegistryInitializer已注冊");
    }
}
class MyCustomService {
}

org.springframework.boot.BootstrapRegistryInitializer=com.xc.config.MyBootstrapRegistryInitializer