Rendez votre code objet plus flexible

Imaginez que vous rejoignez une équipe qui maintient une application de suivi de commandes. Lorsqu’une commande est expédiée, un service envoie une notification par e-mail au client. Jusqu’ici, ce service répond au besoin.

L’équipe souhaite maintenant proposer l’envoi par SMS, puis par notification push. Dans la version actuelle, chaque canal est ajouté dans la même méthode, à l’aide d’une nouvelle condition. La méthode s’allonge et chaque modification risque de perturber les envois déjà en place.

Comment faire évoluer ce code sans le réécrire à chaque nouveau besoin ? Les design patterns, ou patrons de conception, apportent des solutions éprouvées à ce type de problème récurrent. Ils ne sont ni des recettes à copier, ni des obligations : ils proposent une façon d’organiser les objets pour rendre certaines évolutions plus simples.

Dans ce chapitre, vous allez apprendre à repérer ce manque de flexibilité et à mieux répartir les responsabilités entre les objets. Vous utiliserez pour cela des contrats, le polymorphisme, la composition et l’injection de dépendances. Ces mécanismes vous prépareront à appliquer votre premier design pattern dans le chapitre suivant.

Comprenez le rôle d’un design pattern

Lorsque plusieurs équipes rencontrent le même problème de conception, elles finissent souvent par organiser leurs objets de façon comparable. Un design pattern décrit une solution générale qui a fait ses preuves face à un problème récurrent.

Un pattern ne fournit pas un programme prêt à exécuter. Il décrit plutôt :

  • le problème auquel il répond ;

  • le contexte dans lequel ce problème apparaît ;

  • les rôles joués par les objets ;

  • la façon dont ces objets collaborent ;

  • les avantages et les compromis de cette organisation.

Prenez le problème de votre application : le canal de notification doit pouvoir varier sans obliger le service principal à changer. Un design pattern adapté ne vous imposera ni un fournisseur d’e-mails, ni un nom de classe, ni un langage. Il proposera une manière d’organiser le comportement variable et l’objet qui l’utilise. Vous adapterez ensuite cette structure à votre application.

Un design pattern n’est donc :

  • ni une bibliothèque que vous installez ;

  • ni une fonction que vous copiez ;

  • ni un framework qui configure l’application à votre place ;

  • ni une règle à appliquer systématiquement.

Les patterns donnent aussi un vocabulaire commun. Dire « cette partie utilise Strategy » permet à une équipe d’évoquer rapidement des comportements interchangeables, un contrat commun et un objet qui délègue le travail. Ce nom ne remplace toutefois pas l’explication : il faut toujours pouvoir indiquer quel problème le pattern résout dans le code concerné.

Dans ce cours, vous n’allez donc pas mémoriser un catalogue de patterns. Vous allez d’abord acquérir les mécanismes de conception objet sur lesquels ils reposent. Puis vous les assemblerez dans le chapitre suivant pour appliquer le pattern Strategy à un problème concret. Ce pattern, dont le nom signifie « stratégie », permet de regrouper plusieurs façons de réaliser une même opération derrière un contrat commun et de les rendre interchangeables. Par exemple, un service peut utiliser différentes règles de calcul d’une prime sans connaître le détail de chaque formule. Cette progression vous aidera à comprendre pourquoi le pattern est utile, au lieu d’en reproduire uniquement la forme.

Un pattern introduit en effet davantage d’objets et d’abstractions. Si le comportement ne varie jamais, une solution directe peut rester plus lisible. Le bon réflexe n’est pas « Où puis-je placer un pattern ? », mais « Quel problème d’évolution ou de maintenance dois-je résoudre ? ».

Repérez les limites d’un code objet difficile à faire évoluer

Voici une première version simplifiée du service de notification :

classe ServiceNotification
    méthode envoyerNotification(utilisateur, message)
        si utilisateur.email est vide
            lever une erreur "Adresse e-mail manquante"
        contenu = "Bonjour " + utilisateur.prenom + ", " + message
        clientEmail = nouveau ClientEmail("cle-secrete")
        clientEmail.envoyer(
            destinataire = utilisateur.email,
            objet = "Nouvelle notification",
            contenu = contenu
        )
        journaliser("E-mail envoyé à " + utilisateur.email)

Ce code est court. Pourtant, la classeServiceNotificationprend déjà en charge plusieurs tâches :

  • elle vérifie les coordonnées de l’utilisateur ;

  • elle construit le contenu du message ;

  • elle configure un outil d’envoi d’e-mails ;

  • elle expédie le message ;

  • elle écrit une trace dans le journal de l’application.

Cette accumulation est un premier signal d’alerte. Une classe devrait avoir une responsabilité principale, c’est-à-dire une seule raison importante de changer. C’est le principe de responsabilité unique, ou SRP pour Single Responsibility Principle.

Ici, la classe peut changer si la règle de validation évolue, si le texte du message change, si l’équipe remplace son fournisseur d’e-mails ou si le format des journaux est modifié. Plusieurs responsabilités sont donc mélangées.

D’autres indices doivent attirer votre attention :

  • une méthode trop longue, dans laquelle plusieurs étapes métier et techniques s’enchaînent ;

  • des noms imprécis, qui ne permettent pas de comprendre le rôle d’une variable ou d’une méthode ;

  • de la logique dupliquée, par exemple la même construction de message dans les envois par e-mail et par SMS ;

  • une dépendance créée directement dans la classe, commenouveau ClientEmail(...);

  • des conditions qui se multiplient chaque fois qu’un comportement est ajouté.

Le principe DRY, pour Don’t Repeat Yourself (ne vous répétez pas), vous aide à repérer les répétitions inutiles. Les pratiques de Clean Code (code propre), comme des noms explicites et des méthodes courtes, facilitent quant à elles la lecture du code. Ces repères ne sont pas des objectifs isolés : ils servent à rendre le programme plus facile à comprendre et à modifier.

Cette fragilité vient notamment du couplage. Deux éléments sont fortement couplés lorsque l’un connaît de nombreux détails sur l’autre.ServiceNotificationsait ici qu’il utiliseClientEmail, comment le construire et quelle clé lui fournir. Tout changement du client d’e-mail peut donc modifier le service.

À l’inverse, la cohésion décrit à quel point les éléments d’une classe contribuent à une même responsabilité. Une classe qui valide un utilisateur, formate un message, envoie un e-mail et journalise une action manque de cohésion. Pour l’améliorer, vous allez commencer par isoler ce qui varie : le canal utilisé pour envoyer la notification.

Appliquer SRP ne consiste toutefois pas à créer une classe pour chaque ligne de code. Un découpage trop fin disperserait la logique et obligerait à ouvrir de nombreux fichiers pour comprendre une seule action. Cherchez plutôt les responsabilités qui évoluent pour des raisons différentes. La construction du message change lorsque les besoins de communication évoluent ; l’envoi change lorsque le fournisseur ou le canal change ; la journalisation change lorsque les besoins de suivi évoluent. Ces trois axes justifient une séparation. À l’inverse, deux petites opérations qui évoluent toujours ensemble peuvent rester regroupées.

Définissez un contrat commun

L’application doit pouvoir envoyer une notification par différents canaux. Tous n’utilisent pas les mêmes données ni les mêmes outils, mais ils répondent au même besoin : transmettre un message à un destinataire.

Vous pouvez exprimer ce besoin par un contrat :

contrat CanalNotification
    méthode envoyer(destinataire, message)

Le contrat décrit l’opération attendue sans imposer la façon de la réaliser. Il ne sait pas comment un e-mail ou un SMS est envoyé. Il indique seulement que tout canal de notification doit proposer une méthodeenvoyer.

Deux classes peuvent alors respecter ce contrat :

classe CanalEmail respecte CanalNotification
    méthode envoyer(destinataire, message)
        clientEmail.envoyer(destinataire.email, message)
classe CanalSMS respecte CanalNotification
    méthode envoyer(destinataire, message)
        clientSMS.envoyer(destinataire.telephone, message)

Selon le langage, ce contrat peut prendre différentes formes : une interface en Java ou en C# ; unProtocol, une classe abstraite ou la signature d’une fonction injectée en Python. Pour l’instant, retenez surtout son rôle : séparer ce dont le programme a besoin de la manière dont ce besoin est satisfait.

Cette séparation clarifie les responsabilités.CanalEmailconnaît les détails de l’envoi d’un e-mail ;CanalSMSconnaît ceux de l’envoi d’un SMS. Le service principal n’a plus besoin de les connaître.

Le contrat ne supprime donc pas la dépendance :ServiceNotificationa toujours besoin d’un canal pour travailler. Il change la direction et le niveau de cette dépendance. Au lieu de dépendre des détails d’un client d’e-mail, le service dépend d’une capacité stable : « envoyer une notification ».

Cette distinction est importante. Une implémentation concrète contient des choix techniques susceptibles de changer : fournisseur externe, format de requête, authentification ou gestion des erreurs. Le contrat, lui, exprime le besoin du code métier. Il doit rester assez précis pour être utile, mais assez général pour convenir à toutes les implémentations prévues.

Évitez par exemple un contrat nomméCanalNotificationdont la méthode seraitenvoyerEmailAvecObjet. Il imposerait des notions propres à l’e-mail et conviendrait mal au SMS. Une opération commeenvoyer(destinataire, message)décrit mieux le besoin commun. Concevoir un bon contrat revient donc à rechercher ce qui reste stable derrière les comportements qui varient.

Rendez les comportements interchangeables grâce au polymorphisme

Dès lors que plusieurs objets respectent le même contrat, le code qui les utilise peut les manipuler de la même façon. C’est le polymorphisme : un même appel produit un comportement différent selon l’objet reçu.

Le service de notification peut maintenant dépendre du contrat :

classe ServiceNotification
    attribut canal : CanalNotification
    méthode notifier(utilisateur, message)
        canal.envoyer(utilisateur, message)

Si l’attributcanalcontient un objetCanalEmail, la notification part par e-mail. S’il contient un objetCanalSMS, elle part par SMS. La méthodenotifierreste identique : elle appelle seulementenvoyer.

serviceEmail = nouveau ServiceNotification(canalEmail)
serviceEmail.notifier(utilisateur, "Votre commande est expédiée")
serviceSMS = nouveau ServiceNotification(canalSMS)
serviceSMS.notifier(utilisateur, "Votre commande est expédiée")

Le polymorphisme vous évite d’écrire une longue condition dans le service :

si typeCanal = "email"
    envoyerEmail(...)
sinon si typeCanal = "sms"
    envoyerSMS(...)
sinon si typeCanal = "push"
    envoyerPush(...)

Cette structure conditionnelle paraît acceptable avec deux possibilités. Mais elle grossit à chaque nouveau canal et oblige à modifier le service. Avec un contrat commun, le service se contente d’utiliser l’objet qu’il reçoit.

Préférez la composition à l’héritage

Pour rendre le service flexible, vous pourriez être tenté de créer plusieurs sous-classes :

ServiceNotificationEmail hérite de ServiceNotification
ServiceNotificationSMS hérite de ServiceNotification
ServiceNotificationPush hérite de ServiceNotification

Cette solution exprime une relation « est un » : unServiceNotificationEmailest unServiceNotification. Pourtant, ce qui varie n’est pas la nature du service, mais le canal qu’il utilise.

La composition traduit mieux cette relation : le service utilise un canal de notification.

classe ServiceNotification
    attribut canal : CanalNotification

L’attributcanalest défini par le contratCanalNotification: ce n’est pas une classe concrète. À l’exécution, il contient un objet qui respecte ce contrat, par exemple unCanalEmailou unCanalSMS. C’est l’association de la composition et du contrat commun qui permet de remplacer le canal sans créer une nouvelle hiérarchie de services.

La différence devient plus nette si l’application doit combiner plusieurs variations. Imaginez trois canaux, deux formats de message et deux systèmes de journalisation. Avec l’héritage, vous risquez de créer des classes telles queServiceEmailCourtAvecJournalFichierouServiceSMSLongAvecJournalConsole. Le nombre de sous-classes augmente très vite.

Avec la composition, vous assemblez les collaborateurs nécessaires :

service = nouveau ServiceNotification(
    canal = canalSMS,
    formateur = formateurCourt,
    journal = journalFichier
)

Chaque objet conserve une responsabilité claire. Vous pouvez remplacer le canal sans toucher au formateur, ou remplacer le journal sans créer une nouvelle version du service.

Injectez une dépendance

Le service dépend maintenant d’unCanalNotification. Il reste à décider qui crée ce canal.

Dans une version fortement couplée, le service le construit lui-même :

classe ServiceNotification
    méthode initialiser()
        canal = nouveau CanalEmail()

Le service est alors toujours lié à l’e-mail. Pour changer de canal, vous devez modifier son code.

L’injection de dépendances consiste à fournir le collaborateur depuis l’extérieur. La forme la plus simple est l’injection par constructeur :

classe ServiceNotification
    attribut canal : CanalNotification
    constructeur(canal)
        cetObjet.canal = canal
    méthode notifier(utilisateur, message)
        cetObjet.canal.envoyer(utilisateur, message)

Le code qui démarre l’application choisit l’implémentation :

canal = nouveau CanalEmail(clientEmail)
service = nouveau ServiceNotification(canal)

Cette organisation présente trois avantages :

  1. Le service est plus flexible : vous pouvez lui fournir un canal e-mail, SMS ou push.

  2. Les responsabilités sont mieux réparties : le service utilise le canal, mais ne le configure pas.

  3. Le service est plus facile à tester : vous pouvez injecter un faux canal qui enregistre le message au lieu de l’envoyer.

classe FauxCanal respecte CanalNotification
    attribut dernierMessage
    méthode envoyer(destinataire, message)
        dernierMessage = message

Un test peut alors vérifier le comportement du service sans appeler un véritable fournisseur d’e-mails et sans envoyer de message à un utilisateur.

Les frameworks Java et C# proposent des conteneurs capables de créer et d’injecter automatiquement les dépendances. En Python, elles sont souvent assemblées explicitement. Vous découvrirez ces mises en œuvre dans les cours consacrés à chaque stack. Le mécanisme reste le même : un objet reçoit ce dont il a besoin au lieu de le construire lui-même.

À vous de jouer

Votre application envoie pour l’instant des notifications avec cette classe :

classe AlerteStock
    méthode avertir(responsable, produit)
        clientSMS = nouveau ClientSMS("cle-secrete")
        message = "Stock faible : " + produit.nom
        clientSMS.envoyer(responsable.telephone, message)

L’équipe souhaite pouvoir envoyer la même alerte par e-mail, et peut-être plus tard par notification push. Elle veut aussi tester le service sans envoyer de vrai message.

À vous de rendre ce code plus flexible :

  1. Repérez la dépendance créée directement dansAlerteStocket expliquez le couplage qu’elle produit.

  2. Définissez un contrat commun nomméCanalAlerteavec une opération d’envoi.

  3. Créez deux implémentations :AlerteSMSetAlerteEmail.

  4. ModifiezAlerteStockpour qu’elle reçoive le canal par son constructeur.

  5. Créez unFauxCanalAlerteutilisable dans un test.

  6. Vérifiez que vous pouvez remplacer le SMS par l’e-mail sans modifier la classeAlerteStock.

Avant de consulter la proposition, dessinez les relations entre les objets ou écrivez votre propre pseudo-code.

En résumé

  • Le principe de responsabilité unique aide à séparer les raisons pour lesquelles une classe peut changer. DRY et les pratiques de Clean Code aident à repérer les duplications et les problèmes de lisibilité.

  • Réduire le couplage et renforcer la cohésion facilite l’évolution du code : chaque classe rassemble une responsabilité claire et dépend de moins de détails techniques.

  • Un contrat définit une opération commune sans imposer sa réalisation ; le polymorphisme permet d’utiliser différentes implémentations derrière ce contrat.

  • La composition permet à un objet d’utiliser un comportement interchangeable sans multiplier les sous-classes.

  • L’injection de dépendances consiste à fournir un collaborateur depuis l’extérieur, ce qui facilite son remplacement et les tests.

Vous savez maintenant rendre des comportements interchangeables et réduire le couplage entre vos objets. Dans le chapitre suivant, vous allez organiser ces mécanismes au sein d’une solution de conception reconnue : le pattern Strategy.

Ever considered an OpenClassrooms diploma?
  • Up to 100% of your training program funded
  • Flexible start date
  • Career-focused projects
  • Individual mentoring
Find the training program and funding option that suits you best