💡 Créez un moteur de règles dynamique en Spring Boot avec le pattern Strategy + Registry

Lorsque votre application doit appliquer des comportements différents en fonction d’une condition (type de client, statut d’une commande, type de paiement…), il est tentant d’utiliser des if-else ou des switch.

Mais très vite, ce code devient difficile à maintenir et à étendre.

Une meilleure solution ?

👉 Le pattern Strategy couplé à un Registry.

Dans cet article, nous allons créer un moteur de règles dynamique en Spring Boot avec seulement 2 règles pour garder l’exemple clair.

🎯 Objectif

Nous voulons appliquer deux règles de réduction en fonction du type de client :

• ClientPremiumRule : réduction de 20 %
• ClientStandardRule : réduction de 5 %

1️⃣ Définir l’interface de la règle

public interface DiscountRule {
    String getRuleName(); // clé d'identification
    double applyDiscount(double price);
}

2️⃣ Implémenter les règles

import org.springframework.stereotype.Component;

@Component
public class ClientPremiumRule implements DiscountRule {
    @Override
    public String getRuleName() {
        return "premium";
    }
    @Override
    public double applyDiscount(double price) {
        return price * 0.8; // -20%
    }
}
@Component
public class ClientStandardRule implements DiscountRule {
    @Override
    public String getRuleName() {
        return "standard";
    }
    @Override
    public double applyDiscount(double price) {
        return price * 0.95; // -5%
    }
}

3️⃣ Créer le Registry

On utilise Spring pour injecter toutes les stratégies disponibles et les stocker dans une map.

import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.stream.Collectors;

@Component
public class DiscountRuleRegistry {
    private final Map<String, DiscountRule> rules;
    public DiscountRuleRegistry(Map<String, DiscountRule> rulesMap) {
        this.rules = rulesMap.values().stream()
                .collect(Collectors.toMap(DiscountRule::getRuleName, r -> r));
    }
    public DiscountRule getRule(String ruleName) {
        return rules.getOrDefault(ruleName, price -> price); // défaut: pas de réduction
    }
}

4️⃣ Utilisation dans un service

import org.springframework.stereotype.Service;

@Service
public class DiscountService {
    private final DiscountRuleRegistry registry;
    public DiscountService(DiscountRuleRegistry registry) {
        this.registry = registry;
    }
    public double calculatePrice(String customerType, double price) {
        return registry.getRule(customerType).applyDiscount(price);
    }
}

5️⃣ Exemple d’utilisation

@SpringBootApplication
public class DiscountApp implements CommandLineRunner {
    private final DiscountService service;
    public DiscountApp(DiscountService service) {
        this.service = service;
    }
    public static void main(String[] args) {
        SpringApplication.run(DiscountApp.class, args);
    }
    @Override
    public void run(String... args) {
        System.out.println(service.calculatePrice("premium", 100)); // 80.0
        System.out.println(service.calculatePrice("standard", 100)); // 95.0
        System.out.println(service.calculatePrice("inconnu", 100)); // 100.0
    }
}

🚀 Avantages

• Extensible : ajouter une nouvelle règle = créer une nouvelle classe, aucune modification du code existant.
• Lisible : fini les gros if-else.
• Testable : chaque règle peut être testée indépendamment.

💭 Conclusion

Le Strategy + Registry pattern est un excellent moyen d’éviter la complexité croissante des conditions imbriquées.

Même avec 2 règles, l’architecture reste prête pour évoluer vers un moteur de règles complet.

Des questions ? Des retours d’expérience à partager ? N’hésitez pas à commenter ! 👇

Peace ✌️

Cindano Jonathan

Merci de faire partie de notre communauté ! Avant de partir :

• ❤️ J’aime l’histoire et je suis l’auteur 👉
• 📰 Voir plus de contenu dans mes publications
• 🔔 Suivez-nous : Twitter | LinkedIn | Newsletter