Où va chaque morceau de code ? L'architecture répond : cœur au centre, détails aux bords.
⏱️ Durée : environ 95 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Urbaniste logiciel
🎬 L'histoire
L'application HashBox grandit : pages web, règles de calcul, accès à la base, envoi de mails. Le code se mélange : une page web contient du SQL, une règle métier appelle directement le serveur de mail, et changer de base de données nécessite de modifier cinquante fichiers.
« Il faut décider où vivent les choses, dit Sam, et dans quel sens vont les dépendances. Les règles métier doivent être au centre et ne dépendre de rien. »
Tu apprends les architectures en couches, MVC, hexagonale et les bases de DDD.
🎯 Ta mission
À la fin, je serai capable de :
- décrire l'architecture en couches et sa règle de dépendance
- expliquer MVC et son rôle
- expliquer l'architecture hexagonale (ports et adaptateurs)
- utiliser entités, objets-valeurs et services (bases de DDD)
- construire une petite application dont le cœur ne dépend d'aucun détail technique
🧩 Défi d'échauffement (5 XP)
Une ville est organisée : le centre historique (règles qu'on ne change pas à la légère), les quartiers (usages), les routes et réseaux (électricité, eau) qui peuvent être refaits sans reconstruire les maisons. Si on doit changer de fournisseur d'électricité, veut-on casser les maisons ? Quelles sont les « maisons » et les « réseaux » dans une application ?
💡 Le concept
Architecture en couches
On organise le code en couches empilées, chacune ne dépendant que de celle d'en dessous :
flowchart TD
A["Présentation<br/>(web, CLI, API)"] --> B["Application / services<br/>(cas d'usage)"]
B --> C["Domaine<br/>(règles métier)"]
B --> D["Infrastructure<br/>(base, mail, fichiers)"]
Description du schéma : la présentation appelle la couche application (cas d'usage), qui utilise le domaine (règles métier) et l'infrastructure (base de données, mail, fichiers).
Avantage : séparer les préoccupations. Limite : si le domaine dépend de l'infrastructure, les règles métier sont liées à la base de données.
MVC
Modèle – Vue – Contrôleur sépare une interface en trois rôles :
| Rôle | Responsabilité |
|---|---|
| Modèle | données et règles métier |
| Vue | affichage |
| Contrôleur | reçoit les actions de l'utilisateur, coordonne modèle et vue |
L'architecture hexagonale (ports et adaptateurs)
On inverse la dépendance : le domaine est au centre et ne connaît que des interfaces (les ports). Les détails techniques (adaptateurs) implémentent ces ports.
flowchart LR
Web["Adaptateur web"] --> App
CLI["Adaptateur CLI"] --> App
subgraph Cœur
App["Cas d'usage"] --> Dom["Domaine"]
App --> Port["Ports<br/>(interfaces)"]
end
Port -.implémenté par.-> SQL["Adaptateur SQL"]
Port -.implémenté par.-> Mail["Adaptateur mail"]
Description du schéma : à gauche, des adaptateurs d'entrée (web, ligne de commande) appellent les cas d'usage du cœur. Le cœur contient le domaine et des ports (interfaces). À droite, les adaptateurs de sortie (SQL, mail) implémentent ces ports.
Règle de dépendance : les flèches de dépendance pointent vers le centre. Le domaine ne connaît ni SQL, ni HTTP, ni mail.
Conséquences : on teste le cœur sans infrastructure ; on change de base ou de framework en écrivant un nouvel adaptateur.
Les bases de DDD (Domain-Driven Design)
La conception pilotée par le domaine propose un vocabulaire pour modéliser le métier :
| Concept | Sens | Exemple |
|---|---|---|
| Langage omniprésent | les mots du métier, utilisés partout (code compris) | « inscription », « mission terminée » |
| Entité | objet défini par son identité | Membre (id 42) |
| Objet-valeur | défini par ses valeurs, immuable | Montant(10, "EUR"), Email |
| Agrégat | groupe d'objets modifié comme un tout, via une racine | Commande avec ses lignes |
| Service de domaine | règle qui n'appartient à aucune entité | calcul de remise croisée |
| () |
Les frontières
Une frontière est l'endroit où l'on traduit entre deux modèles ou deux mondes (données HTTP → objets du domaine ; lignes SQL → entités). On valide à la frontière, et à l'intérieur on manipule des objets fiables.
Choisir
| Contexte | Architecture raisonnable |
|---|---|
| Script, prototype | un module, des fonctions |
| Petite application | couches simples |
| Application métier durable | hexagonale avec domaine isolé |
| Très grand système | contextes délimités, services séparés |
🧠 Astuce : une architecture se juge à la facilité des changements probables. Fais la plus simple qui permet de changer de base, d'interface et de règle sans tout casser.
🔍 Exemple pas à pas
Problème : une petite application d'inscriptions en architecture hexagonale, avec deux adaptateurs de stockage et un test du cœur sans infrastructure.
from dataclasses import dataclass
from typing import Protocol
# ===== DOMAINE : aucune dépendance technique =====
@dataclass(frozen=True)
class Email:
valeur: str
def __post_init__(self):
if "@" not in self.valeur or self.valeur.startswith("@") or self.valeur.endswith("@"):
raise ValueError(f"e-mail invalide : {self.valeur!r}")
@dataclass
class Membre:
id: int | None
nom: str
email: Email
cours: set
def s_inscrire(self, code_cours, capacite_max, deja_inscrits):
if code_cours in self.cours:
raise ValueError("déjà inscrit")
if deja_inscrits >= capacite_max:
raise ValueError("cours complet")
self.cours.add(code_cours)
():
() -> Membre: ...
() -> Membre | : ...
() -> : ...
():
() -> : ...
CAPACITE_COURS =
:
():
.depot, .messagerie = depot, messagerie
():
email = Email(adresse)
membre = .depot.par_email(email) Membre(, nom, email, ())
membre.s_inscrire(code_cours, CAPACITE_COURS, .depot.compter_inscrits(code_cours))
membre = .depot.enregistrer(membre)
.messagerie.envoyer(email, )
membre
:
():
._par_email, ._suivant = {},
():
membre. :
membre., ._suivant = ._suivant, ._suivant +
._par_email[membre.email.valeur] = membre
membre
():
._par_email.get(email.valeur)
():
(code m.cours m ._par_email.values())
:
():
.envoyes = []
():
.envoyes.append((email.valeur, texte))
depot, mail = DepotMemoire(), MessagerieEnregistrement()
cas_usage = InscrireMembre(depot, mail)
cas_usage.executer(, , )
cas_usage.executer(, , )
mail.envoyes[] == (, )
erreur, (n, a) ((, (, )), (, (, ))):
:
cas_usage.executer(n, a, )
AssertionError()
ValueError e:
erreur (e)
:
cas_usage.executer(, , )
ValueError e:
(, e)
()
Lecture :
- le domaine (
Email,Membre) contient les règles (cours complet, déjà inscrit) et ne connaît ni base ni mail ; - les ports (
DepotMembres,Messagerie) sont les contrats exigés par le cœur ; - les adaptateurs (
DepotMemoireici, unDepotSQLiteensuite) les implémentent ; Emailest un objet-valeur : s'il existe, il est valide, donc plus besoin de revalider partout ;- le cas d'usage orchestre : valider, charger, appliquer la règle, enregistrer, notifier.
✍️ À toi, avec aide (10 XP)
Ajoute un deuxième adaptateur de stockage à l'exemple : DepotSQLite, qui implémente DepotMembres avec une base SQLite en mémoire (tables membres et inscriptions).
- Implémente
enregistrer,par_email,compter_inscrits. - Fais passer exactement les mêmes vérifications (cours complet, déjà inscrit) à
InscrireMembreavec ce nouveau dépôt. - Que prouve le fait de ne pas avoir touché au cœur ?
💡 Indice 1
Membre a un set de cours : stocke-les dans une table inscriptions(membre_id, cours).
💡 Indice 2
par_email doit reconstruire un Membre complet avec ses cours.
💡 Indice 3
Le cas d'usage reçoit le dépôt par son constructeur : tu n'as rien à y changer.
✅ Réponse
import sqlite3
class DepotSQLite:
def __init__(self):
self._bd = sqlite3.connect(":memory:")
self._bd.executescript('''
CREATE TABLE membres (id INTEGER PRIMARY KEY, nom TEXT NOT NULL, email TEXT NOT NULL UNIQUE);
CREATE TABLE inscriptions (membre_id INTEGER NOT NULL REFERENCES membres(id), cours TEXT NOT NULL, PRIMARY KEY (membre_id, cours));
''')
def enregistrer(self, membre):
with self._bd:
if membre.id is None:
cur = self._bd.execute("INSERT INTO membres (nom, email) VALUES (?, ?)", (membre.nom, membre.email.valeur))
membre.id = cur.lastrowid
self._bd.execute("DELETE FROM inscriptions WHERE membre_id = ?", (membre.id,))
self._bd.executemany("INSERT INTO inscriptions VALUES (?, ?)", [(membre.id, c) for c in membre.cours])
return membre
def par_email(self, email):
ligne = self._bd.execute("SELECT id, nom FROM membres WHERE email = ?", (email.valeur,)).fetchone()
ligne :
cours = {c (c,) ._bd.execute(, (ligne[],))}
Membre(ligne[], ligne[], email, cours)
():
._bd.execute(, (code,)).fetchone()[]
🚀 À toi, en solo (20 XP)
Ajouter une règle métier sans toucher à l'infrastructure. Nouvelle règle : un membre ne peut pas être inscrit à plus de 3 cours simultanément, sauf s'il est « premium » (nouvel attribut booléen).
- Modifie uniquement le domaine (
Membre) et les tests. - Vérifie que les adaptateurs (dépôt, messagerie) n'ont pas besoin d'être changés (à l'exception du stockage de l'attribut
premiumdans l'adaptateur SQL si tu veux le persister). - Écris les tests : 3 cours acceptés, un 4ᵉ refusé, un membre premium accepté.
- Que montre cet exercice sur la valeur de l'architecture ?
✅ Pistes de correction
# Dans Membre :
# premium: bool = False
# def s_inscrire(self, code_cours, capacite_max, deja_inscrits):
# ...règles existantes...
# if not self.premium and len(self.cours) >= 3:
# raise ValueError("limite de 3 cours atteinte")
# self.cours.add(code_cours)
from dataclasses import dataclass, field
@dataclass
class Membre:
id: int | None
nom: str
email: str
cours: set = field(default_factory=set)
premium: bool = False
def s_inscrire(self, code_cours, capacite_max, deja_inscrits):
if code_cours in self.cours:
raise ValueError("déjà inscrit")
if deja_inscrits >= capacite_max:
raise ValueError("cours complet")
if not self.premium and len(self.cours) >= 3:
raise ValueError("limite de 3 cours atteinte")
.cours.add(code_cours)
m = Membre(, , )
code (, , ):
m.s_inscrire(code, , )
:
m.s_inscrire(, , )
AssertionError()
ValueError e:
(e)
p = Membre(, , , premium=)
code (, , , ):
p.s_inscrire(code, , )
(p.cours) ==
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| SQL dans les contrôleurs | Règles métier et accès aux données mélangés | Passer par un port (dépôt) |
| Un domaine qui importe le framework | Impossible à tester seul | Le domaine ne dépend de rien |
| Architecture trop lourde pour un script | Complexité sans bénéfice | Adapter l'architecture à la durée de vie du logiciel |
| Valider partout, ou nulle part | Données invalides à l'intérieur | Valider à la frontière, objets-valeurs ensuite |
🐉 Mini-boss (40 XP)
Application de réservation de salles en architecture hexagonale.
Domaine : Salle (capacité), Reservation (entité), Creneau (objet-valeur : début, fin, valide si fin > début), règle de non-chevauchement.
Ports : DepotReservations, Horloge (pour contrôler le temps dans les tests), Notificateur.
Cas d'usage : ReserverSalle, AnnulerReservation, ListerReservationsDuJour.
Adaptateurs : dépôt mémoire, dépôt SQLite, notificateur console, adaptateur « ligne de commande » qui traduit des textes en appels de cas d'usage.
- Implémente le tout.
- Écris au moins 12 tests du cœur avec uniquement des fakes (chevauchement, annulation, capacité, créneau invalide, horloge fixée).
- Fais passer le même test de contrat aux deux dépôts.
- Dessine (Mermaid) les dépendances et vérifie par un petit script que le domaine n'importe ni
sqlite3nisys.
✅ Pistes de correction
Un bon travail : Creneau est un @dataclass(frozen=True) qui valide dans __post_init__ ; Reservation.chevauche(autre) ; le cas d'usage ReserverSalle récupère les réservations de la salle via le dépôt, refuse en cas de chevauchement, enregistre et notifie ; Horloge.maintenant() permet de refuser les réservations passées sans dépendre de l'heure réelle ; la vérification d'architecture lit les fichiers du domaine avec ast et échoue si un import hors bibliothèque standard « pure » (dataclasses, typing, datetime) est trouvé. Le schéma Mermaid montre les flèches vers le centre.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Dans l'architecture hexagonale, le domaine :
- A. ne dépend d'aucun détail technique
- B. dépend de la base de données
- C. dépend du framework web
2. Un objet-valeur est :
- A. défini par son identité
- B. défini par ses valeurs et immuable
- C. toujours persistant
3. Un port est :
- A. une connexion réseau
- B. un fichier de configuration
- C. une interface exigée par le cœur
4. 🔁 Révision mission 06 : Strategy permet de :
- A. changer d'algorithme sans modifier le code appelant
- B. créer une seule instance
- C. traduire une interface
5. 🔁 Révision mission 06 : Un Adapter :
- A. ajoute de la sécurité
- B. traduit une interface vers celle qu'attend le client
- C. supprime des classes
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Quels éléments de ta vie professionnelle sont « le cœur » (qu'on protège) et lesquels sont des « détails » (qu'on peut remplacer) ?
- Pourquoi valider à la frontière réduit-il les bugs à l'intérieur ?
🎒 À retenir
- Couches : présentation, application, domaine, infrastructure.
- MVC : modèle, vue, contrôleur.
- Hexagonale : domaine au centre, ports et adaptateurs.
- DDD : entités, objets-valeurs, agrégats, dépôts.
- Règle de dépendance : vers le centre.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Urbaniste logiciel
← Mission 06 — Les patrons de conception · Mission 08 — Refactoring sécurisé →
HEF-080 — Génie logiciel

