【死磕 Spring】—- Spring 的環境&屬性：PropertySource、Environment、Profile

spring.profiles.active 和 @Profile 這兩個我相信各位都熟悉吧，主要功能是可以實現不同環境下（開發、測試、生產）引數配置的切換。其實關於環境的切換，小編在部落格 【死磕Spring】—– IOC 之 PropertyPlaceholderConfigurer 的應用 已經介紹了利用 PropertyPlaceholderConfigurer 來實現動態切換配置環境，當然這種方法需要我們自己實現，有點兒麻煩。但是對於這種非常實際的需求，Spring 怎麼可能沒有提供呢？下麵小編就問題來對 Spring 的環境 & 屬性來做一個分析說明。

概括

Spring 環境 & 屬性由四個部分組成：PropertySource、PropertyResolver、Profile 和 Environment。

• PropertySource：屬性源，key-value 屬性對抽象，用於配置資料。
• PropertyResolver：屬性解析器，用於解析屬性配置
• Profile：剖面，只有啟用的剖面的元件/配置才會註冊到 Spring 容器，類似於 Spring Boot 中的 profile
• Environment：環境，Profile 和 PropertyResolver 的組合。

下麵是整個體系的結構圖：

下麵就針對上面結構圖對 Spring 的 Properties & Environment 做一個詳細的分析。

Properties

PropertyResolver

屬性解析器，用於解析任何基礎源的屬性的介面

1. public interface PropertyResolver {
2.  
3.    // 是否包含某個屬性
4.    boolean containsProperty(String key);
5.  
6.    // 獲取屬性值 如果找不到傳回null
7.    @Nullable
8.    String getProperty(String key);
9.  
10.    // 獲取屬性值，如果找不到傳回預設值  
11.    String getProperty(String key, String defaultValue);
12.  
13.    // 獲取指定型別的屬性值，找不到傳回null
14.    @Nullable
15.    <T> T getProperty(String key, Class<T> targetType);
16.  
17.    // 獲取指定型別的屬性值，找不到傳回預設值
18.    <T> T getProperty(String key, Class<T> targetType, T defaultValue);
19.  
20.    // 獲取屬性值，找不到丟擲異常IllegalStateException
21.    String getRequiredProperty(String key) throws IllegalStateException;
22.  
23.    // 獲取指定型別的屬性值，找不到丟擲異常IllegalStateException
24.    <T> T getRequiredProperty(String key, Class<T> targetType) throws IllegalStateException;
25.  
26.    // 替換文字中的佔位符（${key}）到屬性值，找不到不解析
27.    String resolvePlaceholders(String text);
28.  
29.    // 替換文字中的佔位符（${key}）到屬性值，找不到丟擲異常IllegalArgumentException
30.    String resolveRequiredPlaceholders(String text) throws IllegalArgumentException;
31. }

從 API 上面我們就知道屬性解析器 PropertyResolver 的作用了。下麵是一個簡單的運用。

1. PropertyResolver propertyResolver = new PropertySourcesPropertyResolver(propertySources);
2.  
3. System.out.println(propertyResolver.getProperty("name"));
4. System.out.println(propertyResolver.getProperty("name", "chenssy"));
5. System.out.println(propertyResolver.resolvePlaceholders("my name is  ${name}"));

下圖是 PropertyResolver 體系結構圖：

• ConfigurablePropertyResolver：供屬性型別轉換的功能
• AbstractPropertyResolver：解析屬性檔案的抽象基類
• PropertySourcesPropertyResolver：PropertyResolver 的實現者，他對一組 PropertySources 提供屬性解析服務

ConfigurablePropertyResolver

提供屬性型別轉換的功能

通俗點說就是 ConfigurablePropertyResolver 提供屬性值型別轉換所需要的 ConversionService。

1. public interface ConfigurablePropertyResolver extends PropertyResolver {
2.  
3.    // 傳回執行型別轉換時使用的 ConfigurableConversionService
4.    ConfigurableConversionService getConversionService();
5.  
6.    // 設定 ConfigurableConversionService
7.    void setConversionService(ConfigurableConversionService conversionService);
8.  
9.    // 設定佔位符字首
10.    void setPlaceholderPrefix(String placeholderPrefix);
11.  
12.    // 設定佔位符字尾
13.    void setPlaceholderSuffix(String placeholderSuffix);
14.  
15.    // 設定佔位符與預設值之間的分隔符
16.    void setValueSeparator(@Nullable String valueSeparator);
17.  
18.    // 設定當遇到巢狀在給定屬性值內的不可解析的佔位符時是否丟擲異常
19.    // 當屬性值包含不可解析的佔位符時，getProperty(String)及其變體的實現必須檢查此處設定的值以確定正確的行為。
20.    void setIgnoreUnresolvableNestedPlaceholders(boolean ignoreUnresolvableNestedPlaceholders);
21.  
22.    // 指定必須存在哪些屬性，以便由validateRequiredProperties（）驗證
23.    void setRequiredProperties(String... requiredProperties);
24.  
25.    // 驗證setRequiredProperties指定的每個屬性是否存在並解析為非null值
26.    void validateRequiredProperties() throws MissingRequiredPropertiesException;
27.  
28. }

從 ConfigurablePropertyResolver 所提供的方法來看，除了訪問和設定 ConversionService 外，主要還提供了一些解析規則之類的方法。

就 Properties 體系而言，PropertyResolver 定義了訪問 Properties 屬性值的方法，而 ConfigurablePropertyResolver 則定義瞭解析 Properties 一些相關的規則和值進行型別轉換所需要的 Service。該體繫有兩個實現者：AbstractPropertyResolver 和 PropertySourcesPropertyResolver，其中 AbstractPropertyResolver 為實現的抽象基類，PropertySourcesPropertyResolver 為真正的實現者。

AbstractPropertyResolver

解析屬性檔案的抽象基類

AbstractPropertyResolver 作為基類它僅僅只是設定了一些解析屬性檔案所需要配置或者轉換器，如 setConversionService()、 setPlaceholderPrefix()、 setValueSeparator()，其實這些方法的實現都比較簡單都是設定或者獲取 AbstractPropertyResolver 所提供的屬性，如下：

1. // 型別轉換去
2. private volatile ConfigurableConversionService conversionService;
3. // 佔位符
4. private PropertyPlaceholderHelper nonStrictHelper;
5. //
6. private PropertyPlaceholderHelper strictHelper;
7. // 設定是否丟擲異常
8. private boolean ignoreUnresolvableNestedPlaceholders = false;
9. // 佔位符字首
10. private String placeholderPrefix = SystemPropertyUtils.PLACEHOLDER_PREFIX;
11. // 佔位符字尾
12. private String placeholderSuffix = SystemPropertyUtils.PLACEHOLDER_SUFFIX;
13. // 與預設值的分割
14. private String valueSeparator = SystemPropertyUtils.VALUE_SEPARATOR;
15. // 必須要有的欄位值
16. private final Set<String> requiredProperties = new LinkedHashSet<>();

這些屬性都是 ConfigurablePropertyResolver 介面所提供方法需要的屬性，他所提供的方法都是設定和讀取這些值，如下幾個方法：

1.    public ConfigurableConversionService getConversionService() {
2.        // 需要提供獨立的DefaultConversionService，而不是PropertySourcesPropertyResolver 使用的共享DefaultConversionService。
3.        ConfigurableConversionService cs = this.conversionService;
4.        if (cs == null) {
5.            synchronized (this) {
6.                cs = this.conversionService;
7.                if (cs == null) {
8.                    cs = new DefaultConversionService();
9.                    this.conversionService = cs;
10.                }
11.            }
12.        }
13.        return cs;
14.    }
15.  
16.    @Override
17.    public void setConversionService(ConfigurableConversionService conversionService) {
18.        Assert.notNull(conversionService, "ConversionService must not be null");
19.        this.conversionService = conversionService;
20.    }
21.  
22.    public void setPlaceholderPrefix(String placeholderPrefix) {
23.        Assert.notNull(placeholderPrefix, "'placeholderPrefix' must not be null");
24.        this.placeholderPrefix = placeholderPrefix;
25.    }
26.  
27.    public void setPlaceholderSuffix(String placeholderSuffix) {
28.        Assert.notNull(placeholderSuffix, "'placeholderSuffix' must not be null");
29.        this.placeholderSuffix = placeholderSuffix;
30.    }

而對屬性的訪問則委託給子類 PropertySourcesPropertyResolver 實現。

1.    public String getProperty(String key) {
2.        return getProperty(key, String.class);
3.    }
4.  
5.    public String getProperty(String key, String defaultValue) {
6.        String value = getProperty(key);
7.        return (value != null ? value : defaultValue);
8.    }
9.  
10.    public <T> T getProperty(String key, Class<T> targetType, T defaultValue) {
11.        T value = getProperty(key, targetType);
12.        return (value != null ? value : defaultValue);
13.    }
14.  
15.    public String getRequiredProperty(String key) throws IllegalStateException {
16.        String value = getProperty(key);
17.        if (value == null) {
18.            throw new IllegalStateException("Required key '" + key + "' not found");
19.        }
20.        return value;
21.    }
22.  
23.    public <T> T getRequiredProperty(String key, Class<T> valueType) throws IllegalStateException {
24.        T value = getProperty(key, valueType);
25.        if (value == null) {
26.            throw new IllegalStateException("Required key '" + key + "' not found");
27.        }
28.        return value;

PropertySourcesPropertyResolver

PropertyResolver 的實現者，他對一組 PropertySources 提供屬性解析服務

它僅有一個成員變數：PropertySources。該成員變數內部儲存著一組 PropertySource，表示 key-value 鍵值對的源的抽象基類，即一個 PropertySource 物件則是一個 key-value 鍵值對。如下：

1. public abstract class PropertySource<T> {
2.    protected final Log logger = LogFactory.getLog(getClass());
3.    protected final String name;
4.    protected final T source;
5.  
6.   //......
7. }

對外公開的 getProperty() 都是委託給 getProperty(Stringkey,Class<T>targetValueType,booleanresolveNestedPlaceholders) 實現，他有三個引數，分別表示為：

• key：獲取的 key
• targetValueType： 標的 value 的型別
• resolveNestedPlaceholders：是否解決巢狀佔位符

原始碼如下：

1.    protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) {
2.        if (this.propertySources != null) {
3.            for (PropertySource> propertySource : this.propertySources) {
4.                if (logger.isTraceEnabled()) {
5.                    logger.trace("Searching for key '" + key + "' in PropertySource '" +
6.                            propertySource.getName() + "'");
7.                }
8.                Object value = propertySource.getProperty(key);
9.                if (value != null) {
10.                    if (resolveNestedPlaceholders && value instanceof String) {
11.                        value = resolveNestedPlaceholders((String) value);
12.                    }
13.                    logKeyFound(key, propertySource, value);
14.                    return convertValueIfNecessary(value, targetValueType);
15.                }
16.            }
17.        }
18.        if (logger.isDebugEnabled()) {
19.            logger.debug("Could not find key '" + key + "' in any property source");
20.        }
21.        return null;
22.    }

首先從 propertySource 中獲取指定 key 的 value 值，然後判斷是否需要進行巢狀佔位符解析，如果需要則呼叫 resolveNestedPlaceholders() 進行巢狀佔位符解析，然後呼叫 convertValueIfNecessary() 進行型別轉換。

resolveNestedPlaceholders()

該方法用於解析給定字串中的佔位符，同時根據 ignoreUnresolvableNestedPlaceholders 的值，來確定是否對不可解析的佔位符的處理方法：是忽略還是丟擲異常（該值由 setIgnoreUnresolvableNestedPlaceholders() 設定）。

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

如果 this.ignoreUnresolvableNestedPlaceholders 為 true，則呼叫 resolvePlaceholders() ，否則呼叫 resolveRequiredPlaceholders() 但是無論是哪個方法，最終都會到 doResolvePlaceholders()，該方法接收兩個引數：

• String 型別的 text：待解析的字串
• PropertyPlaceholderHelper 型別的 helper：用於解析佔位符的工具類。

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

PropertyPlaceholderHelper 是用於處理包含佔位符值的字串，構造該實體需要四個引數：

• placeholderPrefix：佔位符字首
• placeholderSuffix：佔位符字尾
• valueSeparator：佔位符變數與關聯的預設值之間的分隔符
• ignoreUnresolvablePlaceholders：指示是否忽略不可解析的佔位符（true）或丟擲異常（false）

建構式如下：

1.    public PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix,
2.            @Nullable String valueSeparator, boolean ignoreUnresolvablePlaceholders) {
3.  
4.        Assert.notNull(placeholderPrefix, "'placeholderPrefix' must not be null");
5.        Assert.notNull(placeholderSuffix, "'placeholderSuffix' must not be null");
6.        this.placeholderPrefix = placeholderPrefix;
7.        this.placeholderSuffix = placeholderSuffix;
8.        String simplePrefixForSuffix = wellKnownSimplePrefixes.get(this.placeholderSuffix);
9.        if (simplePrefixForSuffix != null && this.placeholderPrefix.endsWith(simplePrefixForSuffix)) {
10.            this.simplePrefix = simplePrefixForSuffix;
11.        }
12.        else {
13.            this.simplePrefix = this.placeholderPrefix;
14.        }
15.        this.valueSeparator = valueSeparator;
16.        this.ignoreUnresolvablePlaceholders = ignoreUnresolvablePlaceholders;
17.    }

就 PropertySourcesPropertyResolver 而言，其父類 AbstractPropertyResolver 已經對上述四個值做了定義：placeholderPrefix 為 ${，placeholderSuffix 為 }，valueSeparator 為 :，ignoreUnresolvablePlaceholders 預設為 false，當然我們也可以使用相應的 setter 方法自定義。

呼叫 PropertyPlaceholderHelper 的 replacePlaceholders() 對佔位符進行處理，該方法接收兩個引數，一個是待解析的字串 value ，一個是 PlaceholderResolver 型別的 placeholderResolver，他是定義佔位符解析的策略類。如下：

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

內部委託給 parseStringValue() 實現：

1.    protected String parseStringValue(
2.            String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
3.  
4.        StringBuilder result = new StringBuilder(value);
5.  
6.        // 檢索字首，${
7.        int startIndex = value.indexOf(this.placeholderPrefix);
8.        while (startIndex != -1) {
9.            // 檢索字尾 ,}
10.            int endIndex = findPlaceholderEndIndex(result, startIndex);
11.            if (endIndex != -1) {
12.                // 字首和字尾之間的字串
13.                String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
14.                String originalPlaceholder = placeholder;
15.                // 迴圈佔位符
16.                // 判斷該佔位符是否已經處理了
17.                if (!visitedPlaceholders.add(originalPlaceholder)) {
18.                    throw new IllegalArgumentException(
19.                            "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
20.                }
21.                // 遞迴呼叫，解析佔位符
22.                placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
23.                // 獲取值
24.                String propVal = placeholderResolver.resolvePlaceholder(placeholder);
25.                // propval 為空，則提取預設值
26.                if (propVal == null && this.valueSeparator != null) {
27.                    int separatorIndex = placeholder.indexOf(this.valueSeparator);
28.                    if (separatorIndex != -1) {
29.                        String actualPlaceholder = placeholder.substring(0, separatorIndex);
30.                        String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
31.                        propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
32.                        if (propVal == null) {
33.                            propVal = defaultValue;
34.                        }
35.                    }
36.                }
37.                if (propVal != null) {
38.                    // 遞迴呼叫，解析先前解析的佔位符值中包含的佔位符
39.                    propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
40.                    result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
41.                    if (logger.isTraceEnabled()) {
42.                        logger.trace("Resolved placeholder '" + placeholder + "'");
43.                    }
44.                    startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
45.                }
46.                else if (this.ignoreUnresolvablePlaceholders) {
47.                    // Proceed with unprocessed value.
48.                    startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
49.                }
50.                else {
51.                    throw new IllegalArgumentException("Could not resolve placeholder '" +
52.                            placeholder + "'" + " in value \"" + value + "\"");
53.                }
54.                //
55.                visitedPlaceholders.remove(originalPlaceholder);
56.            }
57.            else {
58.                startIndex = -1;
59.            }
60.        }
61.  
62.        return result.toString();
63.    }

其實就是獲取佔位符 ${} 中間的值，這裡面會涉及到一個遞迴的過程，因為可能會存在這種情況 ${${name}}。

convertValueIfNecessary()

該方法是不是感覺到非常的熟悉，該方法就是完成型別轉換的。如下：

1.    protected <T> T convertValueIfNecessary(Object value, @Nullable Class<T> targetType) {
2.        if (targetType == null) {
3.            return (T) value;
4.        }
5.        ConversionService conversionServiceToUse = this.conversionService;
6.        if (conversionServiceToUse == null) {
7.            // Avoid initialization of shared DefaultConversionService if
8.            // no standard type conversion is needed in the first place...
9.            if (ClassUtils.isAssignableValue(targetType, value)) {
10.                return (T) value;
11.            }
12.            conversionServiceToUse = DefaultConversionService.getSharedInstance();
13.        }
14.        return conversionServiceToUse.convert(value, targetType);
15.    }

首先獲取型別轉換服務 conversionService ，若為空，則判斷是否可以透過反射來設定，如果可以則直接強轉傳回，否則構造一個 DefaultConversionService 實體，最後呼叫其 convert() 完成型別轉換，後續就是 Spring 型別轉換體系的事情了，如果對其不瞭解，可以參考小編這篇部落格：【死磕 Spring】—– IOC 之深入分析 Bean 的型別轉換體系

Environment

表示當前應用程式正在執行的環境

應用程式的環境有兩個關鍵方面：profile 和 properties。

• properties 的方法由 PropertyResolver 定義。
• profile 則表示當前的執行環境，對於應用程式中的 properties 而言，並不是所有的都會載入到系統中，只有其屬性與 profile 一直才會被啟用載入，

所以 Environment 物件的作用是確定哪些配置檔案（如果有）當前處於活動狀態，以及預設情況下哪些配置檔案（如果有）應處於活動狀態。properties 在幾乎所有應用程式中都發揮著重要作用，並且有多種來源：屬性檔案，JVM 系統屬性，系統環境變數，JNDI，servlet 背景關係引數，ad-hoc 屬性物件，對映等。同時它繼承 PropertyResolver 介面，所以與屬性相關的 Environment 物件其主要是為使用者提供方便的服務介面，用於配置屬性源和從中屬性源中解析屬性。

1. public interface Environment extends PropertyResolver {
2.    // 傳回此環境下啟用的配置檔案集
3.    String[] getActiveProfiles();
4.  
5.    // 如果未設定啟用配置檔案，則傳回預設的啟用的配置檔案集
6.    String[] getDefaultProfiles();
7.  
8.    boolean acceptsProfiles(String... profiles);
9. }

Environment 體系結構圖如下：

• PropertyResolver：提供屬性訪問功能
• Environment：提供訪問和判斷 profiles 的功能
• ConfigurableEnvironment：提供設定啟用的 profile 和預設的 profile 的功能以及操作 Properties 的工具
• ConfigurableWebEnvironment：提供配置 Servlet 背景關係和 Servlet 引數的功能
• AbstractEnvironment：實現了 ConfigurableEnvironment 介面，預設屬性和儲存容器的定義，並且實現了 ConfigurableEnvironment 的方法，並且為子類預留可改寫了擴充套件方法
• StandardEnvironment：繼承自 AbstractEnvironment ，非 Servlet(Web) 環境下的標準 Environment 實現
• StandardServletEnvironment：繼承自 StandardEnvironment ，Servlet(Web) 環境下的標準 Environment 實現

ConfigurableEnvironment

提供設定啟用的 profile 和預設的 profile 的功能以及操作 Properties 的工具

該類除了繼承 Environment 介面外還繼承了 ConfigurablePropertyResolver 介面，所以它即具備了設定 profile 的功能也具備了操作 Properties 的功能。同時還允許客戶端透過它設定和驗證所需要的屬性，自定義轉換服務等功能。如下：

1. public interface ConfigurableEnvironment extends Environment, ConfigurablePropertyResolver {
2.    // 指定該環境下的 profile 集
3.    void setActiveProfiles(String... profiles);
4.  
5.    // 增加此環境的 profile
6.    void addActiveProfile(String profile);
7.  
8.    // 設定預設的 profile
9.    void setDefaultProfiles(String... profiles);
10.  
11.    // 傳回此環境的 PropertySources
12.    MutablePropertySources getPropertySources();
13.  
14.   // 嘗試傳回 System.getenv() 的值，若失敗則傳回透過 System.getenv(string) 的來訪問各個鍵的對映
15.    Map<String, Object> getSystemEnvironment();
16.  
17.    // 嘗試傳回 System.getProperties() 的值，若失敗則傳回透過 System.getProperties(string) 的來訪問各個鍵的對映
18.    Map<String, Object> getSystemProperties();
19.  
20.    void merge(ConfigurableEnvironment parent);
21. }

AbstractEnvironment

Environment 的基礎實現

允許透過設定 ACTIVEPROFILESPROPERTYNAME 和DEFAULTPROFILESPROPERTYNAME 屬性指定活動和預設配置檔案。子類的主要區別在於它們預設新增的 PropertySource 物件。而 AbstractEnvironment 則沒有新增任何內容。子類應該透過受保護的 customizePropertySources(MutablePropertySources) 鉤子提供屬性源，而客戶端應該使用 ConfigurableEnvironment.getPropertySources()進行自定義並對MutablePropertySources API進行操作。

在 AbstractEnvironment 有兩對變數，這兩對變數維護著啟用和預設配置 profile。如下：

1. public static final String ACTIVE_PROFILES_PROPERTY_NAME = "spring.profiles.active";
2. private final Set<String> activeProfiles = new LinkedHashSet<>();
3.  
4. public static final String DEFAULT_PROFILES_PROPERTY_NAME = "spring.profiles.default";
5. private final Set<String> defaultProfiles = new LinkedHashSet<>(getReservedDefaultProfiles());

由於實現方法較多，這裡只關註兩個方法： setActiveProfiles() 和 getActiveProfiles()。

setActiveProfiles()

1.    public void setActiveProfiles(String... profiles) {
2.        Assert.notNull(profiles, "Profile array must not be null");
3.        if (logger.isDebugEnabled()) {
4.            logger.debug("Activating profiles " + Arrays.asList(profiles));
5.        }
6.        synchronized (this.activeProfiles) {
7.            this.activeProfiles.clear();
8.            for (String profile : profiles) {
9.                validateProfile(profile);
10.                this.activeProfiles.add(profile);
11.            }
12.        }
13.    }

該方法其實就是操作 activeProfiles 集合，在每次設定之前都會將該集合清空重新新增，新增之前呼叫 validateProfile() 對新增的 profile 進行校驗，如下：

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

這個校驗過程比較弱，子類可以提供更加嚴格的校驗規則。

getActiveProfiles()

從 getActiveProfiles() 中我們可以猜出這個方法實現的邏輯：獲取 activeProfiles 集合即可。

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

委託給 doGetActiveProfiles() 實現：

1.    protected Set<String> doGetActiveProfiles() {
2.        synchronized (this.activeProfiles) {
3.            if (this.activeProfiles.isEmpty()) {
4.                String profiles = getProperty(ACTIVE_PROFILES_PROPERTY_NAME);
5.                if (StringUtils.hasText(profiles)) {
6.                    setActiveProfiles(StringUtils.commaDelimitedListToStringArray(
7.                            StringUtils.trimAllWhitespace(profiles)));
8.                }
9.            }
10.            return this.activeProfiles;
11.        }
12.    }

如果 activeProfiles 為空，則從 Properties 中獲取 spring.profiles.active 配置，如果不為空，則呼叫 setActiveProfiles() 設定 profile，最後傳回。

到這裡整個環境&屬性已經分析完畢了，至於在後面他是如何與應用背景關係結合的，我們後面分析。