Properties in BeanFactoryPostProcessor

1. Overview

In Spring, properties can be injected directly into our beans using the @Value annotation, accessed through the Environment abstraction, or be bound to structured objects through @ConfigurationProperties. If we try to inject Properties in BeanFactoryPostProcessor using these conventional ways, it won’t work! This is because these annotations are processed by BeanPostProcessor, which means they cannot be used within BeanPostProcessor or BeanFactoryPostProcessor types.

In this tutorial, we’ll learn to use the Environment class to inject properties in BeanFactoryPostProcessor. To show how this works with Spring Boot, we’ll use Binder in place of @ConfigurationProperties. Lastly, we’ll demonstrate both options for creating BeanFactoryPostProcessor using the @Bean annotation and the @Component annotation.

2. Properties in BeanFactoryPostProcessor

To inject properties in BeanFactoryPostProcessor, we need to retrieve the Environment object. Then, using this, we can:

• Use the getProperty() method for each property we wish to fetch
• Use Binder and Environment to retrieve the whole ConfigurationFile

The getProperty() method is convenient to get a small number of properties. If we wish to fetch significantly more, it would be simpler to use a ConfigurationFile, assuming that all properties exist in the same file. Note that @ConfigurationFile is a feature of Spring Boot and therefore not available in simple Spring applications.

3. Properties in BeanFactoryPostProcessor Using @Bean Annotation

Let’s now see how we can use the Environment abstraction to get properties when we create a BeanFactoryPostProcessor using the @Bean annotation.

First, we’ll create a configuration file where we’ll define a bean of type BeanFactoryPostProcessor, injecting the Environment as a parameter. Then, we can either use the getProperty() method or a Binder, as shown in the next sections.

3.1. getProperty() Method of Environment

The use of getProperty() is most useful when only a few properties are needed:

@Bean
public static BeanFactoryPostProcessor beanFactoryPostProcessor(Environment environment) {
    return beanFactory -> {
        String articleName = environment.getProperty("article.name", String.class);
        LOGGER.debug("Article name, using environment::getProperty: " + articleName);

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        registry.registerBeanDefinition("articleNameFromBeanAnnotation", BeanDefinitionBuilder.genericBeanDefinition(String.class)
          .addConstructorArgValue(articleName)
          .getBeanDefinition());
    };
}

In the example above, we use environment.getProperty() to get the article.name property and then create a new dummy bean with the name articleNameFromBeanAnnotation to hold its value.

3.2. Binder

We can also combine Binder and Environment to load the whole configuration file. This way, we can leverage the @ConfigurationFile annotation of Spring Boot applications:

@Bean
public static BeanFactoryPostProcessor beanFactoryPostProcessor(Environment environment) {
    return beanFactory -> {
        BindResult<ApplicationProperties> result = Binder.get(environment)
          .bind("application", ApplicationProperties.class);
        ApplicationProperties properties = result.get();
        LOGGER.debug("Application name, using binder to access ApplicationProperties: " + properties.getName());

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        registry.registerBeanDefinition("applicationNameFromBeanAnnotation", BeanDefinitionBuilder.genericBeanDefinition(String.class)
          .addConstructorArgValue(properties.getName())
          .getBeanDefinition());
    };
}

In this example, we use Binder‘s methods get() and bind() to load the configuration file for the current environment. Then, we use the configuration file getters to retrieve the application name. We finally store its value in a dummy bean with the name applicationNameFromBeanAnnotation.

4. Properties in BeanFactoryPostProcessor Using @Component Annotation

Another way to create a BeanFactoryPostProcessor is to use the @Component annotation. In this case, similar to using @Bean annotation, we need the Environment abstraction. The difference is that we can’t inject the Environment because BeanFactoryPostProcessor only comes with a no-arguments constructor. The solution is to use the EnvironmentAware interface to inject the environment:

@Component
public class PropertiesWithBeanFactoryPostProcessor implements BeanFactoryPostProcessor, EnvironmentAware {

    private Environment environment;

    @Override
    public void postProcessBeanFactory(@NonNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
        String articleName = environment.getProperty("article.name", String.class);
        LOGGER.debug("Article name, using environment::getProperty: " + articleName);

        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        registry.registerBeanDefinition("articleNameFromComponentAnnotation", BeanDefinitionBuilder.genericBeanDefinition(String.class)
          .addConstructorArgValue(articleName)
          .getBeanDefinition());
    }

    @Override
    public void setEnvironment(@NonNull Environment environment) {
        this.environment = environment;
    }
}

This provides the method setEnvironment(), which is another way to inject beans in Spring applications. Then, we store the injected value of the Environment in a field. In postProcessBeanFactory(), we can invoke either the getProperty() method or a Binder using the field. In the code above, we used the former.

4.1. getProperty() Method of Environment

We can use the getProperty() method to retrieve a small number of properties:

@Override
public void postProcessBeanFactory(@NonNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
    String articleName = environment.getProperty("article.name", String.class);
    LOGGER.debug("Article name, using environment::getProperty: " + articleName);

    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    registry.registerBeanDefinition("articleNameFromComponentAnnotation", BeanDefinitionBuilder.genericBeanDefinition(String.class)
      .addConstructorArgValue(articleName)
      .getBeanDefinition());
}

In this example, we use environment.getProperty() to load the article name from properties and store it in the articleNameFromComponentAnnotation bean.

4.2. Binder

In Spring Boot applications, we can use Binder with Environment to retrieve a configuration file that holds a group of properties:

@Override
public void postProcessBeanFactory(@NonNull ConfigurableListableBeanFactory beanFactory) throws BeansException {
    BindResult<ApplicationProperties> result = Binder.get(environment)
      .bind("application", ApplicationProperties.class);
    ApplicationProperties properties = result.get();
    LOGGER.debug("Application name, using binder to access ApplicationProperties: " + properties.getName());

    BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
    registry.registerBeanDefinition("applicationNameFromComponentAnnotation", BeanDefinitionBuilder.genericBeanDefinition(String.class)
      .addConstructorArgValue(properties.getName())
      .getBeanDefinition());
}

Using Binder.get().bind(), we load ApplicationProperties and then use its getters to store the application name in the applicationNameFromComponentAnnotation bean.

5. Conclusion

In this article, we discussed the issues with injecting properties directly in the BeanFactoryPostProcessor. We demonstrated how we can leverage concepts like the Environment abstraction, Binder, BeanNameAware, and @ConfigurationFile to overcome those difficulties. Last, we discussed the trade-offs of each option.