Cours sur l'architecture propre

Leçon 1 • Couplage, cohésion et limites

Explique comment le couplage et la cohésion déterminent la santé d'un module. Les apprenants apprennent à identifier les violations de limite avant d'écrire une seule ligne d'architecture.

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

Définit l'architecture comme l'ensemble des décisions difficiles à inverser. Ancre ce chapitre en séparant les préoccupations de conception de celles de mise en œuvre.

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

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

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

Retrace l'architecture propre à partir de ses prédécesseurs hexagonale et en 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 et responsabilités autorisées 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 apprenants s'entraînent à tracer les flèches de dépendance pour valider la conformité.

Leçon 1 • Conception d'objets domaine sans framework

Enseigne des techniques pour écrire des Entités sans aucune importation de framework. Les apprenants produisent des objets simples qui peuvent être testés sans démarrer aucune infrastructure.

Leçon 2 • Définition des Entités dans l'architecture propre

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

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

Introduction des racines d'agrégat pour gérer des clusters d'Entités liées. Les apprenants apprennent les limites de cohérence qui protègent les règles métier à travers les graphes d'objets.

Leçon 1 • Implémentation du patron Interacteur

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

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

Présentation des interfaces de port comme contrat entre les cas d'utilisation et les adaptateurs. Les apprenants 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 patrons de composition sûrs qui évitent le couplage entre les cas d'utilisation.

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

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

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

Construit des contrôleurs qui analysent les requêtes entrantes et invoquent les ports d'entrée. Les apprenants gardent 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 patron Présentateur pour formater la sortie des cas d'utilisation en vue de la livraison. Sépare complètement la construction du modèle de vue de la logique métier.

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

Crée des classes de passerelle qui implémentent les interfaces des ports de sortie pour la persistance. Les apprenants connectent de vraies bases de données 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 ports 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

Connecte 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 changement.

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 domaine et cas d'utilisation.

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

Applique les principes d'équivalence Réutilisation/Livraison, Fermeture Commune et Réutilisation Commune au conditionnement. Les apprenants 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, Dépendances Stables et Abstractions Stables. Les apprenants détectent et brisent les cycles de dépendance entre les composants.

Leçon 3 • Limites architecturales définies

Distingue les limites dures (processus séparés) des limites souples (paquetages). Les apprenants choisissent la force de la limite 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 limites internes de modules. Prépare le codebase pour une extraction future 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 apprenants appliquent des patrons de décorateur et d'intergiciel pour injecter proprement le comportement transversal.

Leçon 2 • Construire d'abord le noyau domaine

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

Leçon 3 • Fonctions d'aptitude architecturales

Écrire des tests automatisés qui vérifient que les règles architecturales restent intactes au fil du temps. Les apprenants intègrent les fonctions d'aptitude dans les pipelines CI pour éviter la régression.

Leçon 4 • Configuration et structure du projet

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