Easily Set Up Multiple Spring Beans with Unique Configurations

Tired of Repetitive Spring Bean Registrations? You’re Not Alone!

Ever feel bogged down with repeated bean definitions in Spring Boot? You’re not alone! Managing multiple beans of the same class with different configurations can get tedious and cluttered. Let's say you need something like this:

@Bean
MyService beanA() {
    // Set Configuration for bean A
    Configuration a = new...
    a.setUrl(.....)
    return new MyService(a);
}

@Bean
MyService beanB() {
    // Set Configuration for bean A
    Configuration b = new...
    b.setUrl(.....)
    return new MyService(b);
}

This code isn't complex, but it quickly becomes repetitive, especially when dealing with several beans of the same type. Ideally, you'd have a way to register multiple instances with distinct settings without redundant code.

This differs from having unique beans for each implementation of an interface. Instead, we’re talking about setting up one class with variations. For example, think of an app that connects to multiple databases (e.g., customer, reporting, and backup). Each connection needs its own configuration, making it challenging to manage without clutter. You might end up writing something like this:

@Bean
DatabaseService primaryDatabaseService() {
    return new DatabaseService("db-url-primary");
}

@Bean
DatabaseService reportDatabaseService() {
    return new DatabaseService("db-url-report");
}

Having a simpler solution could significantly streamline your configuration and let you focus more on application logic. Enter MultiBeanConfig — a small library I built to help manage multiple configurations for the same Spring bean.

Introducing MultiBeanConfig

MultiBeanConfig simplifies the setup of multiple instances of a bean with separate configurations. With it, you can:

• Reduce repetitive code
• Centralize configuration management
• Keep your codebase clean and organized

Core Features

• Multiple Bean Setup: Define multiple instances of a single class.
• Custom Configurations: Control settings per instance through your application properties.
• Default Values: Automatically apply default values if specific configurations are missing.
• Automatic Injection: Easily use @Autowired for dependency injection.

Step-by-Step Guide

1. Add MultiBeanConfig to Your Project

Include the dependency in your pom.xml:

<dependency>
    <groupId>io.github.olufemithompson</groupId>
    <artifactId>multibeanconfig</artifactId>
    <version>0.0.3</version>
</dependency>

2. Set Up the Bean Class

Mark your class with @MultiBean to make it eligible for multiple instances:

@MultiBean
public class DatabaseService {
    // Your service logic
}

3. Define Beans in Your Config File

Define unique versions in your properties or YAML file:

multibean:
  primary-database-service:
    class: DatabaseService
  report-database-service:
    class: DatabaseService

This registers primaryDatabaseService and reportDatabaseService beans with default configurations. MultiBeanConfig automatically translates names from kebab-case to camelCase.

Customizing Configurations Per Bean

To assign separate settings, add properties directly to each bean’s configuration. Here’s an example where each instance connects to a different database:

@MultiBean
public class DatabaseService {
   @Value("${database-config.connection-url}")
   private String connectionUrl;
}

Configure each instance in application.yml:

database-config:
  connection-url: 'jdbc:h2:default-url'

multibean:
  primary-database-service:
    class: DatabaseService
    database-config:
      connection-url: 'jdbc:mysql:primary-db-url'
  report-database-service:
    class: DatabaseService
    database-config:
      connection-url: 'jdbc:postgresql:report-db-url'

This setup gives each bean a unique connection URL. Shared settings can also be defined in a general section, making configurations efficient and reducing redundancy.

Alternative Ways to Inject Configurations

You don’t have to rely solely on @Value for injecting configurations. Spring’s @ConfigurationProperties allows encapsulating properties in a configuration class:

@ConfigurationProperties("database-config")
@Configuration
public class DatabaseConfig {
    private String connectionUrl;
    private int connectionTimeout;
    // Getters and Setters
}

Then, inject DatabaseConfig directly:

@MultiBean
public class DatabaseService {
   private final DatabaseConfig databaseConfig;
   public DatabaseService(DatabaseConfig databaseConfig) {
       this.databaseConfig = databaseConfig;
   }
}

Using the Configured Beans

With MultiBeanConfig , inject your uniquely configured beans as you would with any Spring dependency:

@Service
public class ApplicationService {
   private final DatabaseService primaryDatabaseService;
   private final DatabaseService reportDatabaseService;

   public ApplicationService(DatabaseService primaryDatabaseService, DatabaseService reportDatabaseService) {
       this.primaryDatabaseService = primaryDatabaseService;
       this.reportDatabaseService = reportDatabaseService;
   }
}

Final Thoughts

MultiBeanConfig streamlines bean management in Spring Boot applications, especially when handling feature flags, data sources, or distinct API connections. It reduces redundancy, keeps your code clean, and enhances maintainability. Give it a try, and let me know how it works for your projects!