Spring Boot 源码分析 —— @ConfigurationProperties

1. 概述

本文我们来分享 @ConfigurationProperties 注解，如何将配置文件自动设置到被注解的类。代码如下：

 

// ConfigurationProperties.java

/**
 * Annotation for externalized configuration. Add this to a class definition or a
 * {@code @Bean} method in a {@code @Configuration} class if you want to bind and validate
 * some external Properties (e.g. from a .properties file).
 * <p>
 * Note that contrary to {@code @Value}, SpEL expressions are not evaluated since property
 * values are externalized.
 *
 * @author Dave Syer
 * @see ConfigurationPropertiesBindingPostProcessor
 * @see EnableConfigurationProperties
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface ConfigurationProperties {

    /**
     * The name prefix of the properties that are valid to bind to this object. Synonym
     * for {@link #prefix()}. A valid prefix is defined by one or more words separated
     * with dots (e.g. {@code "acme.system.feature"}).
     *
     * @return the name prefix of the properties to bind
     */
    @AliasFor("prefix")
    String value() default "";

    /**
     * The name prefix of the properties that are valid to bind to this object. Synonym
     * for {@link #value()}. A valid prefix is defined by one or more words separated with
     * dots (e.g. {@code "acme.system.feature"}).
     *
     * @return the name prefix of the properties to bind
     */
    @AliasFor("value")
    String prefix() default "";

    /**
     * Flag to indicate that when binding to this object invalid fields should be ignored.
     * Invalid means invalid according to the binder that is used, and usually this means
     * fields of the wrong type (or that cannot be coerced into the correct type).
     *
     * @return the flag value (default false)
     */
    boolean ignoreInvalidFields() default false;

    /**
     * Flag to indicate that when binding to this object unknown fields should be ignored.
     * An unknown field could be a sign of a mistake in the Properties.
     *
     * @return the flag value (default true)
     */
    boolean ignoreUnknownFields() default true;

}

 

@ConfigurationProperties 注解有两种使用方法，可见 《关与 @EnableConfigurationProperties 注解》 文章。总结来说：

• 第一种，@Component + @ConfigurationProperties 。
• 第二种，@EnableConfigurationProperties + ConfigurationProperties 。

实际情况下，更多的是使用第一种。当然，第二种的 @EnableConfigurationProperties 的效果，也是将指定的类，实现和 @Component 被注解的类是一样的，创建成 Bean 对象。
这样，@ConfigurationProperties 就可以将配置文件自动设置到该 Bean 对象咧。

2. @EnableConfigurationProperties

org.springframework.boot.context.properties.@EnableConfigurationProperties 注解，可以将指定带有 @ConfigurationProperties 的类，注册成 BeanDefinition ，从而创建成 Bean 对象。代码如下：

 

// EnableConfigurationProperties.java

/**
 * Enable support for {@link ConfigurationProperties} annotated beans.
 * {@link ConfigurationProperties} beans can be registered in the standard way (for
 * example using {@link Bean @Bean} methods) or, for convenience, can be specified
 * directly on this annotation.
 *
 * @author Dave Syer
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(EnableConfigurationPropertiesImportSelector.class)
public @interface EnableConfigurationProperties {

	/**
     * 指定的类们
     *
	 * Convenient way to quickly register {@link ConfigurationProperties} annotated beans
	 * with Spring. Standard Spring Beans will also be scanned regardless of this value.
	 * @return {@link ConfigurationProperties} annotated beans to register
	 */
	Class<?>[] value() default {};

}

 

• 从 @Import 注解上，可以看到使用 EnableConfigurationPropertiesImportSelector 处理。详细的解析，见 「2.2 EnableConfigurationPropertiesImportSelector」 。

2.1 ConfigurationPropertiesAutoConfiguration

默认情况下，@EnableConfigurationProperties 会通过 org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration 类，进行开启。代码如下：

 

// ConfigurationPropertiesAutoConfiguration.java

/**
 * {@link EnableAutoConfiguration Auto-configuration} for {@link ConfigurationProperties}
 * beans. Automatically binds and validates any bean annotated with
 * {@code @ConfigurationProperties}.
 *
 * @author Stephane Nicoll
 * @since 1.3.0
 * @see EnableConfigurationProperties
 * @see ConfigurationProperties
 */
@Configuration
@EnableConfigurationProperties // <X>
public class ConfigurationPropertiesAutoConfiguration {
}

 

• 看，看看，看看看，<X> 哟~

2.2 EnableConfigurationPropertiesImportSelector

org.springframework.boot.context.properties.EnableConfigurationPropertiesImportSelector ，实现 ImportSelector 接口，处理 @EnableConfigurationProperties 注解。代码如下：

 

// EnableConfigurationPropertiesImportSelector.java

private static final String[] IMPORTS = {
		ConfigurationPropertiesBeanRegistrar.class.getName(),
		ConfigurationPropertiesBindingPostProcessorRegistrar.class.getName() };

@Override
public String[] selectImports(AnnotationMetadata metadata) {
	return IMPORTS;
}

 

• 返回的 IMPORTS 的是两个 ImportBeanDefinitionRegistrar 实现类。分别是：
  • ConfigurationPropertiesBeanRegistrar ，在 「2.3 ConfigurationPropertiesBeanRegistrar」 中详细解析。
  • ConfigurationPropertiesBindingPostProcessorRegistrar ，在 「2.4 ConfigurationPropertiesBindingPostProcessorRegistrar」 中详细解析。

2.3 ConfigurationPropertiesBeanRegistrar

ConfigurationPropertiesBeanRegistrar ，是 EnableConfigurationPropertiesImportSelector 的内部静态类，实现 ImportBeanDefinitionRegistrar 接口，将 @EnableConfigurationProperties 注解指定的类，逐个注册成对应的 BeanDefinition 对象。代码如下：

 

// EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
    getTypes(metadata) // <1>
            .forEach((type) -> register(registry, (ConfigurableListableBeanFactory) registry, type)); // <2>
}

 

• <1> 处，调用 #getTypes(AnnotationMetadata metadata) 方法，获得 @EnableConfigurationProperties 注解指定的类的数组。代码如下：

  // EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java
  
  private List<Class<?>> getTypes(AnnotationMetadata metadata) {
      // 获得 @EnableConfigurationProperties 注解
      MultiValueMap<String, Object> attributes = metadata.getAllAnnotationAttributes(EnableConfigurationProperties.class.getName(), false);
      // 获得 value 属性
      return collectClasses((attributes != null) ? attributes.get("value")
              : Collections.emptyList());
  }
  
  private List<Class<?>> collectClasses(List<?> values) {
      return values.stream().flatMap((value) -> Arrays.stream((Object[]) value))
              .map((o) -> (Class<?>) o).filter((type) -> void.class != type)
              .collect(Collectors.toList());
  }

   

  • ~

• <2> 处，遍历，逐个调用 #register(BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory, Class<?> type) 方法，注册每个类对应的 BeanDefinition 对象。代码如下：

   

  // EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java
  
  private void register(BeanDefinitionRegistry registry, ConfigurableListableBeanFactory beanFactory, Class<?> type) {
      // <2.1> 通过 @ConfigurationProperties 注解，获得最后要生成的 BeanDefinition 的名字。格式为 prefix-类全名 or 类全名
      String name = getName(type);
      // <2.2> 判断是否已经有该名字的 BeanDefinition 的名字。没有，才进行注册
      if (!containsBeanDefinition(beanFactory, name)) {
          registerBeanDefinition(registry, name, type); // <2.3> 
      }
  }

   

  • <2.1> 处，调用 #getName(Class<?> type) 方法，通过 @ConfigurationProperties 注解，获得最后要生成的 BeanDefinition 的名字。代码如下：

    // EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java
    
    private String getName(Class<?> type) {
        ConfigurationProperties annotation = AnnotationUtils.findAnnotation(type, ConfigurationProperties.class);
        String prefix = (annotation != null) ? annotation.prefix() : "";
        return (StringUtils.hasText(prefix) ? prefix + "-" + type.getName() : type.getName());
    }

     

    • 格式为 prefix-类全名 or 类全名。

  • <2.2> 处，调用 #containsBeanDefinition(ConfigurableListableBeanFactory beanFactory, String name) 方法，判断是否已经有该名字的 BeanDefinition 的名字。代码如下：

    // EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java
    
    private boolean containsBeanDefinition(ConfigurableListableBeanFactory beanFactory, String name) {
        // 判断是否存在 BeanDefinition 。如果有，则返回 true
        if (beanFactory.containsBeanDefinition(name)) {
            return true;
        }
        // 获得父容器，判断是否存在
        BeanFactory parent = beanFactory.getParentBeanFactory();
        if (parent instanceof ConfigurableListableBeanFactory) {
            return containsBeanDefinition((ConfigurableListableBeanFactory) parent, name);
        }
        // 返回 false ，说明不存在
        return false;
    }

     

    • 如果不存在，才执行后续的注册 BeanDefinition 逻辑。

  • <2.3> 处，调用 #registerBeanDefinition(BeanDefinitionRegistry registry, String name, Class<?> type) 方法，注册 BeanDefinition 。代码如下：

    // EnableConfigurationPropertiesImportSelector#ConfigurationPropertiesBeanRegistrar.java
    
    private void registerBeanDefinition(BeanDefinitionRegistry registry, String name, Class<?> type) {
        // 断言，判断该类有 @ConfigurationProperties 注解
        assertHasAnnotation(type);
        // 创建 GenericBeanDefinition 对象
        GenericBeanDefinition definition = new GenericBeanDefinition();
        definition.setBeanClass(type);
        // 注册到 BeanDefinitionRegistry 中
        registry.registerBeanDefinition(name, definition);
    }
    
    private void assertHasAnnotation(Class<?> type) {
        Assert.notNull(
                AnnotationUtils.findAnnotation(type, ConfigurationProperties.class),
                () -> "No " + ConfigurationProperties.class.getSimpleName()
                        + " annotation found on  '" + type.getName() + "'.");
    }

     

    • ~

2.4 ConfigurationPropertiesBindingPostProcessorRegistrar

org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessorRegistrar ，实现 ImportBeanDefinitionRegistrar 接口，代码如下：

 

// ConfigurationPropertiesBindingPostProcessorRegistrar.java

@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    if (!registry.containsBeanDefinition(ConfigurationPropertiesBindingPostProcessor.BEAN_NAME)) {
        // <1> 注册 ConfigurationPropertiesBindingPostProcessor BeanDefinition
        registerConfigurationPropertiesBindingPostProcessor(registry);
        // <2> 注册 ConfigurationBeanFactoryMetadata BeanDefinition
        registerConfigurationBeanFactoryMetadata(registry);
    }
}

 

• <1> 处，调用 #registerConfigurationPropertiesBindingPostProcessor(BeanDefinitionRegistry registry) 方法，注册 ConfigurationPropertiesBindingPostProcessor BeanDefinition 。代码如下：

  // ConfigurationPropertiesBindingPostProcessorRegistrar.java
  
  private void registerConfigurationPropertiesBindingPostProcessor(BeanDefinitionRegistry registry) {
      // 创建 GenericBeanDefinition 对象
      GenericBeanDefinition definition = new GenericBeanDefinition();
      definition.setBeanClass(ConfigurationPropertiesBindingPostProcessor.class);
      definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
      // 注册
      registry.registerBeanDefinition(ConfigurationPropertiesBindingPostProcessor.BEAN_NAME, definition);
  }

   

  • 关于 ConfigurationPropertiesBindingPostProcessor 类，我们在 「4. ConfigurationPropertiesBindingPostProcessor 相关」 中，详细解析。

• <2> 处，调用 #registerConfigurationBeanFactoryMetadata(BeanDefinitionRegistry registry) 方法，注册 ConfigurationBeanFactoryMetadata BeanDefinition 。代码如下：

  // ConfigurationPropertiesBindingPostProcessorRegistrar.java
  
  private void registerConfigurationBeanFactoryMetadata(BeanDefinitionRegistry registry) {
      // 创建 GenericBeanDefinition 对象
      GenericBeanDefinition definition = new GenericBeanDefinition();
      definition.setBeanClass(ConfigurationBeanFactoryMetadata.class);
      definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
      // 注册
      registry.registerBeanDefinition(ConfigurationBeanFactoryMetadata.BEAN_NAME, definition);
  }

   

  • 关于 ConfigurationBeanFactoryMetadata 类，我们在 「3. ConfigurationBeanFactoryMetadata」 中，详细解析。

3. ConfigurationBeanFactoryMetadata

org.springframework.boot.context.properties.ConfigurationBeanFactoryMetadata ，初始化配置类创建 Bean 的每个方法的元数据。

3.1 postProcessBeanFactory

实现 #postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法，代码如下：

 

// ConfigurationBeanFactoryMetadata.java

private ConfigurableListableBeanFactory beanFactory;

/**
 * FactoryMetadata 的映射
 *
 * KEY ：Bean 的名字
 */
private final Map<String, FactoryMetadata> beansFactoryMetadata = new HashMap<>();

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    // <1> 初始化 beanFactory 属性
    this.beanFactory = beanFactory;
    // <2> 遍历所有的 BeanDefinition 的名字们
    for (String name : beanFactory.getBeanDefinitionNames()) {
        // <2.1> 获得 BeanDefinition 对象
        BeanDefinition definition = beanFactory.getBeanDefinition(name);
        // <2.2> 获得 method、bean 属性
        String method = definition.getFactoryMethodName();
        String bean = definition.getFactoryBeanName();
        // <2.3> 添加到 beansFactoryMetadata 中
        if (method != null && bean != null) {
            this.beansFactoryMetadata.put(name, new FactoryMetadata(bean, method));
        }
    }
}

 

• <1> 处，初始化 beanFactory 属性。

• <2> 处，遍历所有的 BeanDefinition 的名字们，初始化 beansFactoryMetadata 属性。

• <2.1> 处，获得 BeanDefinition 对象。

• <2.2> 处，获得 BeanDefinition 的 factoryMethodName、factoryBeanName 属性。

  • factoryBeanName 属性，是创建该 Bean 的工厂 Bean 的名字。

  • factoryMethodName 属性，是创建 Bean 的工厂 Bean 的方法名。

  • 以如下的 Configuration 类，举个例子：

    @Configuration
    public class TestConfiguration {
    
        @Bean
        public Object testObject() {
            return new Object();
        }
    
    }

     

    • 每个 @Bean 注解的方法，都是一个 factoryBeanName + factoryMethodName 。
    • factoryBeanName 属性，为 "testConfiguration" 。
    • factoryMethodName 属性，为 "testObject" 。

• <2.3> 处，都非空的情况下，添加到 beansFactoryMetadata 中。

• FactoryMetadata 是 ConfigurationBeanFactoryMetadata 的内部静态类。代码如下：

  // ConfigurationBeanFactoryMetadata#FactoryMetadata.java
  
  private static class FactoryMetadata {
  
      /**
       * Bean 的名字
       */
      private final String bean;
      /**
       * Bean 的方法名
       */
      private final String method;
  
      // ... 省略 setting / getting  方法
  
  }

   

3.2 findFactoryMethod

#findFactoryMethod(String beanName) 方法，获得指定 Bean 的创建方法。代码如下：

 

// ConfigurationBeanFactoryMetadata.java

public Method findFactoryMethod(String beanName) {
    // 如果不存在，则返回 null
    if (!this.beansFactoryMetadata.containsKey(beanName)) {
        return null;
    }
    AtomicReference<Method> found = new AtomicReference<>(null);
    // 获得 beanName 对应的 FactoryMetadata 对象
    FactoryMetadata metadata = this.beansFactoryMetadata.get(beanName);
    // 获得对应的工厂类
    Class<?> factoryType = this.beanFactory.getType(metadata.getBean());
    if (ClassUtils.isCglibProxyClass(factoryType)) {
        factoryType = factoryType.getSuperclass();
    }
    // 获得对应的工厂类的方法
    String factoryMethod = metadata.getMethod();
    ReflectionUtils.doWithMethods(factoryType, (method) -> {
        if (method.getName().equals(factoryMethod)) {
            found.compareAndSet(null, method);
        }
    });
    return found.get();
}

 

3.3 findFactoryAnnotation

#findFactoryAnnotation(String beanName, Class<A> type) 方法，获得指定 Bean 的创建方法上的注解。代码如下：

 

// ConfigurationBeanFactoryMetadata.java

public <A extends Annotation> A findFactoryAnnotation(String beanName, Class<A> type) {
    // 获得方法
    Method method = findFactoryMethod(beanName);
    // 获得注解
    return (method != null) ? AnnotationUtils.findAnnotation(method, type) : null;
}

 

3.4 getBeansWithFactoryAnnotation

#getBeansWithFactoryAnnotation(Class<A> type) 方法，获得 beansFactoryMetadata 中的每个 Bean 的方法上的指定注解。代码如下：

 

// ConfigurationBeanFactoryMetadata.java

public <A extends Annotation> Map<String, Object> getBeansWithFactoryAnnotation(Class<A> type) {
    Map<String, Object> result = new HashMap<>();
    // 遍历 beansFactoryMetadata
    for (String name : this.beansFactoryMetadata.keySet()) {
        // 获得每个 Bean 的创建方法上的注解
        if (findFactoryAnnotation(name, type) != null) {
            result.put(name, this.beanFactory.getBean(name));
        }
    }
    return result;
}

 

分享到：

Spring Boot 源码分析 —— BeanDefinitio ... | Spring Boot 源码分析 —— 日志系统

• 2019-08-17 16:07
• 浏览 749
• 评论(0)
• 分类:编程语言
• 查看更多