Cours sur l'architecture propre

Leçon 1 • Couplage, cohésion et frontières

Explique comment le couplage et la cohésion déterminent la santé des modules. Les étudiants apprennent à identifier les violations de frontières avant d'écrire une seule ligne d'architecture.

Leçon 2 • Ce que l'architecture signifie réellement

Définit l'architecture comme l'ensemble des décisions difficiles à inverser. Ancre le chapitre en séparant les préoccupations de conception de celles d'implémentation.

Leçon 3 • Le coût d'une mauvaise conception

Examine comment une mauvaise structure accumule de la dette technique au fil du temps. Motive l'ensemble du cours en quantifiant l'impact commercial des bases de code désordonnées.

Leçon 1 • Origines et objectifs de l'architecture Clean

Retrace l'architecture Clean à partir de ses prédécesseurs Hexagonal et Oignon. Clarifie l'objectif commun : maintenir la logique métier indépendante des frameworks et de l'infrastructure.

Leçon 2 • Les quatre anneaux concentriques

Détaille les couches Entités, Cas d'utilisation, Adaptateurs d'interface et Frameworks. Les connaissances autorisées et les responsabilités de chaque anneau sont précisément définies.

Leçon 3 • La règle de dépendance expliquée

Définit la règle la plus importante : les dépendances du code source pointent uniquement vers l'intérieur. Les étudiants s'entraînent à tracer les flèches de dépendance pour valider la conformité.

Leçon 1 • Conception d'objets métier sans framework

Enseigne des techniques pour écrire des Entités sans aucune importation de framework. Les étudiants produisent des objets simples testables sans avoir à démarrer d'infrastructure.

Leçon 2 • Définition des entités dans l'architecture Clean

Distingue les entités de l'architecture Clean des lignes de base de données ou des modèles ORM. Établit que les entités encapsulent les règles métier critiques, pas seulement les données.

Leçon 3 • Relations entre entités et agrégats

Présente les racines d'agrégat pour gérer des groupes d'entités apparentées. Les étudiants apprennent les frontières de cohérence qui protègent les règles métier à travers les graphes d'objets.

Leçon 1 • Implémentation du modèle Interactor

Implémente la classe Interactor qui remplit un contrat de port d'entrée. Montre comment les Interactors appellent les Entités et délèguent les E/S via les ports de sortie.

Leçon 2 • Ports d'entrée et de sortie

Présente les interfaces de port comme le contrat entre les cas d'utilisation et les adaptateurs. Les étudiants définissent explicitement les ports d'entrée (pilotés) et les ports de sortie (pilotes).

Leçon 3 • Composition et réutilisation des cas d'utilisation

Aborde les scénarios où plusieurs cas d'utilisation partagent des sous-étapes. Enseigne des modèles de composition sûrs qui évitent de coupler les cas d'utilisation entre eux.

Leçon 4 • Test des cas d'utilisation en isolation

Montre comment tester unitairement les Interactors en utilisant des ports de sortie simulés. Valide que la logique des cas d'utilisation est entièrement exerçable sans bases de données ni frameworks web.

Leçon 1 • Contrôleurs et mappage des requêtes

Construit des contrôleurs qui analysent les requêtes entrantes et invoquent les ports d'entrée. Les étudiants maintiennent les contrôleurs légers en déplaçant toute la logique dans les cas d'utilisation.

Leçon 2 • Présentateurs et formatage de la sortie

Implémente le modèle Présentateur pour formater la sortie des cas d'utilisation en vue de sa livraison. Sépare entièrement la construction du modèle de vue de la logique métier.

Leçon 3 • Passerelles et adaptateurs de dépôt

Crée des classes de passerelle qui implémentent les interfaces de port de sortie pour la persistance. Les étudiants connectent des bases de données réelles aux cas d'utilisation sans polluer le noyau.

Leçon 4 • Adaptateurs de services externes

Encapsule les API tierces et les systèmes de messagerie derrière des interfaces de port de sortie. Isole le noyau des SDK spécifiques aux fournisseurs et des protocoles de communication.

Leçon 1 • Injection de dépendances et câblage

Assemble le graphe d'objets complet en utilisant l'injection de dépendances à la racine de composition. Montre comment les conteneurs DI servent la couche la plus externe sans fuir vers l'intérieur.

Leçon 2 • Mécanismes de livraison Web et API

Câble le routage HTTP, la sérialisation et l'intergiciel aux contrôleurs adaptateurs. Montre que le même cas d'utilisation peut servir REST, GraphQL ou CLI sans modifications.

Leçon 3 • Configuration de la base de données et de la persistance

Configure les mappages ORM et les migrations de schéma dans la couche d'infrastructure. Maintient tous les détails technologiques de persistance en dehors des anneaux métier et de cas d'utilisation.

Leçon 1 • Principes de cohésion des composants

Applique les principes d'équivalence Réutilisation/Livraison, de Fermeture Commune et de Réutilisation Commune à l'empaquetage. Les étudiants regroupent les classes en composants qui changent pour une seule raison.

Leçon 2 • Principes de couplage des composants

Applique les principes de Dépendances Acycliques, de Dépendances Stables et d'Abstractions Stables. Les étudiants détectent et brisent les cycles de dépendance entre les composants.

Leçon 3 • Frontières architecturales définies

Distingue les frontières dures (processus séparés) des frontières souples (paquets). Les étudiants choisissent la force de la frontière en fonction de la fréquence des changements et de la propriété de l'équipe.

Leçon 4 • Conception de monolithe modulaire

Structure une unité déployable unique avec de fortes frontières de modules internes. Prépare la base de code pour une future extraction en services sans distribution prématurée.

Leçon 1 • Intégration des préoccupations transversales

Ajoute la journalisation, la sécurité et l'observabilité sans polluer le domaine. Les étudiants appliquent des modèles de décorateur et d'intergiciel pour injecter proprement un comportement transversal.

Leçon 2 • Construire le noyau métier en premier

Implémente les Entités et les Cas d'utilisation avant toute existence d'infrastructure. Valide que le noyau compile et passe les tests avec zéro dépendance externe.

Leçon 3 • Fonctions de fitness architecturales

Écrit des tests automatisés qui vérifient que les règles architecturales restent intactes au fil du temps. Les étudiants intègrent des fonctions de fitness dans les pipelines CI pour prévenir la régression.

Leçon 4 • Configuration et structure du projet

Établit la structure de dossiers, les frontières des modules et la configuration de construction pour un projet d'architecture Clean. Les décisions prises ici appliquent automatiquement la règle de dépendance.