# 精尽 Spring Boot 源码分析 —— 配置加载

# 1. 概述

在使用 Spring Boot 时，我们可以很方便的在 `application.properties` 或 `application.yml` 配置文件中，添加相应的应用所需的配置。那么，究竟 Spring Boot 是如何实现该功能的呢，今儿我们就通过 Spring Boot 的源码，一探究竟！

> 艿艿的高能提示：这篇会非常长，建议胖友保持耐心。另外，最好边调试边看~

# 2. Profiles

在讲配置加载之前，不得不先提下 Spring Profiles 功能。

- 如果不熟悉的胖友，先看看 [《详解 Spring 中的 Profile》](https://www.jianshu.com/p/948c303b2253) 文章。
- 关于这一块，之前在 [《【死磕 Spring】—— 环境 & 属性：PropertySource、Environment、Profile》](http://svip.iocoder.cn/Spring/PropertySource-and-Environment-and-Profile/) 中，已经有详细的源码解析。

😈 Spring Boot 在 Spring Framework 的基础之上，可以手动附加新的 Profile 。在 [《精尽 Spring Boot 源码分析 —— SpringApplication》](http://svip.iocoder.cn/Spring-Boot/SpringApplication/) 的 `#` 。代码如下：

```
// SpringApplication.java

/**
 * 附加的 profiles 的数组
 */
private Set<String> additionalProfiles = new HashSet<>();

protected void configureProfiles(ConfigurableEnvironment environment, String[] args) {
    environment.getActiveProfiles(); // ensure they are initialized 保证已经被初始化
    // But these ones should go first (last wins in a property key clash)
    Set<String> profiles = new LinkedHashSet<>(this.additionalProfiles);
    profiles.addAll(Arrays.asList(environment.getActiveProfiles())); // <X>
    // 设置 activeProfiles
    environment.setActiveProfiles(StringUtils.toStringArray(profiles));
}
```

- `additionalProfiles` 属性，可以设置创建的 SpringApplication 可以附加的 `additionalProfiles` 属性。
- `<X>` 处，在原有 Spring Framework 中设置的 String Profiles 的基础上，又附加上了 `SpringApplication.additionalProfiles` 配置的。

> 艿艿：这个小节，讲的有点绕，胖友辛苦理解下~

# 3. ConfigFileApplicationListener

Spring Boot 实现 `application.properties` 或 `application.yml` 配置文件的加载，关键在于 ConfigFileApplicationListener 类。在 [《精尽 Spring Boot 源码分析 —— ApplicationListener》](http://svip.iocoder.cn/Spring-Boot/ApplicationListener/) 中，我们已经简单介绍过它：

> `org.springframework.boot.context.config.ConfigFileApplicationListener` ，实现 SmartApplicationListener、Ordered、EnvironmentPostProcessor 接口，实现 Spring Boot 配置文件的加载。

- 注意哟，ConfigFileApplicationListener 即是一个 SmartApplicationListener 实现类，又是一个 EnvironmentPostProcessor 实现类。

## 3.1 onApplicationEvent

实现 `#onApplicationEvent(ApplicationEvent event)` 方法，分别对 ApplicationEnvironmentPreparedEvent、ApplicationPreparedEvent 事件进行处理。代码如下：

```
// ConfigFileApplicationListener.java

@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
    return ApplicationEnvironmentPreparedEvent.class.isAssignableFrom(eventType)
            || ApplicationPreparedEvent.class.isAssignableFrom(eventType);
}

@Override
public void onApplicationEvent(ApplicationEvent event) {
    // <1> 如果是 ApplicationEnvironmentPreparedEvent 事件，说明 Spring 环境准备好了，则执行相应的处理
    if (event instanceof ApplicationEnvironmentPreparedEvent) {
        onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
    }
    // <2> 如果是 ApplicationPreparedEvent 事件，说明 Spring 容器初始化好了，则进行相应的处理。
    if (event instanceof ApplicationPreparedEvent) {
        onApplicationPreparedEvent(event);
    }
}
```

- `<1>` 处，如果是 ApplicationEnvironmentPreparedEvent 事件，说明 Spring 环境准备好了，则调用 `#onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent)` 方法，执行相应的处理。详细解析，见 [「3.2 onApplicationEnvironmentPreparedEvent」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。
- `<2>` 处，如果是 ApplicationPreparedEvent 事件，说明 Spring 容器初始化好了，则调用 `#onApplicationPreparedEvent(ApplicationPreparedEvent)` 方法，进行相应的处理。详细解析，见 [「3.3 onApplicationPreparedEvent」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

## 3.2 onApplicationEnvironmentPreparedEvent

`#onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent)` 方法，处理 ApplicationEnvironmentPreparedEvent 事件。代码如下：

```
// ConfigFileApplicationListener.java

private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) {
    // <1.1> 加载指定类型 EnvironmentPostProcessor 对应的，在 `META-INF/spring.factories` 里的类名的数组
    List<EnvironmentPostProcessor> postProcessors = loadPostProcessors();
    // 加入自己
    postProcessors.add(this);
    // 排序 postProcessors 数组
    AnnotationAwareOrderComparator.sort(postProcessors);
    // 遍历 postProcessors 数组，逐个执行。
    for (EnvironmentPostProcessor postProcessor : postProcessors) {
        postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication());
    }
}
```

- `<1.1>` 处，调用 `#loadPostProcessors()` 方法，加载指定类型 EnvironmentPostProcessor 对应的，在 `META-INF/spring.factories` 里的类名的数组。代码如下：

  ```
  // ConfigFileApplicationListener.java
  
  List<EnvironmentPostProcessor> loadPostProcessors() {
  	return SpringFactoriesLoader.loadFactories(EnvironmentPostProcessor.class, getClass().getClassLoader());
  }
  ```

  - 默认情况下，返回的是 SystemEnvironmentPropertySourceEnvironmentPostProcessor、SpringApplicationJsonEnvironmentPostProcessor、CloudFoundryVcapEnvironmentPostProcessor 类。

- `<1.2>` 处，加入自己，到 `postProcessors` 数组中。因为自己也是一个 EnvironmentPostProcessor 实现类。

- `<2>` 处，排序 `postProcessors` 数组。

- `<3>` 处，遍历 `postProcessors` 数组，调用 `EnvironmentPostProcessor#postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application)` 方法，逐个执行。

那么，我们开始来逐个看看每个 EnvironmentPostProcessor 实现类。考虑到 EnvironmentPostProcessor 应有的独立性（尊严!），我们单独开了 [「4. EnvironmentPostProcessor」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 小节，所以胖友先一起跳过来看看。

> 艿艿：这块涉及的逻辑非常多。本文的 4、5、6、7 小节，都和 [「3.2 onApplicationEnvironmentPreparedEvent」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 有关。

## 3.3 onApplicationPreparedEvent

`#onApplicationPreparedEvent(ApplicationEvent event)` 方法，处理 ApplicationPreparedEvent 事件。代码如下：

```
// ConfigFileApplicationListener.java

private void onApplicationPreparedEvent(ApplicationEvent event) {
    // 修改 logger 文件，暂时可以无视。
    this.logger.switchTo(ConfigFileApplicationListener.class);
    // 添加 PropertySourceOrderingPostProcessor 处理器
    addPostProcessors(((ApplicationPreparedEvent) event).getApplicationContext());
}

protected void addPostProcessors(ConfigurableApplicationContext context) {
    context.addBeanFactoryPostProcessor(new PropertySourceOrderingPostProcessor(context));
}
```

- 添加 PropertySourceOrderingPostProcessor 处理器。关于 PropertySourceOrderingPostProcessor 类，见 [「3.3.1 PropertySourceOrderingPostProcessor」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中。

### 3.3.1 PropertySourceOrderingPostProcessor

PropertySourceOrderingPostProcessor ，是 ConfigFileApplicationListener 内部类，实现 BeanFactoryPostProcessor、Ordered 接口，将 `DEFAULT_PROPERTIES` 的 PropertySource 属性源，添加到 `environment` 的尾部。代码如下：

```
// ConfigFileApplicationListener.java
private static final String DEFAULT_PROPERTIES = "defaultProperties";

// ConfigFileApplicationListener#PropertySourceOrderingPostProcessor.java

private class PropertySourceOrderingPostProcessor implements BeanFactoryPostProcessor, Ordered {

    private ConfigurableApplicationContext context;

    PropertySourceOrderingPostProcessor(ConfigurableApplicationContext context) {
        this.context = context;
    }

    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        reorderSources(this.context.getEnvironment());
    }

    private void reorderSources(ConfigurableEnvironment environment) {
        // 移除 DEFAULT_PROPERTIES 的属性源
        PropertySource<?> defaultProperties = environment.getPropertySources().remove(DEFAULT_PROPERTIES);
        // 添加到 environment 尾部
        if (defaultProperties != null) {
            environment.getPropertySources().addLast(defaultProperties);
        }
    }

}
```

- 那么 `DEFAULT_PROPERTIES` 对应的 PropertySource 属性源，究竟是哪里来的呢？答案见 `SpringApplication.defaultProperties` 相关，代码如下：

```
// SpringApplication.java 

/**
 * 默认的属性集合
 */
private Map<String, Object> defaultProperties;

protected void configurePropertySources(ConfigurableEnvironment environment, String[] args) {
	MutablePropertySources sources = environment.getPropertySources();
	// 配置的 defaultProperties
	if (this.defaultProperties != null && !this.defaultProperties.isEmpty()) {
		sources.addLast(new MapPropertySource("defaultProperties", this.defaultProperties));
	}
	
	// ... 省略无关代码
}
```

# 4. EnvironmentPostProcessor

`org.springframework.boot.context.config.EnvironmentPostProcessor` 接口，在 Environment 加载完成之后，如果我们需要对其进行一些配置、增加一些自己的处理逻辑，那么请使用 EnvironmentPostProcessor 。代码如下：

```
// EnvironmentPostProcessor.java

/**
 * Allows for customization of the application's {@link Environment} prior to the
 * application context being refreshed.
 * <p>
 * EnvironmentPostProcessor implementations have to be registered in
 * {@code META-INF/spring.factories}, using the fully qualified name of this class as the
 * key.
 * <p>
 * {@code EnvironmentPostProcessor} processors are encouraged to detect whether Spring's
 * {@link org.springframework.core.Ordered Ordered} interface has been implemented or if
 * the {@link org.springframework.core.annotation.Order @Order} annotation is present and
 * to sort instances accordingly if so prior to invocation.
 *
 * @author Andy Wilkinson
 * @author Stephane Nicoll
 * @since 1.3.0
 */
@FunctionalInterface
public interface EnvironmentPostProcessor {

	/**
	 * Post-process the given {@code environment}.
	 * @param environment the environment to post-process
	 * @param application the application to which the environment belongs
	 */
	void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application);

}
```

从实现上和作用上来说，和 [《【死磕 Spring】—— IoC 之深入分析 BeanPostProcessor》](http://svip.iocoder.cn/Spring/IoC-BeanPostProcessor/) 都是非常类似的。

EnvironmentPostProcessor 的实现类，如下图所示：[![EnvironmentPostProcessor 实现类](14-Spring Boot 源码分析-配置加载.assets/01.jpg)](http://static.iocoder.cn/images/Spring-Boot/2021-01-28/01.jpg)EnvironmentPostProcessor 实现类

## 4.1 CloudFoundryVcapEnvironmentPostProcessor

`org.springframework.boot.cloud.CloudFoundryVcapEnvironmentPostProcessor` ，实现 EnvironmentPostProcessor、Ordered 接口，实现对 [Cloud Foundry](https://www.cloudfoundry.org/) 的支持。因为我们不使用 Cloud Foundry ，所以可以跳过对 CloudFoundryVcapEnvironmentPostProcessor 源码的了解。感兴趣的胖友，可以结合 [《Spring Boot 参考指南（部署到云）》](https://segmentfault.com/a/1190000015088555) 文章，对源码进行研究。

## 4.2 SystemEnvironmentPropertySourceEnvironmentPostProcessor

> 艿艿：选看~

`org.springframework.boot.env.SystemEnvironmentPropertySourceEnvironmentPostProcessor` ，实现 EnvironmentPostProcessor、Ordered 接口，实现将 `environment` 中的 `systemEnvironment` 对应的 PropertySource 属性源对象，替换成 OriginAwareSystemEnvironmentPropertySource 对象。代码如下：

```
// SystemEnvironmentPropertySourceEnvironmentPostProcessor.java

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
    // <1> 获得 systemEnvironment 对应的 PropertySource 属性源
    String sourceName = StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME;
    PropertySource<?> propertySource = environment.getPropertySources().get(sourceName);
    // <2> 将原始的 PropertySource 对象，替换成 OriginAwareSystemEnvironmentPropertySource 对象
    if (propertySource != null) {
        replacePropertySource(environment, sourceName, propertySource);
    }
}

@SuppressWarnings("unchecked")
private void replacePropertySource(ConfigurableEnvironment environment, String sourceName, PropertySource<?> propertySource) {
    Map<String, Object> originalSource = (Map<String, Object>) propertySource.getSource();
    // 创建 SystemEnvironmentPropertySource 对象
    SystemEnvironmentPropertySource source = new OriginAwareSystemEnvironmentPropertySource(sourceName, originalSource);
    // 进行替换
    environment.getPropertySources().replace(sourceName, source);
}
```

- `<1>` 处，获得 `systemEnvironment` 对应的 PropertySource 属性源。

- `<2>` 处，调用 `#replacePropertySource(...)` 方法，将原始的 PropertySource 对象，替换成 OriginAwareSystemEnvironmentPropertySource 对象。

- 其中，OriginAwareSystemEnvironmentPropertySource 是 SystemEnvironmentPropertySourceEnvironmentPostProcessor 内部类，继承 SystemEnvironmentPropertySource 类，实现 OriginLookup 接口，代码如下：

  ```
  // SystemEnvironmentPropertySourceEnvironmentPostProcessor#OriginAwareSystemEnvironmentPropertySource.java
  protected static class OriginAwareSystemEnvironmentPropertySource
  		extends SystemEnvironmentPropertySource implements OriginLookup<String> {
  
  	OriginAwareSystemEnvironmentPropertySource(String name, Map<String, Object> source) {
  		super(name, source);
  	}
  
  	@Override
  	public Origin getOrigin(String key) {
  	    // 解析 key 对应的 property
  		String property = resolvePropertyName(key);
  		// 判断是否存在 property 对应的值。如果存在，则返回 SystemEnvironmentOrigin 对象
  		if (super.containsProperty(property)) {
  			return new SystemEnvironmentOrigin(property);
  		}
  		// 不存在，则返回 null
  		return null;
  	}
  
  }
  ```

  - 重心是对 [`org.springframework.boot.origin.OriginLookup`](https://github.com/spring-projects/spring-boot/blob/master/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/origin/OriginLookup.java) 接口的 `#getOrigin(String key)` 方法的实现，实现查找 `key` 对应的真正的 `property` 。难道两者还会不同，答案是的。例如说：传入的 `key=foo.bar.baz` ，返回的是 `property=FOO_BAR_BAZ` 。

  - 答案见 `SystemEnvironmentPropertySource#checkPropertyName(String name)` 方法，内部会进行各种灵活的替换“查找”。代码如下：

    ```
    // SystemEnvironmentPropertySource.java
    
    @Nullable
    private String checkPropertyName(String name) {
    	// Check name as-is
    	if (containsKey(name)) {
    		return name;
    	}
    	// Check name with just dots replaced
    	String noDotName = name.replace('.', '_');
    	if (!name.equals(noDotName) && containsKey(noDotName)) {
    		return noDotName;
    	}
    	// Check name with just hyphens replaced
    	String noHyphenName = name.replace('-', '_');
    	if (!name.equals(noHyphenName) && containsKey(noHyphenName)) {
    		return noHyphenName;
    	}
    	// Check name with dots and hyphens replaced
    	String noDotNoHyphenName = noDotName.replace('-', '_');
    	if (!noDotName.equals(noDotNoHyphenName) && containsKey(noDotNoHyphenName)) {
    		return noDotNoHyphenName;
    	}
    	// Give up
    	return null;
    }
    ```

    - 各种符号，转成 `_` 来查找对应的属性。

😈 那么具体有什么样的逻辑上的需要呢？暂时还没怎么看到，嘿嘿。所以，知道就好，暂时先不去深究。

## 4.3 SpringApplicationJsonEnvironmentPostProcessor

> 艿艿：选看~

`org.springframework.boot.env.SpringApplicationJsonEnvironmentPostProcessor` ，实现 EnvironmentPostProcessor、Ordered 接口，解析 `environment` 中的 `spring.application.json` 或 `SPRING_APPLICATION_JSON` 对应的 JSON 格式的属性值，创建新的 PropertySource 对象，添加到其中。代码如下：

```
// SpringApplicationJsonEnvironmentPostProcessor.java

/**
 * 默认的 {@link #order} 的值
 *
 * The default order for the processor.
 */
public static final int DEFAULT_ORDER = Ordered.HIGHEST_PRECEDENCE + 5;

/**
 * 顺序
 */
private int order = DEFAULT_ORDER;

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
	MutablePropertySources propertySources = environment.getPropertySources();
	propertySources.stream().map(JsonPropertyValue::get).filter(Objects::nonNull)
			.findFirst().ifPresent((v) -> processJson(environment, v));
}
```

- `map(JsonPropertyValue::get).filter(Objects::nonNull)` 代码段，调用 `JsonPropertyValue#get(PropertySource<?> propertySource)` 方法，`environment` 中的 `spring.application.json` 或 `SPRING_APPLICATION_JSON` 对应的 JSON 格式的属性值。代码如下：

  ```
  // SpringApplicationJsonEnvironmentPostProcessor.java
  
  public static final String SPRING_APPLICATION_JSON_PROPERTY = "spring.application.json";
  public static final String SPRING_APPLICATION_JSON_ENVIRONMENT_VARIABLE = "SPRING_APPLICATION_JSON";
  
  private static class JsonPropertyValue {
  
      private static final String[] CANDIDATES = { SPRING_APPLICATION_JSON_PROPERTY, SPRING_APPLICATION_JSON_ENVIRONMENT_VARIABLE };
  
      private final PropertySource<?> propertySource;
  
      private final String propertyName;
  
      private final String json;
  
      JsonPropertyValue(PropertySource<?> propertySource, String propertyName, String json) {
          this.propertySource = propertySource;
          this.propertyName = propertyName;
          this.json = json;
      }
  
      public String getJson() {
          return this.json;
      }
  
      public Origin getOrigin() {
          return PropertySourceOrigin.get(this.propertySource, this.propertyName);
      }
  
      public static JsonPropertyValue get(PropertySource<?> propertySource) {
          // 遍历 CANDIDATES 数组
          for (String candidate : CANDIDATES) {
              // 获得 candidate 对应的属性值
              Object value = propertySource.getProperty(candidate);
              if (value instanceof String
                      && StringUtils.hasLength((String) value)) {
                  // 创建 JsonPropertyValue 对象，然后返回
                  return new JsonPropertyValue(propertySource, candidate, (String) value);
              }
          }
          return null;
      }
  
  }
  ```

  - 比较简单，胖友看下就明白列。

- 调用 `#processJson(ConfigurableEnvironment environment, JsonPropertyValue propertyValue)` 方法，执行处理 JSON 字符串。详细解析，见 [「4.3.1 processJson」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

### 4.3.1 processJson

`#processJson(ConfigurableEnvironment environment, JsonPropertyValue propertyValue)` 方法，执行处理 JSON 字符串。代码如下：

```
// SpringApplicationJsonEnvironmentPostProcessor.java

private void processJson(ConfigurableEnvironment environment, JsonPropertyValue propertyValue) {
    // <1> 解析 json 字符串，成 Map 对象
    JsonParser parser = JsonParserFactory.getJsonParser();
    Map<String, Object> map = parser.parseMap(propertyValue.getJson());
    // <2> 创建 JsonPropertySource 对象，添加到 environment 中
    if (!map.isEmpty()) {
        // <2.2>
        addJsonPropertySource(environment, new JsonPropertySource(propertyValue, flatten(map))); // <2.1>
    }
}
```

- `<1>` 处，解析 json 字符串，成 Map 对象。

- `<2>` 处，创建 JsonPropertySource 对象，添加到 `environment` 中。其中，JsonPropertySource 继承 MapPropertySource 类，实现 OriginLookup 接口，代码如下：

  ```
  // SpringApplicationJsonEnvironmentPostProcessor#JsonPropertySource.java
  
  private static class JsonPropertySource extends MapPropertySource
  		implements OriginLookup<String> {
  
  	private final JsonPropertyValue propertyValue;
  
  	JsonPropertySource(JsonPropertyValue propertyValue, Map<String, Object> source) {
  		super(SPRING_APPLICATION_JSON_PROPERTY, source);
  		this.propertyValue = propertyValue;
  	}
  
  	@Override
  	public Origin getOrigin(String key) {
  		return this.propertyValue.getOrigin();
  	}
  
  }
  ```

  - 使用的 `name` 为 `SPRING_APPLICATION_JSON_PROPERTY=spring.application.json` 。

- `<2.1>` 处，调用 `#flatten(String prefix, Map<String, Object> result, Map<String, Object> map)` 方法，将 JSON 解析后的 Map 可能存在的内嵌的 Map 对象，转换成多条 KV 格式的配置对。代码如下：

  ```
  // SpringApplicationJsonEnvironmentPostProcessor.java
  
  private Map<String, Object> flatten(Map<String, Object> map) {
      Map<String, Object> result = new LinkedHashMap<>();
      flatten(null, result, map);
      return result;
  }
  
  private void flatten(String prefix, Map<String, Object> result, Map<String, Object> map) {
      String namePrefix = (prefix != null) ? prefix + "." : "";
      map.forEach((key, value) -> extract(namePrefix + key, result, value));
  }
  
  @SuppressWarnings("unchecked")
  private void extract(String name, Map<String, Object> result, Object value) {
      if (value instanceof Map) { // 内嵌的 Map 格式
          flatten(name, result, (Map<String, Object>) value);
      } else if (value instanceof Collection) { // 内嵌的 Collection
          int index = 0;
          for (Object object : (Collection<Object>) value) {
              extract(name + "[" + index + "]", result, object);
              index++;
          }
      } else { // 普通格式，添加到 result 中
          result.put(name, value);
      }
  }
  ```

- `<2.2>` 处，调用 `#addJsonPropertySource(ConfigurableEnvironment environment, PropertySource<?> source)` 方法，添加到 `environment` 中。代码如下：

  ```
  // SpringApplicationJsonEnvironmentPostProcessor.java
  
  private void addJsonPropertySource(ConfigurableEnvironment environment, PropertySource<?> source) {
      MutablePropertySources sources = environment.getPropertySources();
      // 获得需要添加到 source 所在的 PropertySource 之前的名字
      String name = findPropertySource(sources);
      // 添加到 environment 的 sources 中。
      // 这么做的效果是，source 高于 SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME && JNDI_PROPERTY_SOURCE_NAME 之前
      if (sources.contains(name)) {
          sources.addBefore(name, source);
      } else {
          sources.addFirst(source);
      }
  }
  
  private String findPropertySource(MutablePropertySources sources) {
      // 在 Servlet 环境下，且有 JNDI_PROPERTY_SOURCE_NAME 属性，则返回 StandardServletEnvironment.JNDI_PROPERTY_SOURCE_NAME
      if (ClassUtils.isPresent(SERVLET_ENVIRONMENT_CLASS, null)
              && sources.contains(StandardServletEnvironment.JNDI_PROPERTY_SOURCE_NAME)) {
          return StandardServletEnvironment.JNDI_PROPERTY_SOURCE_NAME;
  
      }
      // 否则，返回 SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME 属性
      return StandardEnvironment.SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME;
  }
  ```

😈 当然，因为绝大多数情况下，我们并不会去使用 `spring.application.json` 或 `SPRING_APPLICATION_JSON` 去进行配置。所以呢，这块逻辑等胖友真的有需要，再来瞅瞅落。

## 4.4 ConfigFileApplicationListener

> 艿艿：真正的重头戏~

实现 `#addPropertySources(ConfigurableEnvironment environment,ResourceLoader resourceLoader)` 方法，代码如下：

```
// ConfigFileApplicationListener.java

protected void addPropertySources(ConfigurableEnvironment environment,ResourceLoader resourceLoader) {
    // <1> 添加 RandomValuePropertySource 到 environment 中
    RandomValuePropertySource.addToEnvironment(environment);
    // <2> 创建 Loader 对象，进行加载
    new Loader(environment, resourceLoader).load();
}
```

- `<1>` 处，添加 RandomValuePropertySource 到 `environment` 中。详细解析，见 [「5. RandomValuePropertySource」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中。
- `<2>` 处，创建 Loader 对象，并调用 `Loader#load()` 方法，进行加载。详细解析，见 [「4.4.1 Loader」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中。

### 4.4.1 Loader

> 艿艿：高能预警，关于这一块，内容会比较扎实（很多）！

Loader 是 ConfigFileApplicationListener 的内部类，负责加载指定的配置文件。构造方法如下：

```
// ConfigFileApplicationListener.java

private class Loader {

    private final Log logger = ConfigFileApplicationListener.this.logger;

    private final ConfigurableEnvironment environment;

    private final PropertySourcesPlaceholdersResolver placeholdersResolver;

    private final ResourceLoader resourceLoader;

    private final List<PropertySourceLoader> propertySourceLoaders;

    private Deque<Profile> profiles;

    private List<Profile> processedProfiles;

    private boolean activatedProfiles;

    private Map<Profile, MutablePropertySources> loaded;

    private Map<DocumentsCacheKey, List<Document>> loadDocumentsCache = new HashMap<>();

    Loader(ConfigurableEnvironment environment, ResourceLoader resourceLoader) {
        this.environment = environment;
        // <1> 创建 PropertySourcesPlaceholdersResolver 对象
        this.placeholdersResolver = new PropertySourcesPlaceholdersResolver(this.environment);
        // <2> 创建 DefaultResourceLoader 对象
        this.resourceLoader = (resourceLoader != null) ? resourceLoader : new DefaultResourceLoader();
        // <3> 加载指定类型 PropertySourceLoader 对应的，在 `META-INF/spring.factories` 里的类名的数组
        this.propertySourceLoaders = SpringFactoriesLoader.loadFactories(PropertySourceLoader.class, getClass().getClassLoader());
    }
    
    // ... 省略其它方法
}
```

- `<1>` 处，创建 PropertySourcesPlaceholdersResolver 对象。详细解析，胖友可以跳到 [「6. PropertySourcesPlaceholdersResolver」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，瞅一眼，然后继续回到此处。

- `<2>` 处，创建 DefaultResourceLoader 对象。这个是 Spring Framework 中的类，用于资源的加载。当然，这不是本文的重点，暂时先忽略。

- ```
  <3>
  ```

   

  处，加载指定类型 PropertySourceLoader 对应的，在

   

  ```
  META-INF/spring.factories
  ```

   

  里的类名的数组。

  - 默认情况下，返回的是 PropertiesPropertySourceLoader、YamlPropertySourceLoader 类。详细解析，见 [「7. PropertySourceLoader」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

#### 4.4.1.1 load

`#load()` 方法，加载配置。代码如下：

```
// ConfigFileApplicationListener#Loader.java

public void load() {
    // <1> 初始化变量
    this.profiles = new LinkedList<>(); // 未处理的 Profile 集合
    this.processedProfiles = new LinkedList<>(); // 已处理的 Profile 集合
    this.activatedProfiles = false;
    this.loaded = new LinkedHashMap<>();
    // <2> 初始化 Spring Profiles 相关
    initializeProfiles();
    // <3> 遍历 profiles 数组
    while (!this.profiles.isEmpty()) {
        // 获得 Profile 对象
        Profile profile = this.profiles.poll();
        // <3.1> 添加 Profile 到 environment 中
        if (profile != null && !profile.isDefaultProfile()) {
            addProfileToEnvironment(profile.getName());
        }
        // <3.2> 加载配置
        load(profile, this::getPositiveProfileFilter,
                addToLoaded(MutablePropertySources::addLast, false));
        // <3.3> 添加到 processedProfiles 中，表示已处理
        this.processedProfiles.add(profile);
    }
    // <4> 获得真正加载的 Profile 们，添加到 environment 中。
    resetEnvironmentProfiles(this.processedProfiles);
    // <5> 加载配置
    load(null, this::getNegativeProfileFilter,
            addToLoaded(MutablePropertySources::addFirst, true));
    // <6> 将加载的配置对应的 MutablePropertySources 到 environment 中
    addLoadedPropertySources();
}
```

- `<1>` 处，初始化变量。每个变量的意思，看代码中的注释。

- `<2>` 处，初始化 Spring Profiles 相关。详细解析，见 [「4.4.1.1 initializeProfiles」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中。胖友可以先跳过去看一眼，然后回来。

- `<3>` 处，遍历 `profiles` 数组，逐个加载对应的配置文件。

  - `<3.1>` 处，调用 `#addProfileToEnvironment(String profile)` 方法，添加到 `environment.activeProfiles` 中。代码如下：

    ```
    // ConfigFileApplicationListener#Loader.java
    
    private void addProfileToEnvironment(String profile) {
        // 如果已经在 activeProfiles 中，则返回
        for (String activeProfile : this.environment.getActiveProfiles()) {
            if (activeProfile.equals(profile)) {
                return;
            }
        }
        // 如果不在，则添加到 environment 中
        this.environment.addActiveProfile(profile);
    }
    ```

    - ~

  - `<3.2>` 处，调用 `#load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，加载配置。这块会比较复杂，晚点再求看 [「4.4.1.1.2 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

  - `<3.3>` 处，添加到 `processedProfiles` 中，表示已处理。

- `<4>` 处，调用 `#resetEnvironmentProfiles(List<Profile> processedProfiles)` 方法，获得真正加载的 Profile 们，添加到 environment 中。代码如下：

  ```
  // ConfigFileApplicationListener#Loader.java
  
  private void resetEnvironmentProfiles(List<Profile> processedProfiles) {
      // 获得真正加载的 Profile 们，添加到 environment 中。
      String[] names = processedProfiles.stream()
              .filter((profile) -> profile != null && !profile.isDefaultProfile())
              .map(Profile::getName).toArray(String[]::new);
      this.environment.setActiveProfiles(names);
  }
  ```

  - 因为每个 Profile 可能不存在对应的配置文件，只有真正加载到配置文件的 Profile 们，才会设置到 `environment.activeProfiles` 属性中。

- `<5>` 处，调用 `#load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，加载配置。这块会比较复杂，晚点再求看 [「4.4.1.1.2 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

  - 和 `<3.2>` 处，有一些不同，主要差别在于传入的方法参数。
  - 在补充一点，有点不造怎么解释了。😈 `<5>` 处的作用是，将 `profile=null` 的情况中，将配置文件里有配置文件 `spring.profiles` 内容，且属于基于的 Profile ，也添加到 `profile=null` 在 `Loader.loaded` 的映射中。具体的，可以看 [「666. 彩蛋」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 提供的示例。😈 真的是，好绕啊！！！！

- `<6>` 处，调用 `#addLoadedPropertySources()` 方法，将加载的配置对应的 MutablePropertySources 到 `environment` 中。代码如下：

  ```
  // ConfigFileApplicationListener.java
  
  private static final String DEFAULT_PROPERTIES = "defaultProperties";
  
  // ConfigFileApplicationListener#Loader.java
  
  private void addLoadedPropertySources() {
      MutablePropertySources destination = this.environment.getPropertySources();
      // 获得当前加载的 MutablePropertySources 集合
      List<MutablePropertySources> loaded = new ArrayList<>(this.loaded.values());
      Collections.reverse(loaded); // <Z>
      // 声明变量
      String lastAdded = null; // 下面循环，最后找到的 MutablePropertySources 的名字
      Set<String> added = new HashSet<>(); // 已添加到 destination 中的 MutablePropertySources 的名字的集合
      // <X> 遍历 loaded 数组
      for (MutablePropertySources sources : loaded) {
          // <Y> 遍历 sources 数组
          for (PropertySource<?> source : sources) {
              // 添加到 destination 中
              if (added.add(source.getName())) {
                  addLoadedPropertySource(destination, lastAdded, source);
                  lastAdded = source.getName();
              }
          }
      }
  }
  
  private void addLoadedPropertySource(MutablePropertySources destination, String lastAdded, PropertySource<?> source) {
      if (lastAdded == null) {
          if (destination.contains(DEFAULT_PROPERTIES)) {
              destination.addBefore(DEFAULT_PROPERTIES, source);
          } else {
              destination.addLast(source);
          }
      } else {
          destination.addAfter(lastAdded, source);
      }
  }
  ```

  - `<X>` 和 `<Y>` 处，为什么是两层遍历呢？因为一个 Profile 可以对应多个配置文件。例如说，Profile 为 `prod` ，对应 `applicaion-prod.properties` 和 `application-prod.yml` 两个配置文件。
  - 这样，我们就可以从 `environment` 中，读取加载到的配置文件。
  - `<Z>` 处，为什么要反转一下呢？因为，配置在越后面的 Profile ，优先级越高，所以需要进行反转。举个例子 `spring.profiles.active=prod,dev` ，那么 Profile 的优先级是 `dev > prod > null` 。

下面，我们就可以跳到 [「4.4.1.1.2 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 小节，看看这个关键的逻辑。

> 艿艿：逻辑真的有点复杂！目的简单，过程中的逻辑细节比较多。和我一起，保持耐心！！！

##### 4.4.1.1.1 initializeProfiles

在 `#initializeProfiles()` 方法之前，我们先来看 Profile 类。它是 ConfigFileApplicationListener 的内部类，是 Spring Profiles 的封装对象。代码如下：

```
// ConfigFileApplicationListener#Profile.java

/**
 * A Spring Profile that can be loaded.
 */
private static class Profile {

    /**
     * Profile 名字
     */
	private final String name;
    /**
     * 是否为默认的 Profile
     */
	private final boolean defaultProfile;

    // ... 省略构造方法、getting 方法、toString 和 hashCode 方法

}
```

然后，继续来看 `#initializeProfiles()` 方法，初始化 Spring Profiles 相关。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private void initializeProfiles() {
    // The default profile for these purposes is represented as null. We add it
    // first so that it is processed first and has lowest priority.
    // <1> 添加 null 到 profiles 中。用于加载默认的配置文件。优先添加到 profiles 中，因为希望默认的配置文件先被处理。
    this.profiles.add(null);
    // <2.1> 获得激活的 Profile 们（从配置中）
    Set<Profile> activatedViaProperty = getProfilesActivatedViaProperty();
    // <2.2> 先添加激活的 Profile 们（不在配置中）
    this.profiles.addAll(getOtherActiveProfiles(activatedViaProperty));
    // Any pre-existing active profiles set via property sources (e.g.
    // System properties) take precedence over those added in config files.
    // <2.3> 再添加激活的 Profile 们（在配置中）
    addActiveProfiles(activatedViaProperty);
    // <3> 如果没有激活的 Profile 们，则添加默认的 Profile
    if (this.profiles.size() == 1) { // only has null profile
        for (String defaultProfileName : this.environment.getDefaultProfiles()) {
            Profile defaultProfile = new Profile(defaultProfileName, true);
            this.profiles.add(defaultProfile);
        }
    }
}
```

- `<1>` 处，添加 `null` 到 `profiles` 中。用于加载默认的配置文件。优先添加到 `profiles` 中，因为希望默认的配置文件先被处理。

- `<2.1>` 处，调用 `#getProfilesActivatedViaProperty()` 方法，获得激活的 Profile 们（从配置中）。代码如下：

  ```
  // ConfigFileApplicationListener#Loader.java
  
  private Set<Profile> getProfilesActivatedViaProperty() {
  	if (!this.environment.containsProperty(ACTIVE_PROFILES_PROPERTY)
  			&& !this.environment.containsProperty(INCLUDE_PROFILES_PROPERTY)) {
  		return Collections.emptySet();
  	}
  	Binder binder = Binder.get(this.environment);
  	Set<Profile> activeProfiles = new LinkedHashSet<>();
  	activeProfiles.addAll(getProfiles(binder, INCLUDE_PROFILES_PROPERTY)); // spring.profiles.include
  	activeProfiles.addAll(getProfiles(binder, ACTIVE_PROFILES_PROPERTY)); // spring.profiles.active
  	return activeProfiles;
  }
  ```

  - 读取 `"spring.profiles.include"` 和 `"spring.profiles.active"` 对应的 Profile 们。

- `<2.2>` 处，调用 `#getOtherActiveProfiles(Set<Profile> activatedViaProperty)` 方法，先添加激活的 Profile 们（**不在配置中**）到 `profiles` 中。代码如下：

  ```
  // ConfigFileApplicationListener#Loader.java
  
  private List<Profile> getOtherActiveProfiles(Set<Profile> activatedViaProperty) {
  	return Arrays.stream(this.environment.getActiveProfiles()).map(Profile::new)
  			.filter((profile) -> !activatedViaProperty.contains(profile))
  			.collect(Collectors.toList());
  }
  ```

  - “**不在配置中**”，例如说：`SpringApplication.additionalProfiles` 。

- `<2.3>` 处，调用 `#addActiveProfiles(Set<Profile> profiles)` 方法，再添加激活的 Profile 们（在配置中）到 `profiles` 中。代码如下：

  ```
  // ConfigFileApplicationListener#Loader.java
  
  void addActiveProfiles(Set<Profile> profiles) {
      if (profiles.isEmpty()) {
          return;
      }
      // 如果已经标记 activatedProfiles 为 true ，则直接返回
      if (this.activatedProfiles) {
          if (this.logger.isDebugEnabled()) {
              this.logger.debug("Profiles already activated, '" + profiles + "' will not be applied");
          }
          return;
      }
      // 添加到 profiles 中
      this.profiles.addAll(profiles);
      if (this.logger.isDebugEnabled()) {
          this.logger.debug("Activated activeProfiles " + StringUtils.collectionToCommaDelimitedString(profiles));
      }
      // 标记 activatedProfiles 为 true 。
      this.activatedProfiles = true;
      // 移除 profiles 中，默认的配置们。
      removeUnprocessedDefaultProfiles();
  }
  
  private void removeUnprocessedDefaultProfiles() {
      this.profiles.removeIf(
              (profile) -> (profile != null && profile.isDefaultProfile()));
  }
  ```

- `<3>` 处，如果没有激活的 Profile 们，则添加默认的 Profile 。此处的“默认”是，指的是配置文件中的 `"spring.profiles.default"` 对应的值。

- 这块比较绕，胖友最好自己调试下。例如说，我们在 JVM 启动增加 `--spring.profiles.active=prod` ，则结果如下图：[![`profiles`](14-Spring Boot 源码分析-配置加载.assets/02.jpg)](http://static.iocoder.cn/images/Spring-Boot/2021-01-28/02.jpg)`profiles`

##### 4.4.1.1.2 load

`#load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，加载指定 Profile 的配置文件。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private void load(Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
    // <1> 获得要检索配置的路径
    getSearchLocations().forEach((location) -> {
        // 判断是否为文件夹
        boolean isFolder = location.endsWith("/");
        // <2> 获得要检索配置的文件名集合
        Set<String> names = isFolder ? getSearchNames() : NO_SEARCH_NAMES;
        // <3> 遍历文件名集合，逐个加载配置文件
        names.forEach(
                (name) -> load(location, name, profile, filterFactory, consumer));
    });
}
```

- `<1>` 处，调用 `#getSearchLocations()` 方法，获得要检索配置的路径们。代码如下：

  ```
  // ConfigFileApplicationListener.java
  
  // Note the order is from least to most specific (last one wins)
  private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/";
  
  /**
   * The "config location" property name.
   */
  public static final String CONFIG_LOCATION_PROPERTY = "spring.config.location";
  /**
   * The "config additional location" property name.
   */
  public static final String CONFIG_ADDITIONAL_LOCATION_PROPERTY = "spring.config.additional-location";
  
  // ConfigFileApplicationListener#Loader.java
  
  private Set<String> getSearchLocations() {
      // 获得 `"spring.config.location"` 对应的配置的值
      if (this.environment.containsProperty(CONFIG_LOCATION_PROPERTY)) {
          return getSearchLocations(CONFIG_LOCATION_PROPERTY);
      }
      // 获得 `"spring.config.additional-location"` 对应的配置的值
      Set<String> locations = getSearchLocations(CONFIG_ADDITIONAL_LOCATION_PROPERTY);
      // 添加 searchLocations 到 locations 中
      locations.addAll(asResolvedSet(ConfigFileApplicationListener.this.searchLocations, DEFAULT_SEARCH_LOCATIONS));
      return locations;
  }
  
  private Set<String> getSearchLocations(String propertyName) {
      Set<String> locations = new LinkedHashSet<>();
      // 如果 environment 中存在 propertyName 对应的值
      if (this.environment.containsProperty(propertyName)) {
          // 读取属性值，进行分割后，然后遍历
          for (String path : asResolvedSet(this.environment.getProperty(propertyName), null)) {
              // 处理 path
              if (!path.contains("$")) {
                  path = StringUtils.cleanPath(path);
                  if (!ResourceUtils.isUrl(path)) {
                      path = ResourceUtils.FILE_URL_PREFIX + path;
                  }
              }
              // 添加到 path 中
              locations.add(path);
          }
      }
      return locations;
  }
  
  // 优先使用 value 。如果 value 为空，则使用 fallback
  private Set<String> asResolvedSet(String value, String fallback) {
      List<String> list = Arrays.asList(StringUtils.trimArrayElements(
              StringUtils.commaDelimitedListToStringArray((value != null)
                      ? this.environment.resolvePlaceholders(value) : fallback)));
      Collections.reverse(list);
      return new LinkedHashSet<>(list);
  }
  ```

  - 看似比较长，逻辑并不复杂。
  - 如果配置了 `"spring.config.location"` ，则使用它的值，作为要检索配置的路径。
  - 如果配置了 `"spring.config.additional-location"` ，则使用它作为**附加**要检索配置的路径。当然，还是会添加默认的 `DEFAULT_SEARCH_LOCATIONS` 路径。
  - 默认情况下，返回的值是 `DEFAULT_SEARCH_LOCATIONS` 。因为，绝大数情况，我们并不会做相应的配置。😈 所以，胖友如果懒的看逻辑，就记得这个结论就可以了。

- `<2>` 处，调用 `#getSearchNames()` 方法，获得要检索配置的文件名集合。代码如下：

  ```
  // ConfigFileApplicationListener.java
  
  private static final String DEFAULT_NAMES = "application";
  
  private static final Set<String> NO_SEARCH_NAMES = Collections.singleton(null);
  
  public static final String CONFIG_NAME_PROPERTY = "spring.config.name";
  
  // ConfigFileApplicationListener#Loader.java
  
  private Set<String> getSearchNames() {
      // 获得 `"spring.config.name"` 对应的配置的值
      if (this.environment.containsProperty(CONFIG_NAME_PROPERTY)) {
          String property = this.environment.getProperty(CONFIG_NAME_PROPERTY);
          return asResolvedSet(property, null);
      }
      // 添加 names or DEFAULT_NAMES 到 locations 中
      return asResolvedSet(ConfigFileApplicationListener.this.names, DEFAULT_NAMES);
  }
  ```

  - 通过 `DEFAULT_NAMES` 静态属性，我们可以知道，默认都去的配置文件名（不考虑后缀）为 `"application"` 。
  - 剩余的逻辑，胖友简单看看即可。
  - 默认情况下，返回的值是 `DEFAULT_NAMES` 。因为，绝大数情况，我们并不会做相应的配置。😈 所以，胖友如果懒的看逻辑，就记得这个结论就可以了。

- `<3>` 处，遍历 `names` 数组，逐个调用 `#load(String location, String name, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，逐个加载 Profile 指定的配置文件。详细解析，见 [「4.4.1.1.3 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

##### 4.4.1.1.3 load

`#load(String location, String name, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，逐个加载 Profile 指定的配置文件。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private void load(String location, String name, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
    // <1> 这块逻辑先无视，因为我们不会配置 name 为空。
    // 默认情况下，name 为 DEFAULT_NAMES=application
    if (!StringUtils.hasText(name)) {
        for (PropertySourceLoader loader : this.propertySourceLoaders) {
            if (canLoadFileExtension(loader, location)) {
                load(loader, location, profile, filterFactory.getDocumentFilter(profile), consumer);
                return;
            }
        }
    }
    Set<String> processed = new HashSet<>(); // 已处理的文件后缀集合
    // <2> 遍历 propertySourceLoaders 数组，逐个使用 PropertySourceLoader 读取配置
    for (PropertySourceLoader loader : this.propertySourceLoaders) {
        // <3> 遍历每个 PropertySourceLoader 可处理的文件后缀集合
        for (String fileExtension : loader.getFileExtensions()) {
            // <4> 添加到 processed 中，一个文件后缀，有且仅能被一个 PropertySourceLoader 所处理
            if (processed.add(fileExtension)) {
                // 加载 Profile 指定的配置文件（带后缀）
                loadForFileExtension(loader, location + name, "." + fileExtension,
                        profile, filterFactory, consumer);
            }
        }
    }
}
```

- `<1>` 处的逻辑，可以无视。具体的原因，见我添加的注释。
- `<2>` 处，遍历 `propertySourceLoaders` 数组，逐个使用 PropertySourceLoader 读取配置。
- `<3>` 处，遍历每个 PropertySourceLoader 可处理的文件后缀集合。例如说，PropertiesPropertySourceLoader 可处理 `.properties` 和 `.xml` 后缀，YamlPropertySourceLoader 可处理 `.yml` 和 `.yaml` 后置。
- `<4>` 处，添加到 `processed` 中。一个文件后缀，有且仅能被一个 PropertySourceLoader 所处理。
- `<5>` 处，调用 `#loadForFileExtension(PropertySourceLoader loader, String prefix, String fileExtension, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，加载 Profile 指定的配置文件（带后缀）。详细解析，见 [「4.4.1.1.7 loadForFileExtension」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

##### 4.4.1.1.4 Document

> 因为稍后在讲解 `#loadForFileExtension(...)` 方法需要用到，所以插播下。

Document ，是 ConfigFileApplicationListener 的内部类，用于封装 PropertySourceLoader 加载配置文件后。代码如下：

```
// ConfigFileApplicationListener#Document.java

private static class Document {

    private final PropertySource<?> propertySource;

    /**
     * 对应 `spring.profiles` 属性值
     */
    private String[] profiles;

    /**
     * 对应 `spring.profiles.active` 属性值
     */
    private final Set<Profile> activeProfiles;

    /**
     * 对应 `spring.profiles.include` 属性值
     */
    private final Set<Profile> includeProfiles;
}
```

###### 4.4.1.1.4.1 DocumentsCacheKey

DocumentsCacheKey ，是 ConfigFileApplicationListener 的内部类，用于表示加载 Documents 的缓存 KEY 。代码如下：

```
// ConfigFileApplicationListener#DocumentsCacheKey.java

/**
 * Cache key used to save loading the same document multiple times.
 */
private static class DocumentsCacheKey {

	private final PropertySourceLoader loader;

	private final Resource resource;

	DocumentsCacheKey(PropertySourceLoader loader, Resource resource) {
		this.loader = loader;
		this.resource = resource;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj == null || getClass() != obj.getClass()) {
			return false;
		}
		DocumentsCacheKey other = (DocumentsCacheKey) obj;
		return this.loader.equals(other.loader)
				&& this.resource.equals(other.resource);
	}

	@Override
	public int hashCode() {
		return this.loader.hashCode() * 31 + this.resource.hashCode();
	}

}
```

- 因为一个配置文件在 [「4.4.1.1.7 loadForFileExtension」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 方法中，我们会看到可能存在重复加载的情况，所以通过缓存，避免重新读取~

##### 4.4.1.1.5 DocumentFilterFactory

> 因为稍后在讲解 `#loadForFileExtension(...)` 方法需要用到，所以插播下。

DocumentFilterFactory ，是 ConfigFileApplicationListener 的内部接口，用于创建 DocumentFilter 对象。代码如下：

```
// ConfigFileApplicationListener#DocumentFilterFactory.java

@FunctionalInterface
private interface DocumentFilterFactory {

	DocumentFilter getDocumentFilter(Profile profile);

}
```

在 [「4.4.1.1 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，我们在该方法中，已经看到它的两个匿名实现类，如下：

```
// ConfigFileApplicationListener#Loader.java

第一个：this::getPositiveProfileFilter
第二个：this::getNegativeProfileFilter
```

- 它们分别调用对应的方法，创建 DocumentFilter 对象。

###### 4.4.1.1.5.1 DocumentFilter

DocumentFilter ，是 ConfigFileApplicationListener 的内部接口，用于匹配配置加载后的 Document 对象。代码如下：

```
// ConfigFileApplicationListener#DocumentFilter.java

@FunctionalInterface
private interface DocumentFilter {

	boolean match(Document document);

}
```

- 在下面的文章中，我们会看到，加载的配置文件后，返回的是 Document 对象。但是，返回的 Document 对象，需要和 Profile 进行匹配。

###### 4.4.1.1.5.2 getPositiveProfileFilter

`#getPositiveProfileFilter(Profile profile)` 方法，代码如下：

```
// ConfigFileApplicationListener#Loader.java

private DocumentFilter getPositiveProfileFilter(Profile profile) {
    return (Document document) -> {
        // <1> 当 profile 为空时，document.profiles 也要为空
        if (profile == null) {
            return ObjectUtils.isEmpty(document.getProfiles());
        }
        // <2> 要求 document.profiles 包含 profile
        // 并且，environment.activeProfiles 包含 document.profiles
        // 总结来说，environment.activeProfiles 包含 document.profiles 包含 profile
        return ObjectUtils.containsElement(document.getProfiles(), profile.getName())
                && this.environment.acceptsProfiles(Profiles.of(document.getProfiles()));
    };
}
```

- `<1>` 处，当传入的 `profile` 为空时，要求 `document.profiles` 也要为空。
- `<2>` 处，当传入的 `profile` 非空时，要求 `environment.activeProfiles` 包含 `document.profiles` 包含 `profile` 。

可能比较绕，胖友先看 [《Spring-boot动态profiles的实践》](https://spldeolin.com/posts/spring-boot-active-profiles/) 文章的 [「Spring Boot的Profiles属性」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 部分。

- 什么意思呢？假设一个 `application-prod.properties` 的配置文件，一般我们的理解是对应 Profile 为 `prod` 的情况，对吧？！但是，如果说我们在配置文件中增加了 `spring.profiles=dev` ，那它实际是属于 Profile 为 `dev` 的情况。

  > 艿艿：第一次知道还有这样的设定！！！

- 当然，我们绝大都数情况，并不会去定义 `spring.profiles` 属性。所以呢，分成两种情况：

  > 艿艿：仔细理解，我也懵逼了好多小时！！！！

  - `profile` 为 `null` 的情况，处理默认情况，即我们未定义 `spring.profiles` 属性。
  - `profile` 非 `null` 的情况，处理配置文件中定义了 `spring.profiles` 属性，则需要使用 `profile` 和 `spring.profiles` 匹配，并且它要属于 `environment.activeProfiles` 中已经激活的。

😈 所以呢，我们在 [「4.4.1.1 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，看到它是在加载指定 Profile 的配置文件所使用。

###### 4.4.1.1.5.3 getPositiveProfileFilter

`#getPositiveProfileFilter(Profile profile)` 方法，代码如下：

```
// ConfigFileApplicationListener#Loader.java

private DocumentFilter getNegativeProfileFilter(Profile profile) {
    return (Document document) -> (profile == null // <1>
            && !ObjectUtils.isEmpty(document.getProfiles()) // <2> 非空
            // environment.activeProfiles 包含 document.profiles
            && this.environment.acceptsProfiles(Profiles.of(document.getProfiles()))); // <3>
}
```

- `<1>` 处，要求传入的 `profile` 为空。因为呢，[「4.4.1.1 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，看到它是在加载**无 Profile** 的配置文件所使用。
- `<2>` 处，要求 `document.profiles` 非空。一般情况下，我们在 `application.properties` 中，也并不会填写 `spring.profiles` 属性值。这就是说，这个方法默认基本返回 `false` 。
- `<3>` 处，`environment.activeProfiles` 包含 `document.profiles` 。

##### 4.4.1.1.6 DocumentConsumer

> 因为稍后在讲解 `#loadForFileExtension(...)` 方法需要用到，所以插播下。

DocumentConsumer ，是 ConfigFileApplicationListener 的内部接口，用于处理传入的 Document 。代码如下：

```
// ConfigFileApplicationListener#DocumentConsumer.java

/**
 * Consumer used to handle a loaded {@link Document}.
 */
@FunctionalInterface
private interface DocumentConsumer {

	void accept(Profile profile, Document document);

}
```

在 [「4.4.1.1 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，我们在该方法中，已经看到它的一个匿名实现类，如下：

```
// ConfigFileApplicationListener#Loader.java

第一个：addToLoaded(MutablePropertySources::addLast, false))
第二个：addToLoaded(MutablePropertySources::addFirst, true))
```

- 差别在于传入的

   

  ```
  #addToLoaded(BiConsumer<MutablePropertySources, PropertySource<?>> addMethod, boolean checkForExisting)
  ```

   

  方法的

   

  ```
  addMethod
  ```

   

  参数不同。为什么呢？

  - 对于有 Profile 的情况，使用前者 `MutablePropertySources::addLast` ，将 Document 的 PropertySource 添加到尾部。
  - 对于无 Profile 的情况，使用后者 `MutablePropertySources::addFirst` ，将 Document 的 PropertySource 添加到头部。
  - 最终，我们看到 `#addLoadedPropertySources()` 方法中，会执行 `Collections.reverse(loaded)` 代码段，进行颠倒。为什么呢？这样，就能很巧妙的实现 `application-prod.properties` 的优先级，高于 `application.properties` ，从而实现相同属性时，覆盖读取~，即读取的是 `application-prod.properties` 的属性配置。

###### 4.4.1.1.6.1 addToLoaded

`#addToLoaded(BiConsumer<MutablePropertySources, PropertySource<?>> addMethod, boolean checkForExisting)` 方法，将 Document 的 PropertySource ，添加到 `Loader.loaded` 中。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private DocumentConsumer addToLoaded(BiConsumer<MutablePropertySources, PropertySource<?>> addMethod, boolean checkForExisting) {
    // 创建 DocumentConsumer 对象
    return (profile, document) -> {
        // 如果要校验已经存在的情况，则如果已经存在，则直接 return
        if (checkForExisting) {
            for (MutablePropertySources merged : this.loaded.values()) {
                if (merged.contains(document.getPropertySource().getName())) {
                    return;
                }
            }
        }
        // 获得 profile 对应的 MutablePropertySources 对象
        MutablePropertySources merged = this.loaded.computeIfAbsent(profile,
                (k) -> new MutablePropertySources());
        // 将加载的 document 合并到 merged 中
        addMethod.accept(merged, document.getPropertySource());
    };
}
```

- 创建了一个 DocumentConsumer 对象。而其内部的逻辑，很简单，胖友自己瞅瞅即可。

##### 4.4.1.1.7 loadForFileExtension

`#loadForFileExtension(PropertySourceLoader loader, String prefix, String fileExtension, Profile profile, DocumentFilterFactory filterFactory, DocumentConsumer consumer)` 方法，加载 Profile 指定的配置文件（带后缀）。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private void loadForFileExtension(PropertySourceLoader loader, String prefix,
        String fileExtension, Profile profile,
        DocumentFilterFactory filterFactory, DocumentConsumer consumer) {
    // <1> 获得 DocumentFilter 对象
    DocumentFilter defaultFilter = filterFactory.getDocumentFilter(null);
    DocumentFilter profileFilter = filterFactory.getDocumentFilter(profile);
    // <2> 加载 Profile 指定的配置文件（带后缀）。
    if (profile != null) {
        // Try profile-specific file & profile section in profile file (gh-340)
        // 加载 Profile 指定的配置文件（带后缀）。
        String profileSpecificFile = prefix + "-" + profile + fileExtension;
        load(loader, profileSpecificFile, profile, defaultFilter, consumer); // <2.1> 情况一，未配置 spring.profile 属性
        load(loader, profileSpecificFile, profile, profileFilter, consumer); // <2.2> 情况二，有配置 spring.profile 属性
        // Try profile specific sections in files we've already processed
        // <2.3》 特殊情况，之前读取 Profile 对应的配置文件，也可被当前 Profile 所读取。
        // 举个例子，假设之前读取了 Profile 为 common 对应配置文件是 application-common.properties ，里面配置了 spring.profile=dev,prod
        //         那么，此时如果读取的 Profile 为 dev 时，也能读取 application-common.properties 这个配置文件
        for (Profile processedProfile : this.processedProfiles) {
            if (processedProfile != null) {
                String previouslyLoaded = prefix + "-" + processedProfile + fileExtension; // 拼接之前的配置文件名
                load(loader, previouslyLoaded, profile, profileFilter, consumer); // 注意噢，传入的 profile 是当前的 profile
            }
        }
    }
    // Also try the profile-specific section (if any) of the normal file
    // <3> 加载（无需带 Profile）指定的配置文件（带后缀）。
    load(loader, prefix + fileExtension, profile, profileFilter, consumer);
}
```

- `<1>` 处，获得两个 DocumentFilter 对象。为什么是两个呢？胖友思考下。实际上，我们在 [「4.4.1.1.5.2 getPositiveProfileFilter」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，已经说明了答案。
- `<2>` 处，加载 Profile 指定的配置文件（带后缀）。有三种情况，胖友认真看 `<2.1>`、`<2.2>`、`<2.3>` 处的代码注释。
- `<3>` 处，加载（无需带 Profile）指定的配置文件（带后缀）。
- 关于 `#load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter, DocumentConsumer consumer)` 方法，真正加载 Profile 指定的配置文件（带后缀）。详细解析，见 [「4.4.1.1.8 load」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 。

##### 4.4.1.1.8 load

`#load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter, DocumentConsumer consumer)` 方法，真正加载 Profile 指定的配置文件（带后缀）。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private void load(PropertySourceLoader loader, String location, Profile profile, DocumentFilter filter, DocumentConsumer consumer) {
    try {
        // <1.1> 判断指定的配置文件是否存在。若不存在，则直接返回
        Resource resource = this.resourceLoader.getResource(location);
        if (!resource.exists()) {
            if (this.logger.isTraceEnabled()) {
                StringBuilder description = getDescription("Skipped missing config ", location, resource, profile);
                this.logger.trace(description);
            }
            return;
        }
        // <1.2> 如果没有文件后缀的配置文件，则忽略，不进行读取
        if (!StringUtils.hasText(StringUtils.getFilenameExtension(resource.getFilename()))) {
            if (this.logger.isTraceEnabled()) {
                StringBuilder description = getDescription("Skipped empty config extension ", location, resource, profile);
                this.logger.trace(description);
            }
            return;
        }
        // <1.3> 加载配置文件，返回 Document 数组
        String name = "applicationConfig: [" + location + "]";
        List<Document> documents = loadDocuments(loader, name, resource);
        // <1.4> 如果没加载到，则直接返回
        if (CollectionUtils.isEmpty(documents)) {
            if (this.logger.isTraceEnabled()) {
                StringBuilder description = getDescription(
                        "Skipped unloaded config ", location, resource, profile);
                this.logger.trace(description);
            }
            return;
        }
        // <2> 使用 DocumentFilter 过滤匹配的 Document ，添加到 loaded 数组中。
        List<Document> loaded = new ArrayList<>();
        for (Document document : documents) {
            if (filter.match(document)) { // 匹配
                addActiveProfiles(document.getActiveProfiles()); // <2.1>
                addIncludedProfiles(document.getIncludeProfiles()); // <2.2>
                loaded.add(document);
            }
        }
        Collections.reverse(loaded);
        // <3> 使用 DocumentConsumer 进行消费 Document ，添加到本地的 loaded 中。
        if (!loaded.isEmpty()) {
            loaded.forEach((document) -> consumer.accept(profile, document));
            if (this.logger.isDebugEnabled()) {
                StringBuilder description = getDescription("Loaded config file ", location, resource, profile);
                this.logger.debug(description);
            }
        }
    } catch (Exception ex) {
        throw new IllegalStateException("Failed to load property "
                + "source from location '" + location + "'", ex);
    }
}
```

- `<1.1>` 处，判断指定的配置文件是否存在。若不存在，则直接返回。

- `<1.2>` 处，如果没有文件后缀的配置文件，则忽略，不进行读取。

- `<1.3>` 处，调用 `#loadDocuments(PropertySourceLoader loader, String name, Resource resource)` 方法，加载配置文件，并返回 Document 数组。详细解析，见 [「4.4.1.1.8.1 loadDocuments」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 小节。

- `<1.4>` 处，如果没加载到，则直接返回。

- `<2>` 处，遍历加载到 `documents` 数组，逐个调用 `DocumentFilter#match(Document document)` 方法，进行匹配。若匹配成功，则添加到 `loaded` 中。

  - `<2.1>` 处，`#addActiveProfiles(Set<Profile> profiles)` 方法，已经在 [「4.4.1.1.1 initializeProfiles」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中，详细解析。

  - `<2.2>` 处，`#addIncludedProfiles(Set<Profile> profiles)` 方法，代码如下：

    ```
    // ConfigFileApplicationListener#Loader.java
    
    private void addIncludedProfiles(Set<Profile> includeProfiles) {
        // 整体逻辑是 includeProfiles - processedProfiles + profiles
    	LinkedList<Profile> existingProfiles = new LinkedList<>(this.profiles);
    	this.profiles.clear();
    	this.profiles.addAll(includeProfiles);
    	this.profiles.removeAll(this.processedProfiles);
    	this.profiles.addAll(existingProfiles);
    }
    ```

    - ~

  - `<3>` 处，遍历 `loaded` 数组，调用 `DocumentConsumer#accept(Profile profile, Document document)` 方法，添加到本地的 `Loader.loaded` 中。此处，在结合 [「4.4.1.1.6 DocumentConsumer」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 一起看。

😈 至此，Spring Boot 加载配置的功能，基本是完成了。总的来说，理解大体的流程，还是相对比较容易的。但是，想要扣懂这个过程的每一个细节，需要多多的调试。

> 艿艿：可能有些细节写的不到位，或者解释的不到位，又或者讲的不正确。所以，有任何疑惑，请立刻马上赶紧给我星球留言提问哈。

###### 4.4.1.1.8.1 loadDocuments

`#loadDocuments(PropertySourceLoader loader, String name, Resource resource)` 方法，加载配置文件，并返回 Document 数组。代码如下：

```
// ConfigFileApplicationListener#Loader.java

private List<Document> loadDocuments(PropertySourceLoader loader, String name, Resource resource) throws IOException {
    // <1> 创建 DocumentsCacheKey 对象，从 loadDocumentsCache 缓存中加载 Document 数组
    DocumentsCacheKey cacheKey = new DocumentsCacheKey(loader, resource);
    List<Document> documents = this.loadDocumentsCache.get(cacheKey);
    // <2.1> 如果不存在，则使用 PropertySourceLoader 加载指定配置文件
    if (documents == null) {
        List<PropertySource<?>> loaded = loader.load(name, resource);
        // <2.2> 将返回的 PropertySource 数组，封装成 Document 数组
        documents = asDocuments(loaded);
        // <2.3> 添加到 loadDocumentsCache 缓存中
        this.loadDocumentsCache.put(cacheKey, documents);
    }
    return documents;
}
```

- `<1>` 处，创建 DocumentsCacheKey 对象，从 `loadDocumentsCache` 缓存中加载 Document 数组。

- `<2.1>` 处，如果不存在，则调用 `PropertySourceLoader#load(String name, Resource resource)` 方法，加载指定配置文件。详细的解析，见 [「7. PropertySourceLoader」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) 中。

- `<2.2>` 处，调用 `#asDocuments(List<PropertySource<?>> loaded)` 方法，将返回的 PropertySource 数组，封装成 Document 数组。代码如下：

  ```
  // ConfigFileApplicationListener#Loader.java
  
  private List<Document> asDocuments(List<PropertySource<?>> loaded) {
      if (loaded == null) {
          return Collections.emptyList();
      }
      return loaded.stream().map((propertySource) -> {
          // 创建 Binder 对象
          Binder binder = new Binder(
                  ConfigurationPropertySources.from(propertySource),
                  this.placeholdersResolver);
          return new Document(propertySource,
                  binder.bind("spring.profiles", STRING_ARRAY).orElse(null), // 读取 "spring.profiles" 配置
                  getProfiles(binder, ACTIVE_PROFILES_PROPERTY), // 读取 "spring.profiles.active" 配置
                  getProfiles(binder, INCLUDE_PROFILES_PROPERTY)); // 读取 "spring.profiles.include" 配置
      }).collect(Collectors.toList());
  }
  
  private Set<Profile> getProfiles(Binder binder, String name) {
  	return binder.bind(name, STRING_ARRAY).map(this::asProfileSet).orElse(Collections.emptySet());
  }
  
  private Set<Profile> asProfileSet(String[] profileNames) {
  	List<Profile> profiles = new ArrayList<>();
  	for (String profileName : profileNames) {
  		profiles.add(new Profile(profileName));
  	}
  	return new LinkedHashSet<>(profiles);
  }
  ```

- `<2.3>` 处，添加到 `loadDocumentsCache` 缓存中。

# 5. RandomValuePropertySource

`org.springframework.boot.env.RandomValuePropertySource` ，继承 PropertySource 类，提供随机值的 PropertySource 实现类。

不了解 Spring Boot 从配置文件中获取随机数，可以看看 [《Spring Boot学习–从配置文件中获取随机数》](https://blog.csdn.net/qq_35981283/article/details/77853069) 文章。

## 5.1 addToEnvironment

`#addToEnvironment(ConfigurableEnvironment environment)` **静态**方法，创建 RandomValuePropertySource 对象，添加到 `environment` 中。代码如下：

```
// RandomValuePropertySource.java

/**
 * Name of the random {@link PropertySource}.
 */
public static final String RANDOM_PROPERTY_SOURCE_NAME = "random";

public static void addToEnvironment(ConfigurableEnvironment environment) {
	environment.getPropertySources().addAfter(StandardEnvironment.SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, new RandomValuePropertySource(RANDOM_PROPERTY_SOURCE_NAME));
	logger.trace("RandomValuePropertySource add to Environment");
}
```

## 5.2 getProperty

实现 `#getProperty(String name)` 方法，获得 `name` 对应的随机值。代码如下：

```
// RandomValuePropertySource.java

private static final String PREFIX = "random.";

@Override
public Object getProperty(String name) {
    // <1> 必须以 random. 前缀
    if (!name.startsWith(PREFIX)) {
        return null;
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Generating random property for '" + name + "'");
    }
    // <2> 根据类型，获得随机值
    return getRandomValue(name.substring(PREFIX.length()));
}
```

- `<1>` 处，必须以 `"random."` 前缀。在获取属性值，`name` 前后的 `${}` 已经被去掉。

- `<2>` 处，调用 `#getRandomValue(String type)` 方法，根据类型，获得随机值。代码如下：

  ```
  // RandomValuePropertySource.java
  
  private Object getRandomValue(String type) {
      // int
      if (type.equals("int")) {
          return getSource().nextInt();
      }
      // long
      if (type.equals("long")) {
          return getSource().nextLong();
      }
      // int 范围
      String range = getRange(type, "int");
      if (range != null) {
          return getNextIntInRange(range);
      }
      // long 范围
      range = getRange(type, "long");
      if (range != null) {
          return getNextLongInRange(range);
      }
      // uuid
      if (type.equals("uuid")) {
          return UUID.randomUUID().toString();
      }
      // md5
      return getRandomBytes();
  }
  
  private String getRange(String type, String prefix) {
      if (type.startsWith(prefix)) {
          int startIndex = prefix.length() + 1;
          if (type.length() > startIndex) {
              return type.substring(startIndex, type.length() - 1);
          }
      }
      return null;
  }
  
  private int getNextIntInRange(String range) {
      String[] tokens = StringUtils.commaDelimitedListToStringArray(range);
      int start = Integer.parseInt(tokens[0]);
      if (tokens.length == 1) {
          return getSource().nextInt(start);
      }
      return start + getSource().nextInt(Integer.parseInt(tokens[1]) - start);
  }
  
  private long getNextLongInRange(String range) {
      String[] tokens = StringUtils.commaDelimitedListToStringArray(range);
      if (tokens.length == 1) {
          return Math.abs(getSource().nextLong() % Long.parseLong(tokens[0]));
      }
      long lowerBound = Long.parseLong(tokens[0]);
      long upperBound = Long.parseLong(tokens[1]) - lowerBound;
      return lowerBound + Math.abs(getSource().nextLong() % upperBound);
  }
  
  private Object getRandomBytes() {
      byte[] bytes = new byte[32];
      getSource().nextBytes(bytes);
      return DigestUtils.md5DigestAsHex(bytes);
  }
  ```

  - 比较简单，瞅瞅即明白。

😈 这个谜题，是不是被揭晓了~

# 6. PropertySourcesPlaceholdersResolver

`org.springframework.boot.context.properties.bind.PropertySourcesPlaceholdersResolver` ，实现 PropertySource 对应的值是占位符的解析器 。

## 6.1 构造方法

```
// PropertySourcesPlaceholdersResolver.java

private final Iterable<PropertySource<?>> sources;

private final PropertyPlaceholderHelper helper;

public PropertySourcesPlaceholdersResolver(Environment environment) {
	this(getSources(environment), null);
}

public PropertySourcesPlaceholdersResolver(Iterable<PropertySource<?>> sources) {
	this(sources, null);
}

public PropertySourcesPlaceholdersResolver(Iterable<PropertySource<?>> sources,
		PropertyPlaceholderHelper helper) {
	this.sources = sources;
	this.helper = (helper != null) ? helper
			: new PropertyPlaceholderHelper(SystemPropertyUtils.PLACEHOLDER_PREFIX, // ${
					SystemPropertyUtils.PLACEHOLDER_SUFFIX, // }
					SystemPropertyUtils.VALUE_SEPARATOR, true);
}

// 获得 PropertySources 们
private static PropertySources getSources(Environment environment) {
	Assert.notNull(environment, "Environment must not be null");
	Assert.isInstanceOf(ConfigurableEnvironment.class, environment, "Environment must be a ConfigurableEnvironment");
	return ((ConfigurableEnvironment) environment).getPropertySources();
}
```

- 其中，创建的 `helper` 属性，为 PropertyPlaceholderHelper 对象。其中 `SystemPropertyUtils.PLACEHOLDER_PREFIX` 为 `${` ， `SystemPropertyUtils.PLACEHOLDER_SUFFIX` 为 `}` 。这样，例如说 RandomValuePropertySource 的 `${random.int}` 等等，就可以被 PropertySourcesPlaceholdersResolver 所处理。

## 6.2 resolvePlaceholders

实现 `#resolvePlaceholders(Object value)` 方法，解析占位符。代码如下：

```
// PropertySourcesPlaceholdersResolver.java

@Override
public Object resolvePlaceholders(Object value) {
    // 如果 value 是 String 类型，才是占位符
    if (value instanceof String) {
        return this.helper.replacePlaceholders((String) value, this::resolvePlaceholder);
    }
    return value;
}
```

- 如果 `value` 是 String 类型，才**可能**是占位符。满足时，调用 `PropertyPlaceholderHelper#replacePlaceholders(String value, PlaceholderResolver placeholderResolver)` 方法，解析出占位符里面的内容。

  - 例如说：PropertySourcesPlaceholdersResolver 中，占位符是 `${}` ，那么 `${random.int}` 被解析后的内容是 `random.int` 。

  - 解析到占位符后，则回调 `#resolvePlaceholder(String placeholder)` 方法，获得占位符对应的值。代码如下：

    ```
    // PropertySourcesPlaceholdersResolver.java
    
    protected String resolvePlaceholder(String placeholder) {
        if (this.sources != null) {
            // 遍历 sources 数组，逐个获得属性值。若获取到，则进行返回
            for (PropertySource<?> source : this.sources) {
                Object value = source.getProperty(placeholder);
                if (value != null) {
                    return String.valueOf(value);
                }
            }
        }
        return null;
    }
    ```

    - 这样，😈 RandomValuePropertySource 是不是就被串起来喽。

# 7. PropertySourceLoader

`org.springframework.boot.env.PropertySourceLoader` 接口，加载指定配置文件，返回 PropertySource 数组。代码如下：

```
// PropertySourceLoader.java

public interface PropertySourceLoader {

	/**
     * 获得可以处理的配置文件的后缀
     *
	 * Returns the file extensions that the loader supports (excluding the '.').
	 * @return the file extensions
	 */
	String[] getFileExtensions();

	/**
     * 加载指定配置文件，返回 PropertySource 数组
     *
	 * Load the resource into one or more property sources. Implementations may either
	 * return a list containing a single source, or in the case of a multi-document format
	 * such as yaml a source for each document in the resource.
	 * @param name the root name of the property source. If multiple documents are loaded
	 * an additional suffix should be added to the name for each source loaded.
     *             PropertySource 的名字
	 * @param resource the resource to load
     *             配置文件的 Resource 对象
	 * @return a list property sources
	 * @throws IOException if the source cannot be loaded
	 */
	List<PropertySource<?>> load(String name, Resource resource) throws IOException;

}
```

- 可能胖友，和我开始一样，为什么一个配置文件，加载后会存在多个 PropertySource 对象呢？下面，我们来见分晓~

## 7.1 PropertiesPropertySourceLoader

`org.springframework.boot.env.PropertiesPropertySourceLoader` ，实现 PropertySourceLoader 接口，加载 `.xml` 和 `.properties` 类型的配置文件。代码如下：

```
// PropertiesPropertySourceLoader.java

public class PropertiesPropertySourceLoader implements PropertySourceLoader {

    private static final String XML_FILE_EXTENSION = ".xml";

    @Override
    public String[] getFileExtensions() {
        return new String[] { "properties", "xml" }; // <1>
    }

    @Override
    public List<PropertySource<?>> load(String name, Resource resource)
            throws IOException {
        // <2.1> 读取指定配置文件，返回 Map 对象
        Map<String, ?> properties = loadProperties(resource);
        // <2.2> 如果 Map 为空，返回空数组
        if (properties.isEmpty()) {
            return Collections.emptyList();
        }
        // <2.3> 将 Map 封装成 OriginTrackedMapPropertySource 对象，然后返回单元素的数组
        return Collections.singletonList(new OriginTrackedMapPropertySource(name, properties));
    }

}
```

- `<1>` 处，返回可处理的文件类型，为 `properties` 和 `xml` 。

- `<2.1>` 处，调用 `#loadProperties(Resource resource)` 方法，读取指定配置文件，返回 Map 对象。代码如下：

  ```
  // PropertiesPropertySourceLoader.java
  
  private Map<String, ?> loadProperties(Resource resource) throws IOException {
      String filename = resource.getFilename();
      // 读取 XML 后缀的配置文件
      if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) {
          return (Map) PropertiesLoaderUtils.loadProperties(resource);
      }
      // 读取 Properties 后缀的配置文件
      return new OriginTrackedPropertiesLoader(resource).load();
  }
  ```

  - 根据 `.xml` 和 `.properties` 后缀，使用不同的读取方法。至于读取配置的逻辑，暂时不在本文的范畴，hoho 。感兴趣的胖友，自己去瞅瞅。

- `<2.2>` 处，如果 Map 为空，返回空数组。

- ```
  <2.3>
  ```

   

  处，将 Map 封装成 OriginTrackedMapPropertySource 对象，然后返回单元素的数组。

  ```
  org.springframework.boot.env.OriginTrackedMapPropertySource
  ```

   

  ，继承 MapPropertySource 类，实现 OriginLookup 接口，代码如下：

  ```
  // OriginTrackedMapPropertySource.java
  
  public final class OriginTrackedMapPropertySource extends MapPropertySource
  		implements OriginLookup<String> {
  
  	@SuppressWarnings({ "unchecked", "rawtypes" })
  	public OriginTrackedMapPropertySource(String name, Map source) {
  		super(name, source);
  	}
  
  	@Override
  	public Object getProperty(String name) {
  	    // 获得属性值
  		Object value = super.getProperty(name);
  		// 如果是 OriginTrackedValue 封装类型，则返回其真实的值
  		if (value instanceof OriginTrackedValue) {
  			return ((OriginTrackedValue) value).getValue();
  		}
  		return value;
  	}
  
  	@Override
  	public Origin getOrigin(String name) {
          // 获得属性值
          Object value = super.getProperty(name);
          // 如果是 OriginTrackedValue 封装类型，则返回其 Origin
  		if (value instanceof OriginTrackedValue) {
  			return ((OriginTrackedValue) value).getOrigin();
  		}
  		return null;
  	}
  
  }
  ```

## 7.2 YamlPropertySourceLoader

`org.springframework.boot.env.YamlPropertySourceLoader` ，实现 PropertySourceLoader 接口，加载 `.yaml` 和 `.yml` 类型的配置文件。代码如下：

```
// YamlPropertySourceLoader.java

public class YamlPropertySourceLoader implements PropertySourceLoader {

    @Override
    public String[] getFileExtensions() {
        return new String[] { "yml", "yaml" }; // <1>
    }

    @Override
    public List<PropertySource<?>> load(String name, Resource resource) throws IOException {
        // <2> 如果不存在 org.yaml.snakeyaml.Yaml 类，说明没有引入 snakeyaml 依赖
        if (!ClassUtils.isPresent("org.yaml.snakeyaml.Yaml", null)) {
            throw new IllegalStateException("Attempted to load " + name
                    + " but snakeyaml was not found on the classpath");
        }
        // <3.1> 加载配置，返回 Map 数组
        List<Map<String, Object>> loaded = new OriginTrackedYamlLoader(resource).load();
        // <3.2> 如果数组为空，返回空数组
        if (loaded.isEmpty()) {
            return Collections.emptyList();
        }
        // <3.3> 将 Map 数组，封装成 OriginTrackedMapPropertySource 数组，返回
        List<PropertySource<?>> propertySources = new ArrayList<>(loaded.size());
        for (int i = 0; i < loaded.size(); i++) {
            String documentNumber = (loaded.size() != 1) ? " (document #" + i + ")" : "";
            propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber, loaded.get(i)));
        }
        return propertySources;
    }

}
```

- `<1>` 处，返回可处理的文件类型，为 `yaml` 和 `yml` 。
- `<2>` 处，如果不存在 `org.yaml.snakeyaml.Yaml` 类，说明没有引入 snakeyaml 依赖，则抛出 IllegalStateException 异常。
- `<3.1>` 处，调用 `OriginTrackedYamlLoader#load()` 方法，加载配置，返回 Map 数组。😈 哎哟，此处就是我们的好奇了，返回的是 Map 数组列！我们先来看看 [《Spring Boot 使用 YML 文件配置多环境》](https://blog.csdn.net/yy756127197/article/details/78193398) 的 [「1 一个yml文件」](https://svip.iocoder.cn/Spring-Boot/properties-load/#) ，每个 `----` 分割线，会解析成一个对应的 `Map<String, Object>` 对象。
- `<3.2>` 处，如果 Map 数组为空，返回空数组。
- `<3.3>` 处，将 Map 数组，封装成 OriginTrackedMapPropertySource 数组，然后返回。

# 666. 彩蛋

卧槽，真心是内心无比卧槽。比我预先的，长太太太多了。

如果有解释不到位的地方，麻烦胖友在星球提出下哟。hoho ，春节期间初二，在老家写完~

参考和推荐如下文章：

- oldflame-Jm [《Spring boot源码分析-profiles环境（4）》](https://blog.csdn.net/jamet/article/details/77508182)
- oldflame-Jm [《Spring boot源码分析-ApplicationListener应用环境（5）》](https://blog.csdn.net/jamet/article/details/78042486)
- youzhibing2904 [《spring-boot-2.0.3不一样系列之源码篇 - run方法（二）之prepareEnvironment，绝对有值得你看的地方》](https://www.cnblogs.com/youzhibing/p/9622441.html)

------

如下内容，是艿艿的草稿，胖友可以先不去了解。

假设 Profile 为 `prod,dev` 。读取结果如下：

> 如下过程，省略读取不到配置文件的情况。

- getPositiveProfileFilter 的情况

  - ```
    profile=null
    ```

     

    部分

    - 读取 `classpath:/application.properties` ，匹配成功。
    - 读取 `classpath:/application.yaml` ，匹配成功。

  - ```
    profile=prod
    ```

    - 读取 `classpath:/application-prod.properties` ，匹配成功（基于 `defaultFilter`）。
    - 读取 `classpath:/application-prod.properties` ，匹配失败（基于 `profileFilter`）。
    - 读取 `classpath:/application-prod.properties` ，匹配失败（基于 `profileFilter`）。
    - 读取 `classpath:/application.yaml` ，匹配失败（基于 `profileFilter`）。【匹配上 prod 那部分】

  - ```
    profile=dev
    ```

    - 读取 `classpath:/application-dev.properties` ，匹配成功（基于 `defaultFilter`）。
    - 读取 `classpath:/application-dev.properties` ，匹配失败（基于 `profileFilter`）。
    - 读取 `classpath:/application-dev.properties` ，匹配失败（基于 `profileFilter`）。
    - 读取 `classpath:/application.yaml` ，匹配失败（基于 `profileFilter`）。【匹配上 dev 那部分】

- getNegativeProfileFilter 的情况

  - ```
    profile=null
    ```

     

    部分

    - 读取 `classpath:/application.properties` ，匹配失败。

    - 🙂🙂🙂 读取

       

      ```
      classpath:/application.yaml
      ```

       

      ，匹配成功【匹配上 prod、dev 那部分】。比较有意思 😈 ，用于解决

       

      ```
      profile=null
      ```

       

      的情况，可以把激活的 Profile ，也匹配上。但是在目前这个情况下，即使匹配上，在

       

      ```
      #addToLoaded(...)
      ```

       

      方法中的 DocumentConsumer 的逻辑时，会在

       

      ```
      checkForExisting
      ```

       

      那块的逻辑，如果要校验已经存在的情况，则如果已经存在，则直接

       

      ```
      return
      ```

       

      被排除掉。因为在

       

      ```
      profile=prod
      ```

       

      和

       

      ```
      profile=dev
      ```

       

      部分，已经匹配上该部分的配置。

      - = =~当然，实在搞不懂这个逻辑，也不用纠结这个。重点是搞懂 Spring Boot 加载配置的核心逻辑。也就是，ConfigFileApplicationListener 整体的逻辑。
      - 艿艿又思考了下，貌似突然也有点想不通，什么情况下，这块逻辑会成功加载到 Profile 不匹配的配置文件，即在在 `#addToLoaded(...)` 方法中的 DocumentConsumer 的逻辑时，会在 `checkForExisting` 那块的逻辑，如果要校验已经存在的情况，则如果不存在。