Spring的环境&属性：PropertySource、Environment、Profile

public interface PropertyResolver {

    // 是否包含某个属性
    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);

    // 获取属性值，找不到抛出异常IllegalStateException
    String getRequiredProperty(String key) throws IllegalStateException;

    // 获取指定类型的属性值，找不到抛出异常IllegalStateException
    <T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;

    // 替换文本中的占位符（${key}）到属性值，找不到不解析
    String resolvePlaceholders(String text);

    // 替换文本中的占位符（${key}）到属性值，找不到抛出异常IllegalArgumentException
    String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;
}

PropertyResolver propertyResolver = new PropertySourcesPropertyResolver(propertySources);

System.out.println(propertyResolver.getProperty("name"));
System.out.println(propertyResolver.getProperty("name", "chenssy"));
System.out.println(propertyResolver.resolvePlaceholders("my name is  ${name}"));

public interface ConfigurablePropertyResolver extends PropertyResolver {

    // 返回执行类型转换时使用的 ConfigurableConversionService
    ConfigurableConversionService getConversionService();

    // 设置 ConfigurableConversionService
    void setConversionService(ConfigurableConversionService conversionService);

    // 设置占位符前缀
    void setPlaceholderPrefix(String placeholderPrefix);

    // 设置占位符后缀
    void setPlaceholderSuffix(String placeholderSuffix);

    // 设置占位符与默认值之间的分隔符
    void setValueSeparator(@Nullable String valueSeparator);

    // 设置当遇到嵌套在给定属性值内的不可解析的占位符时是否抛出异常
    // 当属性值包含不可解析的占位符时，getProperty(String)及其变体的实现必须检查此处设置的值以确定正确的行为。
    void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders);

    // 指定必须存在哪些属性，以便由validateRequiredProperties（）验证
    void setRequiredProperties(String... requiredProperties);

    // 验证setRequiredProperties指定的每个属性是否存在并解析为非null值
    void validateRequiredProperties() throws MissingRequiredPropertiesException;

}

// 类型转换去
private volatile ConfigurableConversionService conversionService;
// 占位符
private PropertyPlaceholderHelper nonStrictHelper;
//
private PropertyPlaceholderHelper strictHelper;
// 设置是否抛出异常
private boolean ignoreUnresolvableNestedPlaceholders = false;
// 占位符前缀
private String placeholderPrefix = SystemPropertyUtils.PLACEHOLDER_PREFIX;
// 占位符后缀
private String placeholderSuffix = SystemPropertyUtils.PLACEHOLDER_SUFFIX;
// 与默认值的分割
private String valueSeparator = SystemPropertyUtils.VALUE_SEPARATOR;
// 必须要有的字段值
private final Set<String> requiredProperties = new LinkedHashSet<>();

public ConfigurableConversionService getConversionService() {
  // 需要提供独立的DefaultConversionService，而不是PropertySourcesPropertyResolver 使用的共享DefaultConversionService。
  ConfigurableConversionService cs = this.conversionService;
  if (cs == null) {
    synchronized (this) {
      cs = this.conversionService;
      if (cs == null) {
        cs = new DefaultConversionService();
        this.conversionService = cs;
      }
    }
  }
  return cs;
}

@Override
public void setConversionService(ConfigurableConversionService conversionService) {
  Assert.notNull(conversionService, "ConversionService must not be null");
  this.conversionService = conversionService;
}

public void setPlaceholderPrefix(String placeholderPrefix) {
  Assert.notNull(placeholderPrefix, "'placeholderPrefix' must not be null");
  this.placeholderPrefix = placeholderPrefix;
}

public void setPlaceholderSuffix(String placeholderSuffix) {
  Assert.notNull(placeholderSuffix, "'placeholderSuffix' must not be null");
  this.placeholderSuffix = placeholderSuffix;
}

public String getProperty(String key) {
  return getProperty(key, String.class);
}

public String getProperty(String key, String defaultValue) {
  String value = getProperty(key);
  return (value != null ? value : defaultValue);
}

public <T> T getProperty(String key, Class<T> targetType, T defaultValue) {
  T value = getProperty(key, targetType);
  return (value != null ? value : defaultValue);
}

public String getRequiredProperty(String key) throws IllegalStateException {
  String value = getProperty(key);
  if (value == null) {
    throw new IllegalStateException("Required key '" + key + "' not found");
  }
  return value;
}

public <T> T getRequiredProperty(String key, Class<T> valueType) throws IllegalStateException {
  T value = getProperty(key, valueType);
  if (value == null) {
    throw new IllegalStateException("Required key '" + key + "' not found");
  }
  return value;

public abstract class PropertySource<T> {
    protected final Log logger = LogFactory.getLog(getClass());
    protected final String name;
    protected final T source;

   //......
}

protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
  if (this.propertySources != null) {
    for (PropertySource<?> propertySource : this.propertySources) {
      if (logger.isTraceEnabled()) {
        logger.trace("Searching for key '" + key + "' in PropertySource '" +
                     propertySource.getName() + "'");
      }
      Object value = propertySource.getProperty(key);
      if (value != null) {
        if (resolveNestedPlaceholders && value instanceof String) {
          value = resolveNestedPlaceholders((String) value);
        }
        logKeyFound(key, propertySource, value);
        return convertValueIfNecessary(value, targetValueType);
      }
    }
  }
  if (logger.isDebugEnabled()) {
    logger.debug("Could not find key '" + key + "' in any property source");
  }
  return null;
}

protected String resolveNestedPlaceholders(String value) {
  return (this.ignoreUnresolvableNestedPlaceholders ?
          resolvePlaceholders(value) : resolveRequiredPlaceholders(value));
}

private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
  return helper.replacePlaceholders(text, this::getPropertyAsRawString);
}

public PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix,
                                 @Nullable String valueSeparator, boolean ignoreUnresolvablePlaceholders) {

  Assert.notNull(placeholderPrefix, "'placeholderPrefix' must not be null");
  Assert.notNull(placeholderSuffix, "'placeholderSuffix' must not be null");
  this.placeholderPrefix = placeholderPrefix;
  this.placeholderSuffix = placeholderSuffix;
  String simplePrefixForSuffix = wellKnownSimplePrefixes.get(this.placeholderSuffix);
  if (simplePrefixForSuffix != null && this.placeholderPrefix.endsWith(simplePrefixForSuffix)) {
    this.simplePrefix = simplePrefixForSuffix;
  }
  else {
    this.simplePrefix = this.placeholderPrefix;
  }
  this.valueSeparator = valueSeparator;
  this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
}

public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
  Assert.notNull(value, "'value' must not be null");
  return parseStringValue(value, placeholderResolver, new HashSet<>());
}

protected String parseStringValue(
  String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {

  StringBuilder result = new StringBuilder(value);

  // 检索前缀，${
  int startIndex = value.indexOf(this.placeholderPrefix);
  while (startIndex != -1) {
    // 检索后缀 ,}
    int endIndex = findPlaceholderEndIndex(result, startIndex);
    if (endIndex != -1) {
      // 前缀和后缀之间的字符串
      String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
      String originalPlaceholder = placeholder;
      // 循环占位符
      // 判断该占位符是否已经处理了
      if (!visitedPlaceholders.add(originalPlaceholder)) {
        throw new IllegalArgumentException(
          "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
      }
      // 递归调用，解析占位符
      placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
      // 获取值
      String propVal = placeholderResolver.resolvePlaceholder(placeholder);
      // propval 为空，则提取默认值
      if (propVal == null && this.valueSeparator != null) {
        int separatorIndex = placeholder.indexOf(this.valueSeparator);
        if (separatorIndex != -1) {
          String actualPlaceholder = placeholder.substring(0, separatorIndex);
          String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
          propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
          if (propVal == null) {
            propVal = defaultValue;
          }
        }
      }
      if (propVal != null) {
        // 递归调用，解析先前解析的占位符值中包含的占位符
        propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
        result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
        if (logger.isTraceEnabled()) {
          logger.trace("Resolved placeholder '" + placeholder + "'");
        }
        startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
      }
      else if (this.ignoreUnresolvablePlaceholders) {
        // Proceed with unprocessed value.
        startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
      }
      else {
        throw new IllegalArgumentException("Could not resolve placeholder '" +
                                           placeholder + "'" + " in value \"" + value + "\"");
      }
      //
      visitedPlaceholders.remove(originalPlaceholder);
    }
    else {
      startIndex = -1;
    }
  }

  return result.toString();
}

protected <T> T convertValueIfNecessary(Object value, @Nullable Class<T> targetType) {
  if (targetType == null) {
    return (T) value;
  }
  ConversionService conversionServiceToUse = this.conversionService;
  if (conversionServiceToUse == null) {
    // Avoid initialization of shared DefaultConversionService if
    // no standard type conversion is needed in the first place...
    if (ClassUtils.isAssignableValue(targetType, value)) {
      return (T) value;
    }
    conversionServiceToUse = DefaultConversionService.getSharedInstance();
  }
  return conversionServiceToUse.convert(value, targetType);
}

public interface Environment extends PropertyResolver {
    // 返回此环境下激活的配置文件集
    String[] getActiveProfiles();

    // 如果未设置激活配置文件，则返回默认的激活的配置文件集
    String[] getDefaultProfiles();

    boolean acceptsProfiles(String... profiles);
}

public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
    // 指定该环境下的 profile 集
    void setActiveProfiles(String... profiles);

    // 增加此环境的 profile
    void addActiveProfile(String profile);

    // 设置默认的 profile
    void setDefaultProfiles(String... profiles);

    // 返回此环境的 PropertySources
    MutablePropertySources getPropertySources();

   // 尝试返回 System.getenv() 的值，若失败则返回通过 System.getenv(string) 的来访问各个键的映射
    Map<String, Object> getSystemEnvironment();

    // 尝试返回 System.getProperties() 的值，若失败则返回通过 System.getProperties(string) 的来访问各个键的映射
    Map<String, Object> getSystemProperties();

    void merge(ConfigurableEnvironment parent);
}

public static final String ACTIVE_PROFILES_PROPERTY_NAME = "spring.profiles.active";
private final Set<String> activeProfiles = new LinkedHashSet<>();

public static final String DEFAULT_PROFILES_PROPERTY_NAME = "spring.profiles.default";
private final Set<String> defaultProfiles = new LinkedHashSet<>(getReservedDefaultProfiles());

public void setActiveProfiles(String... profiles) {
  Assert.notNull(profiles, "Profile array must not be null");
  if (logger.isDebugEnabled()) {
    logger.debug("Activating profiles " + Arrays.asList(profiles));
  }
  synchronized (this.activeProfiles) {
    this.activeProfiles.clear();
    for (String profile : profiles) {
      validateProfile(profile);
      this.activeProfiles.add(profile);
    }
  }
}

protected void validateProfile(String profile) {
  if (!StringUtils.hasText(profile)) {
    throw new IllegalArgumentException("Invalid profile [" + profile + "]: must contain text");
  }
  if (profile.charAt(0) == '!') {
    throw new IllegalArgumentException("Invalid profile [" + profile + "]: must not begin with ! operator");
  }
}

public String[] getActiveProfiles() {
  return StringUtils.toStringArray(doGetActiveProfiles());
}

protected Set<String> doGetActiveProfiles() {
  synchronized (this.activeProfiles) {
    if (this.activeProfiles.isEmpty()) {
      String profiles = getProperty(ACTIVE_PROFILES_PROPERTY_NAME);
      if (StringUtils.hasText(profiles)) {
        setActiveProfiles(StringUtils.commaDelimitedListToStringArray(
          StringUtils.trimAllWhitespace(profiles)));
      }
    }
    return this.activeProfiles;
  }
}