Dynamically Register Spring Beans Based on Properties

1. Overview

In this tutorial, we’ll explore how to dynamically register beans based on custom properties. We’ll explore the BeanDefinitionRegistryPostProcessor interface and how we can use it to add beans to the application context.

2. Code Setup

Let’s start by creating a simple Spring Boot application.

First, we’ll define a bean that we want to register dynamically. Then, we’ll provide a property that decides how to register the beans. And finally, we’ll define a configuration class that will register the bean based on our custom properties.

2.1. Dependencies

Let’s start by adding the Maven dependencies:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>3.2.3</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <version>3.2.3</version>
    <scope>test</scope>
</dependency>

We need to add the spring-boot-starter and spring-boot-starter-test dependencies.

2.2. Bean Class

Next, we define an API client that we want to register based on our custom application property:

public class ApiClient {
    private String name;
    private String url;
    private String key;
    // standard getters, setters and constructors
    
    public String getConnectionProperties() {
        return "Connecting to " + name + " at " + url;     
    }
}

Let’s say we want to use this bean to connect to different APIs based on the properties we provide. We don’t want to create class definitions for each API. Instead, we want to define the properties and register the bean dynamically for each API.

We shouldn’t annotate the ApiClient class with @Component or @Service as we do not want to register it as a bean using the component scan.

2.3. Properties

Let’s add a property that determines which APIs the bean should be registered for. We’ll define this property in the application.yml file:

api:
  clients:
    - name: example  
      url: https://api.example.com
      key: 12345
    - name: anotherexample
      url: https://api.anotherexample.com
      key: 67890

Here, we define two clients with their respective properties. We’ll use these properties when registering the beans.

3. Dynamically Registering Beans

Spring provides a way to register beans dynamically using the BeanDefinitionRegistryPostProcessor interface. This interface allows us to add or modify the bean definitions after the annotated bean definitions have been registered. As it takes place before the bean instantiation, the beans are registered before the application context is fully initialized.

3.1. BeanDefinitionRegistryPostProcessor

Let’s define a configuration class that will register the ApiClient beans based on the custom properties:

public class ApiClientConfiguration implements BeanDefinitionRegistryPostProcessor {
    private static final String API_CLIENT_BEAN_NAME = "apiClient_";
    List<ApiClient> clients;
    public ApiClientConfiguration(Environment environment) {
        Binder binder = Binder.get(environment);
        List<HashMap> properties = binder.bind("api.clients", Bindable.listOf(HashMap.class)).get();
        clients = properties.stream().map(client -> new ApiClient(String.valueOf(client.get("name")),
                String.valueOf(client.get("url")), String.valueOf(client.get("key")))).toList();
    }    
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        clients.forEach(client -> {
            BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(ApiClient.class);
            builder.addPropertyValue("name", client.getName());
            builder.addPropertyValue("url", client.getUrl());
            builder.addPropertyValue("key", client.getkey());
            registry.registerBeanDefinition(API_CLIENT_BEAN_NAME + client.getName(), builder.getBeanDefinition());
        });
    }
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    }
}

Here, we implement the BeanDefinitionRegistryPostProcessor interface. We override the postProcessBeanDefinitionRegistry method that’s responsible for registering the beans based on our custom properties.

First, we define a constant API_CLIENT_BEAN_NAME that will be used as a prefix for the bean names. In the constructor, we read the properties from the Environment object using the Binder API. We then create the ApiClient objects using the properties.

In implementing the postProcessBeanDefinitionRegistry() method, we iterate over the properties and register the ApiClient beans using the BeanDefinitionRegistry object.

We create the beans using the BeanDefinitionBuilder. It requires us to define the bean class. It then lets us set the bean properties one by one using the field names.

Note that we register each bean with a unique name – API_CLIENT_BEAN_NAME + client.getName(). This will help when we want to read the bean of our choice from the context.

3.2. Main Application Class

At last, we need to define the main application class and annotate it with @SpringBootApplication:

@SpringBootApplication
public class RegistryPostProcessorApplication {
    public static void main(String[] args) {
        SpringApplication.run(RegistryPostProcessorApplication.class, args);
    }
    @Bean
    public ApiClientConfiguration apiClientConfiguration(ConfigurableEnvironment environment) {
        return new ApiClientConfiguration(environment);
    }
}

Here, we define the ApiClientConfiguration bean and pass the ConfigurableEnvironment object to the constructor. This will help us to read the properties in the ApiClientConfiguration class.

4. Testing

Now that the beans are registered, let’s test if they have the correct properties to connect to the APIs. To test this, we’ll write a simple test class:

@SpringBootTest
class ApiClientConfigurationTest {
    @Autowired
    private ApplicationContext context;
    
    @Test
    void givenBeansRegistered_whenConnect_thenConnected() {
        ApiClient exampleClient = (ApiClient) context.getBean("apiClient_example");
        Assertions.assertEquals("Connecting to example at https://api.example.com", exampleClient.getConnectionProperties());
        
        ApiClient anotherExampleClient = (ApiClient) context.getBean("apiClient_anotherexample");
        Assertions.assertEquals("Connecting to anotherexample at https://api.anotherexample.com", anotherExampleClient.getConnectionProperties());
    }
}

Here, we use the @SpringBootTest annotation to load the application context. Then, we use the ApplicationContext object to get the beans from the context using the getBean() method. The getBean() method takes the unique bean name as an argument and returns the bean from the context.

The test checks if the beans are registered correctly and have the correct connection properties set.

5. Conclusion

In this tutorial, we explored how to dynamically register Spring beans based on custom properties using the BeanDefinitionRegistryPostProcessor interface. We also wrote a simple test case showing how to retrieve the beans from the context and use them.

As always, the code for the examples is available over on GitHub.