Vous en avez assez des inscriptions répétitives de Spring Bean ? Vous n'êtes pas seul !

Vous êtes-vous déjà senti embourbé dans des définitions répétées de beans dans Spring Boot ? Vous n'êtes pas seul ! La gestion de plusieurs beans de la même classe avec des configurations différentes peut devenir fastidieuse et encombrée. Disons que vous avez besoin de quelque chose comme ceci :

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

Ce code n'est pas complexe, mais il devient vite répétitif, surtout lorsqu'il s'agit de plusieurs beans du même type. Idéalement, vous auriez un moyen d'enregistrer plusieurs instances avec des paramètres distincts sans code redondant.

Cela diffère du fait d'avoir des beans uniques pour chaque implémentation d'une interface. Au lieu de cela, nous parlons de créer une classe avec des variantes. Par exemple, pensez à une application qui se connecte à plusieurs bases de données (par exemple, client, reporting et sauvegarde). Chaque connexion nécessite sa propre configuration, ce qui rend difficile sa gestion sans encombrement. Vous pourriez finir par écrire quelque chose comme ceci :

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

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

Une solution plus simple pourrait considérablement rationaliser votre configuration et vous permettre de vous concentrer davantage sur la logique de l'application. Entrez MultiBeanConfig - une petite bibliothèque que j'ai créée pour aider à gérer plusieurs configurations pour le même bean Spring.

Présentation de MultiBeanConfig

MultiBeanConfig simplifie la configuration de plusieurs instances d'un bean avec des configurations distinctes. Avec lui, vous pouvez :

• Réduire le code répétitif
• Centraliser la gestion de la configuration
• Gardez votre base de code propre et organisée

Fonctionnalités principales

• Configuration de plusieurs beans : définissez plusieurs instances d'une seule classe.
• Configurations personnalisées : contrôlez les paramètres par instance via les propriétés de votre application.
• Valeurs par défaut : appliquez automatiquement les valeurs par défaut si des configurations spécifiques sont manquantes.
• Injection automatique : utilisez facilement @Autowired pour l'injection de dépendances.

Guide étape par étape

1. Ajoutez MultiBeanConfig à votre projet

Incluez la dépendance dans votre pom.xml :

    io.github.olufemithompson
    multibeanconfig
    0.0.3

2. Configurer la classe Bean

Marquez votre classe avec @MultiBean pour la rendre éligible à plusieurs instances :

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

3. Définissez les beans dans votre fichier de configuration

Définissez des versions uniques dans vos propriétés ou votre fichier YAML :

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

Cela enregistre les beans PrimaryDatabaseService et reportDatabaseService avec les configurations par défaut. MultiBeanConfig traduit automatiquement les noms de kebab-case en camelCase.

Personnalisation des configurations par bean

Pour attribuer des paramètres distincts, ajoutez des propriétés directement à la configuration de chaque bean. Voici un exemple où chaque instance se connecte à une base de données différente :

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

Configurez chaque instance dans 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'

Cette configuration donne à chaque bean une URL de connexion unique. Les paramètres partagés peuvent également être définis dans une section générale, rendant les configurations efficaces et réduisant la redondance.

Méthodes alternatives pour injecter des configurations

Vous n'êtes pas obligé de compter uniquement sur @Value pour injecter des configurations. @ConfigurationProperties de Spring permet d'encapsuler des propriétés dans une classe de configuration :

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

Ensuite, injectez directement DatabaseConfig :

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

Utilisation des beans configurés

Avec MultiBeanConfig , injectez vos beans configurés de manière unique comme vous le feriez avec n'importe quelle dépendance 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;
   }
}

Pensées finales

MultiBeanConfig rationalise la gestion des beans dans les applications Spring Boot, en particulier lors de la gestion des indicateurs de fonctionnalités, des sources de données ou des connexions API distinctes. Il réduit la redondance, maintient votre code propre et améliore la maintenabilité. Essayez-le et dites-moi comment cela fonctionne pour vos projets !