protected final String name;

// 属性源
protected final T source;

public PropertySource(String name, T source) {
    Assert.hasText(name, "Property source name must contain at least one character");
    Assert.notNull(source, "Property source must not be null");
    this.name = name;
    this.source = source;
}

@SuppressWarnings("unchecked")
public PropertySource(String name) {
    // 默认以一个空的对象作为属性源
    this(name, (T) new Object());
}

// 属性源集合
private final MutablePropertySources propertySources;

// 属性解析器
private final ConfigurablePropertyResolver propertyResolver;

public AbstractEnvironment() {
    // 创建一个默认的属性源集合对象
    this(new MutablePropertySources());
}

// 这里也可以看出environment中是通过MutablePropertySources来封装了所有的属性源
protected AbstractEnvironment(MutablePropertySources propertySources) {
    this.propertySources = propertySources;
    // 创建属性解析器
    this.propertyResolver = createPropertyResolver(propertySources);
    // 自定义属性源集合，比如往里面添加属性源
    customizePropertySources(propertySources);
}

// 用于保存Environment中的所有属性源
private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();

public MutablePropertySources() {
}

public MutablePropertySources(PropertySources propertySources) {
    this();
    for (PropertySource<?> propertySource : propertySources) {
        addLast(propertySource);
    }
}

@Override
public Iterator<PropertySource<?>> iterator() {
    // 直接返回集合列表的迭代器
    return this.propertySourceList.iterator();
}

/** System environment property source name: {@value}. */
public static final String SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME = "systemEnvironment";

/** JVM system properties property source name: {@value}. */
public static final String SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME = "systemProperties";

@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
    /*
     * 添加两个属性源：
     * * PropertiesPropertySource保存所有通过System.getProperties()获取的属性；
     * * SystemEnvironmentPropertySource保存所有通过System.getenv()获取的属性；
     */
    // 系统属性
    propertySources.addLast(
            new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
    // 环境变量
    propertySources.addLast(
            new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}

// 这里也可以看出environment中是通过MutablePropertySources来封装了所有的属性源
protected AbstractEnvironment(MutablePropertySources propertySources) {
    this.propertySources = propertySources;
    // 创建属性解析器
    this.propertyResolver = createPropertyResolver(propertySources);
    // 自定义属性源集合，比如往里面添加属性源
    customizePropertySources(propertySources);
}

	protected ConfigurablePropertyResolver createPropertyResolver(MutablePropertySources propertySources) {
		// 根据属性源创建属性解析器
		return new PropertySourcesPropertyResolver(propertySources);
	}

@Override
public boolean containsProperty(String key) {
    return this.propertyResolver.containsProperty(key);
}

// 下面是6个获取属性的方法

@Override
@Nullable
public String getProperty(String key) {
    return this.propertyResolver.getProperty(key);
}

@Override
public String getProperty(String key, String defaultValue) {
    return this.propertyResolver.getProperty(key, defaultValue);
}

@Override
@Nullable
public <T> T getProperty(String key, Class<T> targetType) {
    return this.propertyResolver.getProperty(key, targetType);
}

@Override
public <T> T getProperty(String key, Class<T> targetType, T defaultValue) {
    return this.propertyResolver.getProperty(key, targetType, defaultValue);
}

@Override
public String getRequiredProperty(String key) throws IllegalStateException {
    return this.propertyResolver.getRequiredProperty(key);
}

@Override
public <T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException {
    return this.propertyResolver.getRequiredProperty(key, targetType);
}

// 下面是两个解析占位符的方法

@Override
public String resolvePlaceholders(String text) {
    return this.propertyResolver.resolvePlaceholders(text);
}

@Override
public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
    return this.propertyResolver.resolveRequiredPlaceholders(text);
}

@Nullable
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.isTraceEnabled()) {
        logger.trace("Could not find key '" + key + "' in any property source");
    }
    return null;
}

protected String resolveNestedPlaceholders(String value) {
    if (value.isEmpty()) {
        return value;
    }
    /*
     * ignoreUnresolvableNestedPlaceholders表示是否忽略嵌套的占位符，默认值是false。
     * 不管要不要忽略，最终都会调用到doResolvePlaceholders方法，只不过helper参数不一样而已。
     */
    return (this.ignoreUnresolvableNestedPlaceholders ?
            // 忽略嵌套的占位符
            resolvePlaceholders(value) :
            // 不忽略嵌套的占位符
            resolveRequiredPlaceholders(value));
}

/*
 * 下面这三个属性的默认值分别是: '${'、 '}'、 ':'
 */

private String placeholderPrefix = SystemPropertyUtils.PLACEHOLDER_PREFIX;

private String placeholderSuffix = SystemPropertyUtils.PLACEHOLDER_SUFFIX;

@Nullable
private String valueSeparator = SystemPropertyUtils.VALUE_SEPARATOR;

private PropertyPlaceholderHelper createPlaceholderHelper(boolean ignoreUnresolvablePlaceholders) {
    // 创建属性占位符helper，用于帮助解析属性
    return new PropertyPlaceholderHelper(this.placeholderPrefix, this.placeholderSuffix,
            this.valueSeparator, ignoreUnresolvablePlaceholders);
}

private static final Map<String, String> wellKnownSimplePrefixes = new HashMap<>(4);

static {
    wellKnownSimplePrefixes.put("}", "{");
    wellKnownSimplePrefixes.put("]", "[");
    wellKnownSimplePrefixes.put(")", "(");
}


private final String placeholderPrefix;

private final String placeholderSuffix;

private final String simplePrefix;

// 占位符名称和属性默认值之间的分隔符
@Nullable
private final String valueSeparator;

// 是否忽略不能够解析的占位符
private final boolean ignoreUnresolvablePlaceholders;

public PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix) {
    this(placeholderPrefix, placeholderSuffix, null, true);
}

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);
    /*
     * 默认的占位符前缀是'${'，所以这里的endsWith是满足的。
     * 另外在下面的findPlaceholderEndIndex函数中，使用simplePrefix确实可以比使用整个前缀要提高性能。
     *
     * 这里不用担心前缀中没有使用预配置好的后缀对应的简化前缀，因为这里使用了endsWith来判断了。
     */
    if (simplePrefixForSuffix != null && this.placeholderPrefix.endsWith(simplePrefixForSuffix)) {
        // 所以这里的simplePrefix是'{'
        this.simplePrefix = simplePrefixForSuffix;
    }
    else {
        this.simplePrefix = this.placeholderPrefix;
    }
    this.valueSeparator = valueSeparator;
    this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
}

private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
    // 通过helper解析占位符，第二个值是用来获取占位符的值的函数
    return helper.replacePlaceholders(text, this::getPropertyAsRawString);
}

public String replacePlaceholders(String value, final Properties properties) {
    Assert.notNull(properties, "'properties' must not be null");
    return replacePlaceholders(value, properties::getProperty);
}

public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
    Assert.notNull(value, "'value' must not be null");
    // 解析属性
    return parseStringValue(value, placeholderResolver, null);
}

@SuppressWarnings("unchecked")
@Nullable
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);
}

@Override
public void setConversionService(ConfigurableConversionService conversionService) {
    // 为属性解析器设置转换服务
    this.propertyResolver.setConversionService(conversionService);
}