¿Estás cansado de los registros repetitivos de Spring Bean? ¡No estás solo!

¿Alguna vez te has sentido atascado con definiciones repetidas de beans en Spring Boot? ¡No estás solo! Administrar varios beans de la misma clase con diferentes configuraciones puede resultar tedioso y confuso. Digamos que necesitas algo como esto:

@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);
}

Este código no es complejo, pero rápidamente se vuelve repetitivo, especialmente cuando se trata de varios beans del mismo tipo. Lo ideal sería tener una forma de registrar varias instancias con configuraciones distintas sin código redundante.

Esto difiere de tener beans únicos para cada implementación de una interfaz. En cambio, estamos hablando de configurar una clase con variaciones. Por ejemplo, piense en una aplicación que se conecta a varias bases de datos (por ejemplo, clientes, informes y copias de seguridad). Cada conexión necesita su propia configuración, lo que dificulta su gestión sin desorden. Podrías terminar escribiendo algo como esto:

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

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

Tener una solución más simple podría optimizar significativamente su configuración y permitirle concentrarse más en la lógica de la aplicación. Ingrese a MultiBeanConfig, una pequeña biblioteca que construí para ayudar a administrar múltiples configuraciones para el mismo Spring Bean.

Presentamos MultiBeanConfig

MultiBeanConfig simplifica la configuración de múltiples instancias de un bean con configuraciones separadas. Con él podrás:

• Reducir el código repetitivo
• Centralizar la gestión de la configuración
• Mantén tu base de código limpia y organizada

Características principales

• Configuración de múltiples beans: define múltiples instancias de una sola clase.
• Configuraciones personalizadas: controla la configuración por instancia a través de las propiedades de tu aplicación.
• Valores predeterminados: aplica automáticamente los valores predeterminados si faltan configuraciones específicas.
• Inyección automática: utilice fácilmente @Autowired para la inyección de dependencias.

Guía paso a paso

1. Agregue MultiBeanConfig a su proyecto

Incluye la dependencia en tu pom.xml:

io.github.olufemithompsonmultibeanconfig0.0.3

2. Configurar la clase Bean

Marque su clase con @MultiBean para que sea elegible para múltiples instancias:

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

3. Defina Beans en su archivo de configuración

Defina versiones únicas en sus propiedades o archivo YAML:

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

Esto registra los beans de servicio de base de datos primario y de servicio de base de datos de informe con configuraciones predeterminadas. MultiBeanConfig traduce automáticamente nombres de kebab-case a camelCase.

Personalización de configuraciones por bean

Para asignar configuraciones separadas, agregue propiedades directamente a la configuración de cada bean. A continuación se muestra un ejemplo en el que cada instancia se conecta a una base de datos diferente:

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

Configurar cada instancia en 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'

Esta configuración le da a cada bean una URL de conexión única. Las configuraciones compartidas también se pueden definir en una sección general, lo que hace que las configuraciones sean eficientes y reduce la redundancia.

Formas alternativas de inyectar configuraciones

No tienes que depender únicamente de @Value para inyectar configuraciones. @ConfigurationProperties de Spring permite encapsular propiedades en una clase de configuración:

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

Luego, inyecta DatabaseConfig directamente:

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

Usando los beans configurados

Con MultiBeanConfig, inyecte sus beans configurados de forma exclusiva como lo haría con cualquier dependencia de Spring:

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

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

Pensamientos finales

MultiBeanConfig agiliza la administración de beans en aplicaciones Spring Boot, especialmente cuando se manejan indicadores de funciones, fuentes de datos o conexiones API distintas. Reduce la redundancia, mantiene el código limpio y mejora la mantenibilidad. ¡Pruébalo y cuéntame cómo funciona en tus proyectos!