Spring PropertySources

MutablePropertySources

  • 全路径: org.springframework.core.env.MutablePropertySources

  • MutablePropertySources类内部存储了List<PropertySource<?>>对象,主要是针对List<PropertySource<?>> 进行的操作.换句话说就是对 list 操作的实现

  • 类注解如下

  1. public class MutablePropertySources implements PropertySources {
  3.    private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();
  6.    /**
  7.     * Create a new {@link MutablePropertySources} object.
  8.     *
  9.     * 构造方法
  10.     */
  11.    public MutablePropertySources() {
  12.    }
  14.    /**
  15.     * Create a new {@code MutablePropertySources} from the given propertySources
  16.     * object, preserving the original order of contained {@code PropertySource} objects.
  17.     * 构造方法, 传递一个集合, 将集合中的数据放入 {@code propertySourceList}.
  18.     */
  19.    public MutablePropertySources(PropertySources propertySources) {
  20.       this();
  21.       // PropertySources 是一个迭代器接口的实现,通过循环取出信息放入到 propertySourceList 中
  22.       for (PropertySource<?> propertySource : propertySources) {
  23.          // 放入方法
  24.          addLast(propertySource);
  25.       }
  26.    }
  29.    /**
  30.     * 获取迭代器对象
  31.     */
  32.    @Override
  33.    public Iterator<PropertySource<?>> iterator() {
  34.       return this.propertySourceList.iterator();
  35.    }
  37.    /**
  38.     * 获取 Spliterator 对象
  39.     */
  40.    @Override
  41.    public Spliterator<PropertySource<?>> spliterator() {
  42.       return Spliterators.spliterator(this.propertySourceList, 0);
  43.    }
  45.    /**
  46.     * 获取流
  47.     */
  48.    @Override
  49.    public Stream<PropertySource<?>> stream() {
  50.       return this.propertySourceList.stream();
  51.    }
  53.    /**
  54.     * 判断是否存在 name
  55.     * @param name the {@linkplain PropertySource#getName() name of the property source} to find
  56.     */
  57.    @Override
  58.    public boolean contains(String name) {
  59.       return this.propertySourceList.contains(PropertySource.named(name));
  60.    }
  62.    /**
  63.     * 获取 PropertySource 信息
  64.     * @param name the {@linkplain PropertySource#getName() name of the property source} to find
  65.     * @return
  66.     */
  67.    @Override
  68.    @Nullable
  69.    public PropertySource<?> get(String name) {
  70.       // 获取 name 所在的索引位置
  71.       int index = this.propertySourceList.indexOf(PropertySource.named(name));
  72.       // get方法获取结果
  73.       return (index != -1 ? this.propertySourceList.get(index) : null);
  74.    }
  77.    /**
  78.     * Add the given property source object with highest precedence.
  79.     *
  80.     * 头插数据
  81.     */
  82.    public void addFirst(PropertySource<?> propertySource) {
  83.       removeIfPresent(propertySource);
  84.       this.propertySourceList.add(0, propertySource);
  85.    }
  87.    /**
  88.     * Add the given property source object with lowest precedence.
  89.     *
  90.     * 尾插数据
  91.     */
  92.    public void addLast(PropertySource<?> propertySource) {
  93.       removeIfPresent(propertySource);
  94.       this.propertySourceList.add(propertySource);
  95.    }
  97.    /**
  98.     * Add the given property source object with precedence immediately higher
  99.     * than the named relative property source.
  100.     *
  101.     * 在relativePropertySourceName的索引位置前添加数据
  102.     */
  103.    public void addBefore(String relativePropertySourceName, PropertySource<?> propertySource) {
  104.       assertLegalRelativeAddition(relativePropertySourceName, propertySource);
  105.       removeIfPresent(propertySource);
  106.       int index = assertPresentAndGetIndex(relativePropertySourceName);
  107.       addAtIndex(index, propertySource);
  108.    }
  110.    /**
  111.     * Add the given property source object with precedence immediately lower
  112.     * than the named relative property source.
  113.     * 在relativePropertySourceName的索引位置后添加数据
  114.     */
  115.    public void addAfter(String relativePropertySourceName, PropertySource<?> propertySource) {
  116.       assertLegalRelativeAddition(relativePropertySourceName, propertySource);
  117.       // 删除存在的数据
  118.       removeIfPresent(propertySource);
  119.       // 获取所有
  120.       int index = assertPresentAndGetIndex(relativePropertySourceName);
  121.       // 在索引+1出添加数据
  122.       addAtIndex(index + 1, propertySource);
  123.    }
  125.    /**
  126.     * Return the precedence of the given property source, {@code -1} if not found.
  127.     * 获取索引位置
  128.     */
  129.    public int precedenceOf(PropertySource<?> propertySource) {
  130.       return this.propertySourceList.indexOf(propertySource);
  131.    }
  133.    /**
  134.     * Remove and return the property source with the given name, {@code null} if not found.
  135.     * 删除索引位置
  136.     * @param name the name of the property source to find and remove
  137.     */
  138.    @Nullable
  139.    public PropertySource<?> remove(String name) {
  140.       // 获取索引
  141.       int index = this.propertySourceList.indexOf(PropertySource.named(name));
  142.       // 删除索引上的数据
  143.       return (index != -1 ? this.propertySourceList.remove(index) : null);
  144.    }
  146.    /**
  147.     * Replace the property source with the given name with the given property source object.
  148.     * 替换 name 的信息
  149.     * @param name the name of the property source to find and replace
  150.     * @param propertySource the replacement property source
  151.     * @throws IllegalArgumentException if no property source with the given name is present
  152.     * @see #contains
  153.     */
  154.    public void replace(String name, PropertySource<?> propertySource) {
  155.       // 获取索引位置
  156.       int index = assertPresentAndGetIndex(name);
  157.       // 设置具体所应位置的值
  158.       this.propertySourceList.set(index, propertySource);
  159.    }
  161.    /**
  162.     * Return the number of {@link PropertySource} objects contained.
  163.     * 数量
  164.     */
  165.    public int size() {
  166.       return this.propertySourceList.size();
  167.    }
  169.    @Override
  170.    public String toString() {
  171.       return this.propertySourceList.toString();
  172.    }
  174.    /**
  175.     * Ensure that the given property source is not being added relative to itself.
  176.     * 确保两个 PropertySource 的 name不相同
  177.     */
  178.    protected void assertLegalRelativeAddition(String relativePropertySourceName, PropertySource<?> propertySource) {
  179.       // 获取 PropertySource 的名字
  180.       String newPropertySourceName = propertySource.getName();
  181.       // 历史名字和新的名字是否相同
  182.       if (relativePropertySourceName.equals(newPropertySourceName)) {
  183.          throw new IllegalArgumentException(
  184.                "PropertySource named '" + newPropertySourceName + "' cannot be added relative to itself");
  185.       }
  186.    }
  188.    /**
  189.     * Remove the given property source if it is present.
  190.     * 删除已存在的数据
  191.     */
  192.    protected void removeIfPresent(PropertySource<?> propertySource) {
  193.       this.propertySourceList.remove(propertySource);
  194.    }
  196.    /**
  197.     * Add the given property source at a particular index in the list.
  198.     * 指定索引位置插入数据
  199.     */
  200.    private void addAtIndex(int index, PropertySource<?> propertySource) {
  201.       removeIfPresent(propertySource);
  202.       this.propertySourceList.add(index, propertySource);
  203.    }
  205.    /**
  206.     * Assert that the named property source is present and return its index.
  207.     * 获取 name 所在的索引位置
  208.     * @param name {@linkplain PropertySource#getName() name of the property source} to find
  209.     * @throws IllegalArgumentException if the named property source is not present
  210.     */
  211.    private int assertPresentAndGetIndex(String name) {
  212.       int index = this.propertySourceList.indexOf(PropertySource.named(name));
  213.       if (index == -1) {
  214.          throw new IllegalArgumentException("PropertySource named '" + name + "' does not exist");
  215.       }
  216.       return index;
  217.    }
  219. }

PropertySources

  • 类路径: org.springframework.core.env.PropertySources

  • 详细说明如下

  1. public interface PropertySources extends Iterable<PropertySource<?>> {
  3.    /**
  4.     * Return a sequential {@link Stream} containing the property sources.
  5.     * 获取流
  6.     * @since 5.1
  7.     */
  8.    default Stream<PropertySource<?>> stream() {
  9.       return StreamSupport.stream(spliterator(), false);
  10.    }
  12.    /**
  13.     * Return whether a property source with the given name is contained.
  14.     * 判断是否存在 name
  15.     * @param name the {@linkplain PropertySource#getName() name of the property source} to find
  16.     */
  17.    boolean contains(String name);
  19.    /**
  20.     * Return the property source with the given name, {@code null} if not found.
  21.     * 获取 PropertySource
  22.     * @param name the {@linkplain PropertySource#getName() name of the property source} to find
  23.     */
  24.    @Nullable
  25.    PropertySource<?> get(String name);
  27. }

PropertySource

  • 类路径: org.springframework.core.env.PropertySource

  • 存有两个子类

    1. StubPropertySource
    2. ComparisonPropertySource 3. 调用getSource、containsProperty、getProperty 都会直接异常
  1. public abstract class PropertySource<T> {
  3.     protected final Log logger = LogFactory.getLog(getClass());
  5.     /**
  6.      * 属性名称
  7.      */
  8.     protected final String name;
  10.     /**
  11.      * 值
  12.      */
  13.     protected final T source;
  16.     /**
  17.      * Create a new {@code PropertySource} with the given name and source object.
  18.      */
  19.     public PropertySource(String name, T source) {
  20.         Assert.hasText(name, "Property source name must contain at least one character");
  21.         Assert.notNull(source, "Property source must not be null");
  22.         this.name = name;
  23.         this.source = source;
  24.     }
  26.     /**
  27.      * Create a new {@code PropertySource} with the given name and with a new
  28.      * {@code Object} instance as the underlying source.
  29.      * <p>Often useful in testing scenarios when creating anonymous implementations
  30.      * that never query an actual source but rather return hard-coded values.
  31.      */
  32.     @SuppressWarnings("unchecked")
  33.     public PropertySource(String name) {
  34.         this(name, (T) new Object());
  35.     }
  37.     /**
  38.      * Return a {@code PropertySource} implementation intended for collection comparison purposes only.
  39.      * <p>Primarily for internal use, but given a collection of {@code PropertySource} objects, may be
  40.      * used as follows:
  41.      * <pre class="code">
  42.      * {@code List<PropertySource<?>> sources = new ArrayList<PropertySource<?>>();
  43.      * sources.add(new MapPropertySource("sourceA", mapA));
  44.      * sources.add(new MapPropertySource("sourceB", mapB));
  45.      * assert sources.contains(PropertySource.named("sourceA"));
  46.      * assert sources.contains(PropertySource.named("sourceB"));
  47.      * assert !sources.contains(PropertySource.named("sourceC"));
  48.      * }</pre>
  49.      * The returned {@code PropertySource} will throw {@code UnsupportedOperationException}
  50.      * if any methods other than {@code equals(Object)}, {@code hashCode()}, and {@code toString()}
  51.      * are called.
  52.      * @param name the name of the comparison {@code PropertySource} to be created and returned.
  53.      */
  54.     public static PropertySource<?> named(String name) {
  55.         return new ComparisonPropertySource(name);
  56.     }
  58.     /**
  59.      * Return the name of this {@code PropertySource}.
  60.      */
  61.     public String getName() {
  62.         return this.name;
  63.     }
  65.     /**
  66.      * Return the underlying source object for this {@code PropertySource}.
  67.      */
  68.     public T getSource() {
  69.         return this.source;
  70.     }
  72.     /**
  73.      * Return whether this {@code PropertySource} contains the given name.
  74.      * <p>This implementation simply checks for a {@code null} return value
  75.      * from {@link #getProperty(String)}. Subclasses may wish to implement
  76.      * a more efficient algorithm if possible.
  77.      * @param name the property name to find
  78.      */
  79.     public boolean containsProperty(String name) {
  80.         // getProperty 抽象方法子类实现
  81.         return (getProperty(name) != null);
  82.     }
  84.     /**
  85.      * Return the value associated with the given name,
  86.      * or {@code null} if not found.
  87.      * // getProperty 抽象方法子类实现
  88.      * @param name the property to find
  89.      * @see PropertyResolver#getRequiredProperty(String)
  90.      */
  91.     @Nullable
  92.     public abstract Object getProperty(String name);
  94.     /**
  95.      * This {@code PropertySource} object is equal to the given object if:
  96.      * <ul>
  97.      * <li>they are the same instance
  98.      * <li>the {@code name} properties for both objects are equal
  99.      * </ul>
  100.      * <p>No properties other than {@code name} are evaluated.
  101.      */
  102.     @Override
  103.     public boolean equals(@Nullable Object other) {
  104.         return (this == other || (other instanceof PropertySource &&
  105.                 ObjectUtils.nullSafeEquals(this.name, ((PropertySource<?>) other).name)));
  106.     }
  108.     /**
  109.      * Return a hash code derived from the {@code name} property
  110.      * of this {@code PropertySource} object.
  111.      */
  112.     @Override
  113.     public int hashCode() {
  114.         return ObjectUtils.nullSafeHashCode(this.name);
  115.     }
  117.     /**
  118.      * Produce concise output (type and name) if the current log level does not include
  119.      * debug. If debug is enabled, produce verbose output including the hash code of the
  120.      * PropertySource instance and every name/value property pair.
  121.      * <p>This variable verbosity is useful as a property source such as system properties
  122.      * or environment variables may contain an arbitrary number of property pairs,
  123.      * potentially leading to difficult to read exception and log messages.
  124.      * @see Log#isDebugEnabled()
  125.      */
  126.     @Override
  127.     public String toString() {
  128.         if (logger.isDebugEnabled()) {
  129.             return getClass().getSimpleName() + "@" + System.identityHashCode(this) +
  130.                     " {name='" + this.name + "', properties=" + this.source + "}";
  131.         }
  132.         else {
  133.             return getClass().getSimpleName() + " {name='" + this.name + "'}";
  134.         }
  135.     }
  137.     /**
  138.      * {@code PropertySource} to be used as a placeholder in cases where an actual
  139.      * property source cannot be eagerly initialized at application context
  140.      * creation time.  For example, a {@code ServletContext}-based property source
  141.      * must wait until the {@code ServletContext} object is available to its enclosing
  142.      * {@code ApplicationContext}.  In such cases, a stub should be used to hold the
  143.      * intended default position/order of the property source, then be replaced
  144.      * during context refresh.
  145.      * @see org.springframework.context.support.AbstractApplicationContext#initPropertySources()
  146.      * @see org.springframework.web.context.support.StandardServletEnvironment
  147.      * @see org.springframework.web.context.support.ServletContextPropertySource
  148.      */
  149.     public static class StubPropertySource extends PropertySource<Object> {
  151.         public StubPropertySource(String name) {
  152.             super(name, new Object());
  153.         }
  155.         /**
  156.          * Always returns {@code null}.
  157.          */
  158.         @Override
  159.         @Nullable
  160.         public String getProperty(String name) {
  161.             return null;
  162.         }
  163.     }
  166.     /**
  167.      * A {@code PropertySource} implementation intended for collection comparison
  168.      * purposes.
  169.      *
  170.      * @see PropertySource#named(String)
  171.      */
  172.     static class ComparisonPropertySource extends StubPropertySource {
  174.         // 异常信息
  175.         private static final String USAGE_ERROR =
  176.                 "ComparisonPropertySource instances are for use with collection comparison only";
  178.         public ComparisonPropertySource(String name) {
  179.             super(name);
  180.         }
  182.         @Override
  183.         public Object getSource() {
  184.             // 抛异常
  185.             throw new UnsupportedOperationException(USAGE_ERROR);
  186.         }
  188.         @Override
  189.         public boolean containsProperty(String name) {
  190.             // 抛异常
  191.             throw new UnsupportedOperationException(USAGE_ERROR);
  192.         }
  194.         @Override
  195.         @Nullable
  196.         public String getProperty(String name) {
  197.             // 抛异常
  198.             throw new UnsupportedOperationException(USAGE_ERROR);
  199.         }
  200.     }
  202. }

类图

PropertySource.png