Quels sont les modèles architecturaux courants (par couches, hexagonal, etc.) ?

Question

Accepted Answer

Au-delà des modèles de conception au niveau des objets, les **modèles architecturaux** définissent la structure de haut niveau des applications — comme **par couches**, **hexagonal (ports et adaptateurs)**, **architecture propre**, et **piloté par les événements**. Ils organisent des systèmes entiers pour la maintenabilité, la testabilité et la flexibilité.

## Architecture par couches (n-tier)

```text
LAYERED → organize the app into horizontal LAYERS, each with a responsibility:
  PRESENTATION (UI) → APPLICATION/business logic → DATA ACCESS → DATABASE
  → each layer depends only on the layer below; clear separation
  ✓ simple, common, organized  ✗ can become rigid; layers can leak; less flexible
```

## Architecture hexagonale / propre

```text
HEXAGONAL (ports & adapters) / CLEAN architecture → the core business logic is ISOLATED
from external concerns (UI, database, frameworks):
  → the DOMAIN/core depends on NOTHING external; external things (DB, UI, APIs) plug in
    via interfaces ("ports") and "adapters"
  → dependencies point INWARD (toward the domain) → the core is independent and testable
  ✓ highly testable, flexible (swap DB/UI/frameworks), domain-focused
  ✗ more complexity/structure (justified for complex domains)
```

## Autres modèles architecturaux

```text
EVENT-DRIVEN → components communicate via events (decoupled, scalable, reactive)
MICROSERVICES → independent services (covered in system design)
MVC/MVVM → UI architecture (covered separately)
CQRS / EVENT SOURCING → separate read/write; events as the source of truth
PIPELINE / pipes-and-filters → data flows through processing stages
→ choose based on the system's complexity, domain, and needs
```

## Pourquoi c'est important

Comprendre les modèles architecturaux courants est une connaissance précieuse au niveau senior car ils définissent **comment les applications entières sont structurées**, affectant significativement la maintenabilité et la flexibilité, donc c'est important pour concevoir des systèmes bien structurés.

Les modèles architecturaux opèrent à un niveau plus élevé que les modèles de conception au niveau des objets, organisant des systèmes entiers.

Comprendre l'**architecture par couches** (organiser en couches horizontales — présentation, logique métier, accès aux données — chacune dépendant de celle en dessous, fournissant une organisation simple et commune mais avec une rigidité potentielle) est fondamental, car c'est la structure d'application la plus courante.

Comprendre l'**architecture hexagonale/propre** est particulièrement précieuse : isoler la logique métier fondamentale des préoccupations externes (interface utilisateur, base de données, frameworks) pour que le domaine ne dépende de rien d'externe tandis que les choses externes se branchent via des ports et adaptateurs, avec les **dépendances pointant vers l'intérieur du domaine** — rendant le cœur indépendant, hautement testable et flexible (capable d'échanger des bases de données, des interfaces utilisateur et des frameworks).

Cette approche centrée sur le domaine est influente dans l'architecture moderne pour les domaines complexes, bien qu'elle ajoute une structure qui doit être justifiée.

Comprendre les **autres modèles architecturaux** — piloté par les événements (découplé, réactif), microservices, MVC/MVVM, **CQRS/event sourcing** (séparant les lectures/écritures, les événements comme source de vérité), et pipeline/pipes-and-filters — élargit la conscience de la façon dont les systèmes peuvent être structurés.

Comprendre ces modèles et **choisir en fonction de la complexité, du domaine et des besoins du système** reflète le jugement architectural pour structurer les applications de manière appropriée.

Les modèles architecturaux affectent significativement la maintenabilité, la testabilité et la flexibilité d'un système — les choisir et les appliquer correctement est une compétence clé au niveau senior.

Étant donné que les modèles architecturaux définissent comment les applications entières sont structurées (affectant significativement la maintenabilité, la testabilité et la flexibilité) et que comprendre les options (par couches, hexagonal/propre, piloté par les événements, CQRS) et choisir de manière appropriée est important pour concevoir des systèmes bien structurés, comprendre les modèles architecturaux courants est une connaissance précieuse au niveau senior — importante pour structurer correctement les applications entières (en particulier l'approche propre/hexagonale influente pour les systèmes testables et centrés sur le domaine), reflétant le jugement architectural attendu des développeurs seniors qui conçoivent la structure du système, et complétant les modèles au niveau des objets par une organisation de plus haut niveau.