【Spring】@PropertySource配置的用法與實現原理（十一）

一、@PropertySource功能

• 加載指定的屬性文件（*.properties）到 Spring 的 Environment 中。可以配合 @Value 和@ConfigurationProperties 使用。

• @PropertySource 和 @Value 組合使用，可以將自定義屬性文件中的屬性變量值注入到當前類的使用@Value注解的成員變量中。

• @PropertySource 和 @ConfigurationProperties 組合使用，可以將屬性文件與一個Java類綁定，將屬性文件中的變量值注入到該Java類的成員變量中。

二、@PropertySource源碼

package org.springframework.context.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.core.io.support.PropertySourceFactory;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(PropertySources.class)
public @interface PropertySource {

    /**
     * 屬性源的名稱
     */
    String name() default "";

    /**
     * 屬性文件的存放路徑
     */
    String[] value();

    /**
     * 如果指定的屬性源不存在，是否要忽略這個錯誤
     */
    boolean ignoreResourceNotFound() default false;

    /**
     * 屬性源的編碼格式
     */
    String encoding() default "";

    /**
     * 屬性源工廠
     */
    Class<? extends PropertySourceFactory> factory() default PropertySourceFactory.class;

}

三、使用示例

　　屬性文件：person.properties

person.name=小白
person.age=18

1、@PropertySource + @Value

@Component
@PropertySource(value = {"person.properties"})
public class Person {

    @Value("${person.name}")
    private String name;

    @Value("${person.age}")
    private int age;


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +'\'' +
                '}';
    }
}

2、 @PropertySource 和 @ConfigurationProperties

　　注意@ConfigurationProperties在SpringBoot中才有的注解

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource(value = {"person.properties"})
@ConfigurationProperties(prefix = "person")
public class Person2 {

    private String name;

    private int age;


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +'\'' +
                '}';
    }
} 

四、實現原理

1、解析，當Spring容器初始化的時候，內置對象ConfigurationClassParser，會對配置類進行解析。

 　　ConfigurationClassParser#parse() -> processConfigurationClass() -> doProcessConfigurationClass() -> processPropertySource()

　 processPropertySource() 解析Class上的@PropertySource注解

// 處理每一個屬性源，最終加入到環境上下文里面去~
private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
    // 獲取 propertySource 注解 name的值
    String name = propertySource.getString("name");
    if (!StringUtils.hasLength(name)) {
        name = null;
    }
    // 獲取 propertySource 注解 encoding 的編碼
    String encoding = propertySource.getString("encoding");
    if (!StringUtils.hasLength(encoding)) {
        encoding = null;
    }
    // 獲取 propertySource 注解 value 的值
    String[] locations = propertySource.getStringArray("value");
    Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
    // 獲取 ignoreResourceNotFound 注解 ignoreResourceNotFound 的值 默認：false
    boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");

    // 獲取 ignoreResourceNotFound 注解 factory 的值 默認：PropertySourceFactory.class
    Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
    PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
            DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));

    // 遍歷位置路徑
    for (String location : locations) {
        try {
            // 根據環境解析路徑
            String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
            // 處理好占位符后，獲取資源
            Resource resource = this.resourceLoader.getResource(resolvedLocation);
            // 添加屬性源
            addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
        } catch (IllegalArgumentException | FileNotFoundException | UnknownHostException ex) {
            // Placeholders not resolvable or resource not found when trying to open it
            if (ignoreResourceNotFound) {
                if (logger.isInfoEnabled()) {
                    logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
                }
            } else {
                throw ex;
            }
        }
    }
}

 2、添加到環境屬性源集中

private void addPropertySource(PropertySource<?> propertySource) {
    String name = propertySource.getName();
    // 從環境里把MutablePropertySources拿出來，准備向里面添加
    MutablePropertySources propertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
    // 判斷解析器中的屬性源名單是否包含 此屬性源

    // 這里有個暖心的處理：若出現同名的配置文件，它會兩個都保存着，聯合形成一個CompositePropertySource  這樣它哥倆就都會生效了
    // 否則MutablePropertySources 的Map里面的name是不能同名的，我覺得這個做法還是很暖心的~~~
    if (this.propertySourceNames.contains(name)) {
        // We've already added a version, we need to extend it
        // 我們已經添加了一個版本，我們需要擴展它
        PropertySource<?> existing = propertySources.get(name);
        // 是否已經存在相同名的屬性源
        if (existing != null) {
            // 根據屬性源 是否是 資源屬性源 ，獲取一個新源
            PropertySource<?> newSource = (propertySource instanceof ResourcePropertySource ?
                    ((ResourcePropertySource) propertySource).withResourceName() : propertySource);
            // 已經存在的屬性源，是否屬於 組合屬性源
            if (existing instanceof CompositePropertySource) {
                // 屬於組合屬性源
                // 添加到集合第一位
                ((CompositePropertySource) existing).addFirstPropertySource(newSource);
            } else {
                if (existing instanceof ResourcePropertySource) {
                    existing = ((ResourcePropertySource) existing).withResourceName();
                }
                // 創建一個組合屬性源
                CompositePropertySource composite = new CompositePropertySource(name);
                // 后添加的反而在最上面的~~~ 已經存在會被擠下來一個位置
                composite.addPropertySource(newSource);
                composite.addPropertySource(existing);
                // 把已經存在的這個name替換成composite組合的
                propertySources.replace(name, composite);
            }
            return;
        }
    }
    // 解析器屬性源名單為空
    if (this.propertySourceNames.isEmpty()) {
        // 添加到環境屬性源集中
        propertySources.addLast(propertySource);
    } else {
        // 若你不是第一個，那就把你放在已經導入過的最后一個的前一個里面
        // 獲取名單最后一個
        String firstProcessed = this.propertySourceNames.get(this.propertySourceNames.size() - 1);
        // 在最后一個前面插入
        propertySources.addBefore(firstProcessed, propertySource);
    }
    // 添加到解析器屬性源名單中
    this.propertySourceNames.add(name);
}

3、之后，在對象初始化完成，復制賦值時，

　　populateBean() -> AutowiredAnnotationBeanPostProcessor對象后置處理 -> postProcessProperties()后置處理屬性

@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
    // 注入元信息，找到自動注入的元信息
    InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
    try {
        // 調用 metadata 注入方法
        metadata.inject(bean, beanName, pvs);
    }
    catch (BeanCreationException ex) {
        throw ex;
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
    }
    return pvs;
}

 

　　metadata.inject() 方法中，通過解析@Value注解，拿到@Value注解的key值，拿到key之后，由上下文環境對象中，通過解析環境中存在的環境屬性源集，獲取到key所對應的值，然后使用反射的原理，給對象屬性進行賦值

四、@PropertySource原理圖

　　

　　重點是那個紫色虛線

參考：https://blog.csdn.net/qq_37312838/article/details/108237678