L’architecture hexagonale (ou architecture en ports et adaptateurs) est un paradigme de conception logicielle visant à rendre les applications plus flexibles, maintenables et testables. Elle découple le cœur métier d’une application des éléments externes tels que les bases de données, interfaces utilisateur, ou API. Cette séparation permet d’adapter facilement les interfaces externes sans affecter la logique métier.
Principes de l'architecture hexagonale
- Domain-Centric : Le domaine métier est au centre de l’architecture.
- Ports et Adaptateurs :
Les ports définissent des interfaces pour interagir avec le domaine métier.
Les adaptateurs implémentent ces interfaces pour des interactions concrètes avec des services externes. - Indépendance technique : Le domaine métier n’a pas de dépendance directe sur les frameworks ou outils externes.
Structure dans un projet Spring Boot
L’architecture hexagonale est souvent organisée autour de trois couches principales :
- Core (Domaine métier) :
- Contient la logique métier pure.
- Exemples : Services, règles métier, entités (Domain Models).
- Ports (Interfaces) :
- Définit les interactions que le cœur métier permet ou requiert.
- Types :
- Ports primaires : Interfaces exposées par le domaine (e.g.,
Service). - Ports secondaires : Interfaces utilisées par le domaine (e.g.,
Repository).
- Ports primaires : Interfaces exposées par le domaine (e.g.,
- Adaptateurs (Infrastructure) :
- Implémente les ports pour interagir avec le monde extérieur.
- Exemples : API REST, bases de données, fichiers.
Exemple de mise en œuvre dans un projet Spring Boot
1. Structure des Packages
src/main/java/com/exemple/projet
├── core
│ ├── model // Entités métier
│ ├── ports // Interfaces (Ports primaires et secondaires)
│ └── services // Logique métier
├── adapters
│ ├── persistence // Accès aux bases de données
│ ├── rest // API REST
│ └── other // Autres services externes (e.g., Messaging)
└── application
├── config // Configuration Spring
├── controllers // Contrôleurs REST
└── dto // Objets de transfert de données
2. Exemple de Code
a) Domaine métier (core.model et core.services)
public class Transaction {
private final String id;
private final double montant;
public Transaction(String id, double montant) {
this.id = id;
this.montant = montant;
}
public double appliquerTaxe(double taux) {
return montant * (1 + taux);
}
// Getters
}
b) Ports (core.ports)
public interface TransactionRepository {
void sauvegarder(Transaction transaction);
Transaction trouverParId(String id);
}
c) Adaptateur (adapters.persistence)
@Repository
public class TransactionJpaRepository implements TransactionRepository {
private final JpaTransactionRepository jpaRepository;
public TransactionJpaRepository(JpaTransactionRepository jpaRepository) {
this.jpaRepository = jpaRepository;
}
@Override
public void sauvegarder(Transaction transaction) {
jpaRepository.save(new TransactionEntity(transaction.getId(), transaction.getMontant()));
}
@Override
public Transaction trouverParId(String id) {
return jpaRepository.findById(id)
.map(entity -> new Transaction(entity.getId(), entity.getMontant()))
.orElseThrow(() -> new RuntimeException("Transaction non trouvée"));
}
}
Avantages de l'architecture hexagonale
- Facilité de test : La logique métier peut être testée indépendamment des couches externes.
- Extensibilité : Ajouter ou remplacer un adaptateur (e.g., changer la base de données ou l’API) sans impacter le cœur métier.
- Maintenabilité : Un code bien structuré et découplé est plus facile à maintenir.
L’architecture hexagonale est particulièrement utile dans des projets complexes comme ceux basés sur Spring Boot. Elle améliore la modularité et garantit que le cœur métier reste robuste face aux changements dans les technologies ou outils externes.
