🎬 Aller sur la présentation

S O L I D

Introduction

SOLID est un ensemble de principes de conception pour une meilleure qualité de code.

Principes

S : Single Responsibility Principle (SRP)

Chaque classe doit avoir une seule responsabilité.
Exemple :

1
2
3
4
5
6
7

class CommandeService {
    public void traiterCommande(String typePaiement) {
        // Validation
        // Paiement
        // Notification
    }
}

O : Open/Closed Principle (OCP)

Les classes doivent être ouvertes à l’extension mais fermées à la modification.
Exemple :

interface Paiement { void payer(); }
class PaiementCarte implements Paiement { ... }
class PaiementPayPal implements Paiement { ... }

L : Liskov Substitution Principle (LSP)

Les objets d’une classe dérivée doivent pouvoir remplacer ceux de la classe parente sans altérer le bon fonctionnement.

I : Interface Segregation Principle (ISP)

Les interfaces doivent être spécifiques et non généralistes.
Exemple :

interface Notification { void notifier(); }
class NotificationEmail implements Notification { ... }

D : Dependency Inversion Principle (DIP)

Les modules de haut niveau ne doivent pas dépendre de modules de bas niveau, mais des abstractions.

Remanier le code pour qu'il soit SOLID

Sujet

Vous devez refactoriser une classe OrderManager qui gère les tâches suivantes : * Validation de la commande * Calcul des promotions * Envoi d’emails * Déclenchement de la livraison

Objectifs : 1. Séparer ces responsabilités en différentes classes. 2. Appliquer les principes SOLID, en particulier SRP, OCP et DIP. 3. Proposer un design modulaire, évolutif et testable.

Remaniement de la classe OrderManager

Séparer les responsabilités (SRP)

class OrderService {
    private ValidationService validationService;
    private PromotionService promotionService;
    private EmailService emailService;
    private DeliveryService deliveryService;
}

Ouverture à l’extension (OCP)

Ajout de nouveaux services comme PaymentService ou DiscountService sans modifier OrderService.

Injection de dépendances (DIP)

class OrderService {
    private ValidationService validationService;
    private PromotionService promotionService;
    private EmailService emailService;
    private DeliveryService deliveryService;

    public OrderService(ValidationService validationService, PromotionService promotionService,
                        EmailService emailService, DeliveryService deliveryService) {
        this.validationService = validationService;
        this.promotionService = promotionService;
        this.emailService = emailService;
        this.deliveryService = deliveryService;
    }
}

Checklist de Refactoring SOLID

Avant de valider votre refactoring, vérifiez que : * SRP : Chaque classe a une seule responsabilité. * OCP : Le code est ouvert à l’extension, mais fermé à la modification.
* LSP : Les sous-classes peuvent être utilisées à la place de leurs classes parentes sans affecter le comportement. * ISP : Les interfaces sont spécifiques et non générales. * DIP : Le code dépend d’abstractions, et non de détails.

Ressources Utiles

Livres

• "Clean Code" de Robert C. Martin
• "Agile Software Development" de Robert C. Martin

Vidéos et Tutos

• Principes SOLID – Introduction vidéo
• Tutoriel SOLID pour les débutants