Publié le

Les composants dans l'architecture propre

4 min lecture - 678 mots
Auteurs
  • avatar
    Nom
    Cédric RIBALTA
    Twitter
post image

Introduction

Si tu as déjà travaillé sur une grosse base de code, tu sais à quel point il peut devenir difficile de la maintenir sans une bonne structure.

Someone struggling to sleep

Dans Clean Architecture, Robert C. Martin aka Oncle Bob nous parle d’un concept fondamental pour gérer cette complexité : les composants.

Mais qu’est-ce qu’un composant exactement, et pourquoi est-il si crucial dans la conception de logiciels modulaires ?

Dans cet article, on va explorer ce concept et voir comment il peut te simplifier la vie en tant que développeur.

C'est quoi un composant ?

En gros, un composant regroupe un ensemble de classes ou de fichiers qui ont une responsabilité commune. C’est une unité de code cohérente et autonome que tu peux déplacer ou déployer de façon indépendante.

L’idée, c’est de regrouper tout ce qui est étroitement lié fonctionnellement au même endroit, pour que ce soit plus facile à maintenir et à comprendre.

La cohésion est la clef :

Un bon composant, c’est un composant cohérent. Autrement dit, toutes les classes ou modules qu'il contient doivent être liés entre eux pour accomplir une tâche bien définie.

Ça évite que ton code soit dispersé dans tous les sens et qu'il devienne rapidement ingérable. Plus un composant est cohérent, plus il est facile de savoir où faire les changements et d'éviter les bugs inattendus.

L'Encapsulation ou montrer seulement ce qui est nécessaire :

En plus d'être cohérent, un composant doit être bien encapsulé. Ça veut dire qu’il expose uniquement ce dont les autres parties de ton code ont besoin et cache le reste.

Cette approche réduit les dépendances et minimise l'impact des changements internes d'un composant sur le reste du système.

Du coup, si tu dois modifier quelque chose, tu sais que le reste du code ne sera pas affecté, tant que tu gardes la même interface.

Déploiement indépendant :

Un autre gros avantage des composants, c’est qu’ils peuvent être déployés ou mis à jour indépendamment.

En pratique, ça veut dire que tu peux bosser sur une partie du système sans avoir à redéployer tout le projet.

Et ça, ça change la donne en termes de productivité, surtout dans des environnements où chaque minute compte.

Gérer les dépendances entre composants :

Quand on parle de composants, on ne peut pas ignorer la question des dépendances. Robert Martin propose deux principes pour t’aider à structurer tout ça :

  1. Acyclic Dependencies Principle (ADP) :

Les dépendances entre tes composants ne doivent pas créer de boucles. Si le composant A dépend de B, B ne doit jamais dépendre de A. Ça évite les effets domino où une petite modification fait planter tout le reste.

  1. Stable Dependencies Principle (SDP) :

Ici, l’idée est de faire en sorte que tes composants dépendent de composants plus stables qu’eux.

Autrement dit, ton composant doit s’appuyer sur des modules ou bibliothèques qui bougent peu. Ça te permet de protéger les parties les plus instables de ton code et de limiter les répercussions des changements.

Pourquoi c'est important ?

Adopter une approche modulaire avec des composants bien définis, c'est loin d’être juste une théorie sympa. Ça a des avantages très concrets pour nous au quotidien :

  • Modularité : Tu casses ton application en morceaux autonomes, ce qui facilite la compréhension et la maintenance.
  • Scalabilité : Plusieurs équipes ou développeurs peuvent travailler en parallèle sur différents composants sans se marcher dessus.
  • Déploiement facile : Tu peux mettre à jour des parties spécifiques du système sans avoir à redéployer tout le code.
  • Moins de bugs : Comme chaque composant est encapsulé et indépendant, tu réduis les risques d’effets de bord quand tu modifies quelque chose.

Conclusion

Les composants, tels qu’ils sont définis dans Clean Architecture, sont une solution pour structurer nos applications de façon modulaire et maintenable.

En suivant les principes de cohésion, d'encapsulation et de gestion des dépendances, on peut créer des systèmes qui résistent mieux aux changements et qui sont plus faciles à faire évoluer.

Donc, si tu cherches à améliorer l'architecture de tes projets et à éviter de te retrouver dans un cauchemar de dépendances, il est peut-être temps de te pencher sérieusement sur la notion de composants.

Crois-moi, ton futur toi te remerciera !