SpringBoot源码解析(五)：准备应用环境

// SpringApplication类方法
public ConfigurableApplicationContext run(String... args) {
    // 记录应用启动的开始时间
    long startTime = System.nanoTime();

    // 1.创建引导上下文，用于管理应用启动时的依赖和资源
    DefaultBootstrapContext bootstrapContext = createBootstrapContext();
    ConfigurableApplicationContext context = null;

    // 配置无头模式属性，以支持在无图形环境下运行
    // 将系统属性 java.awt.headless 设置为 true
    configureHeadlessProperty();

    // 2.获取Spring应用启动监听器，用于在应用启动的各个阶段执行自定义逻辑
    SpringApplicationRunListeners listeners = getRunListeners(args);
    // 启动开始方法（发布开始事件、通知应用监听器ApplicationListener）
    listeners.starting(bootstrapContext, this.mainApplicationClass);

    try {
        // 3.解析应用参数
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);

        // 4.准备应用环境，包括读取配置文件和设置环境变量
        ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

        // 配置是否忽略 BeanInfo，以加快启动速度
        configureIgnoreBeanInfo(environment);

        // 5.打印启动Banner
        Banner printedBanner = printBanner(environment);

        // 6.创建应用程序上下文
        context = createApplicationContext();
        
        // 设置应用启动的上下文，用于监控和管理启动过程
        context.setApplicationStartup(this.applicationStartup);

        // 7.准备应用上下文，包括加载配置、添加 Bean 等
        prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);

        // 8.刷新上下文，完成 Bean 的加载和依赖注入
        refreshContext(context);

        // 9.刷新后的一些操作，如事件发布等
        afterRefresh(context, applicationArguments);

        // 计算启动应用程序的时间，并记录日志
        Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);
        if (this.logStartupInfo) {
            new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);
        }

        // 10.通知监听器应用启动完成
        listeners.started(context, timeTakenToStartup);

        // 11.调用应用程序中的 `CommandLineRunner` 或 `ApplicationRunner`，以便执行自定义的启动逻辑
        callRunners(context, applicationArguments);
    }
    catch (Throwable ex) {
        // 12.处理启动过程中发生的异常，并通知监听器
        handleRunFailure(context, ex, listeners);
        throw new IllegalStateException(ex);
    }
    try {
        // 13.计算应用启动完成至准备就绪的时间，并通知监听器
        Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);
        listeners.ready(context, timeTakenToReady);
    }
    catch (Throwable ex) {
        // 处理准备就绪过程中发生的异常
        handleRunFailure(context, ex, null);
        throw new IllegalStateException(ex);
    }

    // 返回已启动并准备就绪的应用上下文
    return context;
}

// 4.准备应用环境，包括读取配置文件和设置环境变量
ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);

// SpringApplication类方法
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners,
        DefaultBootstrapContext bootstrapContext, ApplicationArguments applicationArguments) {
    // 4.1.获取环境实例 ApplicationServletEnvironment
    ConfigurableEnvironment environment = getOrCreateEnvironment();
    
    // 4.2.配置环境
    // 将命令行参数传递给环境配置
    configureEnvironment(environment, applicationArguments.getSourceArgs());
    // 添加配置属性源到环境中，使其能够解析相关配置属性
    ConfigurationPropertySources.attach(environment);
    
    // 4.3.通知监听器，环境已准备好
    listeners.environmentPrepared(bootstrapContext, environment);
    
    // 4.4.将默认属性源移到环境属性源列表的末尾
    DefaultPropertiesPropertySource.moveToEnd(environment);
    
    // spring.main.environment-prefix是SpringBoot用于管理上下文环境的一部分
    // 不应该由用户直接修改，如果被用户定义，则抛错
    Assert.state(!environment.containsProperty("spring.main.environment-prefix"),
            "Environment prefix cannot be set via properties.");
    
    // 4.5.绑定spring.main环境配置到SpringApplication对象上
    bindToSpringApplication(environment);
    
    // 如果环境不是自定义的，则进行环境转换，确定必要的环境类型
    if (!this.isCustomEnvironment) {
        EnvironmentConverter environmentConverter = new EnvironmentConverter(getClassLoader());
        environment = environmentConverter.convertEnvironmentIfNecessary(environment, deduceEnvironmentClass());
    }
    
    // 再次设置配置属性源，确保配置属性源在第一位
    ConfigurationPropertySources.attach(environment);
    
    // 返回配置完成的环境对象
    return environment;
}

// 用于解析属性值的接口，支持从底层源解析属性
public interface PropertyResolver {
	// 判断指定的属性键是否可用，即该键对应的值是否不为null
	boolean containsProperty(String key);
	// 返回与指定键关联的属性值，如果未找到则返回null
	@Nullable
	String getProperty(String key);
	// 返回与指定键关联的属性值，如果未找到则返回默认值
	String getProperty(String key, String defaultValue);
	
	// 返回与指定键关联的属性值，并将其转换为指定的目标类型，如果未找到则返回null
	@Nullable
	<T> T getProperty(String key, Class<T> targetType);
	// 返回与指定键关联的属性值，并将其转换为目标类型，如果未找到则返回默认值
	<T> T getProperty(String key, Class<T> targetType, T defaultValue);
	
	// 返回与指定键关联的属性值（不能为null）
	String getRequiredProperty(String key) throws IllegalStateException;
	// 返回与指定键关联的属性值，并将其转换为目标类型（不能为null）
	<T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;

	// 解析给定文本中的 ${...} 占位符，并用对应的属性值替换。
	// 未解析的占位符会被忽略并原样返回。
	String resolvePlaceholders(String text);
	// 解析给定文本中的 ${...} 占位符，并用对应的属性值替换
	// 未解析的占位符将抛出 IllegalArgumentException 异常
	String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;
}

// 表示当前应用程序运行环境的接口
public interface Environment extends PropertyResolver {
	// 返回当前环境中激活的Profiles
	String[] getActiveProfiles();
	// 返回当前环境中默认激活的 Profiles
	String[] getDefaultProfiles();
	// 检查给定的 Profile 表达式是否与当前激活的 Profiles 匹配
	default boolean matchesProfiles(String... profileExpressions) {
		return acceptsProfiles(Profiles.of(profileExpressions));
	}
	// 检查一个或多个给定的 Profiles 是否被当前环境接受
	@Deprecated
	boolean acceptsProfiles(String... profiles);
	// 检查给定的 Profiles 谓词是否与当前激活的或默认的 Profiles 匹配
	boolean acceptsProfiles(Profiles profiles);
}

// 用于在将属性值从一种类型转换为另一种类型时使用
public interface ConfigurablePropertyResolver extends PropertyResolver {
	// 获取用于属性值类型转换的 ConfigurableConversionService 实例
	ConfigurableConversionService getConversionService();
	// 设置类型转换服务
	void setConversionService(ConfigurableConversionService conversionService);

	// 设置占位符的前缀，默认为 ${
	// 示例：若设置为 #{，则占位符形如 #{property}
	void setPlaceholderPrefix(String placeholderPrefix);
	// 设置占位符的后缀，默认为 }
	// 示例：与 setPlaceholderPrefix 配合使用，解析 #{property}
	void setPlaceholderSuffix(String placeholderSuffix);

	// 设置占位符和默认值之间的分隔符，默认值为 :
	// 示例：${property:defaultValue} 表示如果 property 未定义，则返回 defaultValue
	void setValueSeparator(@Nullable String valueSeparator);
	// 设置是否忽略无法解析的嵌套占位符
	// true：保留未解析的占位符（如 ${unresolved}）
	// false：遇到未解析的占位符时抛出异常
	void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders);

	// 设置必须存在的属性
	void setRequiredProperties(String... requiredProperties);
	// 验证所有必需属性是否存在并解析为非 null
	void validateRequiredProperties() throws MissingRequiredPropertiesException;
}

public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
	// 设置当前环境的 Active Profiles（激活的配置）
	void setActiveProfiles(String... profiles);
	// 向当前的 Active Profiles 集合中添加一个 Profile
	void addActiveProfile(String profile);
	// 设置默认激活的 Profile 集合
	void setDefaultProfiles(String... profiles);

	// 返回当前环境的属性源集合，允许动态操作属性源
	MutablePropertySources getPropertySources();
	// 返回JVM的系统属性（System.getProperties()）
	Map<String, Object> getSystemProperties();
	// 返回操作系统的环境变量（System.getenv()）
	Map<String, Object> getSystemEnvironment();
	// 将父环境的 Active Profiles、Default Profiles 和 属性源 合并到当前环境中
	void merge(ConfigurableEnvironment parent);
}

public interface ConfigurableWebEnvironment extends ConfigurableEnvironment {
	// 使用给定的 ServletContext 和（可选的）ServletConfig 初始化属性源。
	// 该方法会将占位符性质的属性源替换为实际的 Servlet 上下文或配置属性源。
	// 调用时机：Spring Boot 中的内嵌容器（如 Tomcat、Jetty）启动时
	void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig);
}

public abstract class AbstractEnvironment implements ConfigurableEnvironment {
	// 激活配置文件集合
    private final Set<String> activeProfiles = new LinkedHashSet<>();
	// 默认配置文件集合 getReservedDefaultProfiles() = 字符串“default”
    private final Set<String> defaultProfiles = new LinkedHashSet<>(getReservedDefaultProfiles());
	// 属性源集合，上篇文章有介绍，属性源就是一组属性map键值对，这里集合就是多组键值对
    private final MutablePropertySources propertySources;
	// 属性解析器
    private final ConfigurablePropertyResolver propertyResolver;
	
    public AbstractEnvironment() {
        this(new MutablePropertySources());
    }
    protected AbstractEnvironment(MutablePropertySources propertySources) {
        this.propertySources = propertySources;
        this.propertyResolver = createPropertyResolver(propertySources);
        customizePropertySources(propertySources);
    }
	
	// 自定义属性源，对属性源增删改查做操作
    protected void customizePropertySources(MutablePropertySources propertySources) {
        // 默认无操作，子类可覆盖
    }
   
    // 省略其他方法
}

public abstract class PropertySource<T> {
	// 属性源名称，唯一标识
    protected final String name;
    // 一般是map键值对
    protected final T source;
    ...
}

public class MutablePropertySources implements PropertySources {
	// 属性源集合
	private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();
	...
}

public class StandardEnvironment extends AbstractEnvironment {
	// 系统环境变量属性源的名称
    public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";
    // JVM 系统属性源的名称
    public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";
    
    public StandardEnvironment() {
    }
    protected StandardEnvironment(MutablePropertySources propertySources) {
        super(propertySources);
    }

	// 自定义操作属性源，父类构造中会调用
    @Override
    protected void customizePropertySources(MutablePropertySources propertySources) {
    	// addLast将属性放到最后，优先级最低，JVM优先级高于环境变量
        propertySources.addLast(
        		// 通过 System.getProperties() 提供的 JVM 系统属性
                new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
        propertySources.addLast(
        		// 通过 System.getenv() 提供的环境变量
                new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
    }
}

public class StandardServletEnvironment extends StandardEnvironment implements ConfigurableWebEnvironment {
	// ServletContext 初始化参数属性源的名称
    public static final String SERVLET_CONTEXT_PROPERTY_SOURCE_NAME = "servletContextInitParams";
    // ServletConfig 初始化参数属性源的名称
    public static final String SERVLET_CONFIG_PROPERTY_SOURCE_NAME = "servletConfigInitParams";
    
    // JNDI 属性源名称
    public static final String JNDI_PROPERTY_SOURCE_NAME = "jndiProperties";
    // 防御性地引用 JNDI API，用于 JDK 9+（可选的 java.naming 模块）
    private static final boolean jndiPresent = ClassUtils.isPresent(
            "javax.naming.InitialContext", StandardServletEnvironment.class.getClassLoader());

    public StandardServletEnvironment() {
    }
    protected StandardServletEnvironment(MutablePropertySources propertySources) {
        super(propertySources);
    }
	// 自定义属性源集合，添加超类贡献的属性源
    @Override
    protected void customizePropertySources(MutablePropertySources propertySources) {
        // 添加 ServletConfig 初始化参数占位符属性源
        propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
        // 添加 ServletContext 初始化参数占位符属性源
        propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
        // 如果 JNDI 可用且默认环境可用，则添加 JNDI 属性源
        if (jndiPresent && JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
            propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
        }
        // 调用父类的自定义属性源方法
        super.customizePropertySources(propertySources);
    }
	// 初始化属性源，将 Servlet 相关的属性源（如 ServletContext 和 ServletConfig）初始化为真实属性源
    @Override
    public void initPropertySources(@Nullable ServletContext servletContext, @Nullable ServletConfig servletConfig) {
        WebApplicationContextUtils.initServletPropertySources(getPropertySources(), servletContext, servletConfig);
    }
}

class ApplicationServletEnvironment extends StandardServletEnvironment {
	// 表示不从任何特定的属性（如 spring.profiles.active）获取活动配置文件
    @Override
    protected String doGetActiveProfilesProperty() {
        return null;
    }
	// 表示不从任何特定的属性（如 spring.profiles.default）获取默认配置文件
    @Override
    protected String doGetDefaultProfilesProperty() {
        return null;
    }
	// 自定义属性解析器，
	// 默认使用ConfigurationPropertySources的实现，这里重写实现为ConfigurationPropertySourcesPropertyResolver
    @Override
    protected ConfigurablePropertyResolver createPropertyResolver(MutablePropertySources propertySources) {
        return ConfigurationPropertySources.createPropertyResolver(propertySources);
    }
}

// 4.2.配置环境
// 将命令行参数传递给环境配置
configureEnvironment(environment, applicationArguments.getSourceArgs());

// 配置环境方法
protected void configureEnvironment(ConfigurableEnvironment environment, String[] args) {
    // 如果需要添加转换服务，用于在应用程序中管理和执行各种类型之间的转换
    if (this.addConversionService) {
        // 设置转换服务为一个新的 ApplicationConversionService 实例
        environment.setConversionService(new ApplicationConversionService());
    }
    // 配置属性源（将命令行参数添加到属性源集合中，放第一位优先级最高）
    configurePropertySources(environment, args);
    // 配置活动的配置文件，空实现
    configureProfiles(environment, args);
}

/**
 * 配置属性源的方法。
 * @param environment 可配置的环境对象，用于管理属性源
 * @param args        应用程序启动时传入的命令行参数
 */
protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
    // 获取当前环境中的属性源集合
    MutablePropertySources sources = environment.getPropertySources();
    // 如果存在默认属性（defaultProperties），将其添加或合并到属性源中
    if (!CollectionUtils.isEmpty(this.defaultProperties)) {
        DefaultPropertiesPropertySource.addOrMerge(this.defaultProperties, sources);
    }
    // 如果启用了命令行属性解析，并且命令行参数非空
    if (this.addCommandLineProperties && args.length > 0) {
        // 获取命令行属性源的默认名称 “commandLineArgs”
        String name = CommandLinePropertySource.COMMAND_LINE_PROPERTY_SOURCE_NAME;
        // 如果当前属性源集合中已经包含命令行属性源，这里第一次进来不包含
        if (sources.contains(name)) {
            // 获取已存在的命令行属性源
            PropertySource<?> source = sources.get(name);
            // 创建一个组合属性源，用于合并新的和已有的命令行属性
            CompositePropertySource composite = new CompositePropertySource(name);
            // 将新的命令行参数解析为属性源并添加到组合属性源中
            composite.addPropertySource(new SimpleCommandLinePropertySource("springApplicationCommandLineArgs", args));
            // 添加已有的命令行属性源到组合属性源中
            composite.addPropertySource(source);
            // 替换旧的命令行属性源为新的组合属性源
            sources.replace(name, composite);
        } else {
            // 如果属性源集合中不存在命令行属性源，则直接将解析的命令行属性源添加到最前面
            sources.addFirst(new SimpleCommandLinePropertySource(args));
        }
    }
}

// 4.2.配置环境
// 添加配置属性源到环境中，使其能够解析相关配置属性
ConfigurationPropertySources.attach(environment);

public static void attach(Environment environment) {
    // 确保传入的 environment 是 ConfigurableEnvironment 类型
    Assert.isInstanceOf(ConfigurableEnvironment.class, environment);
    // 获取当前环境的属性源集合
    MutablePropertySources sources = ((ConfigurableEnvironment) environment).getPropertySources();
    // 检查是否已经附加了名为“configurationProperties”的属性源
    PropertySource<?> attached = getAttached(sources);
    // 如果尚未附加，或者附加的属性源未正确使用当前属性源集合
    if (attached == null || !isUsingSources(attached, sources)) {
        // 创建一个新的 ConfigurationPropertySourcesPropertySource，
        // 它包装了当前的属性源集合
        attached = new ConfigurationPropertySourcesPropertySource(
            ATTACHED_PROPERTY_SOURCE_NAME, 
            new SpringConfigurationPropertySources(sources)
        );
    }
    // 移除已有的同名属性源（如果存在）
    sources.remove(ATTACHED_PROPERTY_SOURCE_NAME);
    // 将新的属性源添加到属性源集合的最前面，确保其具有最高优先级
    sources.addFirst(attached);
}

// 4.3.通知监听器，环境已准备好
listeners.environmentPrepared(bootstrapContext, environment);

// 当应用环境准备事件触发时执行的方法
private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
    // 获取应用的环境配置
    ConfigurableEnvironment environment = event.getEnvironment();
    // 获取 Spring 应用对象
    SpringApplication application = event.getSpringApplication();
    // 遍历所有的 EnvironmentPostProcessor（环境后置处理器）
    for (EnvironmentPostProcessor postProcessor : getEnvironmentPostProcessors(application.getResourceLoader(),
            event.getBootstrapContext())) {
        // 调用每个后置处理器的 postProcessEnvironment 方法，处理环境配置
        postProcessor.postProcessEnvironment(environment, application);
    }
}

// 环境后置处理器接口
@FunctionalInterface
public interface EnvironmentPostProcessor {
	void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application);
}

# 动态生成一个 UUID
my.secret.key=${random.uuid}
# 一个介于 1024 和 65535 之间的随机整数
my.random.port=${random.int[1024,65535]}

logging.level.org.springframework.core.env=DEBUG

2024-11-24 12:34:56.123 DEBUG o.s.b.c.c.ConfigFileApplicationListener - Loaded property source 'applicationConfig: [classpath:/application.properties]'
2024-11-24 12:34:56.124 DEBUG o.s.b.c.c.ConfigFileApplicationListener - Loaded property source 'applicationConfig: [classpath:/application.yml]'
2024-11-24 12:34:56.125 DEBUG o.s.b.e.e.PropertySourcesPropertyResolver - Found key 'my.app.port' in 'systemEnvironment' with value '8080'

export SPRING_APPLICATION_JSON='{"server.port":8081,"spring.datasource.url":"jdbc:mysql://localhost:3306/mydb"}'
java -jar my-app.jar

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
    String json = environment.getProperty("SPRING_APPLICATION_JSON");
    if (StringUtils.hasText(json)) {
        try {
            Map<String, Object> map = parseJson(json);
            PropertySource<?> propertySource = new MapPropertySource("spring.application.json", map);
            environment.getPropertySources().addFirst(propertySource);
        } catch (Exception ex) {
            throw new IllegalStateException("Invalid SPRING_APPLICATION_JSON: " + json, ex);
        }
    }
}

// 4.4.将默认属性源移到环境属性源列表的末尾
DefaultPropertiesPropertySource.moveToEnd(environment);

@Configuration
public class DefaultPropertyConfig {
    @Bean
    public PropertySource<?> defaultPropertySource() {
        return new MapPropertySource("defaultProperties", Map.of(
            "server.port", "8080"
        ));
    }
}

// 4.5.绑定spring.main环境配置到SpringApplication对象上
bindToSpringApplication(environment);