Introduction

L'architecture hexagonale, également connue sous le nom de Ports and Adapters, est un concept puissant qui permet de développer des applications PHP robustes et flexibles. En séparant clairement le domaine métier des détails d'implémentation, cette architecture facilite les tests, permet le développement piloté par le domaine (DDD) et rend l'application résiliente aux changements technologiques.

Les principes fondamentaux de l'architecture hexagonale

L'architecture hexagonale repose sur trois principes fondamentaux :

• 🔷 Séparation du domaine métier : le cœur de l'application, qui représente les règles métier essentielles, est isolé du code d'infrastructure et des détails d'implémentation.
• 🔷 Inversion des dépendances : les dépendances sont inversées, ce qui signifie que les composants de l'application ne dépendent pas directement des détails d'implémentation, mais des interfaces définies par les ports.
• 🔷 Adaptateurs interchangeables : les adaptateurs, responsables de l'interaction avec l'extérieur de l'application (UI, API, persistance, services externes), sont interchangeables et peuvent être facilement remplacés.

Structure d'une application hexagonale

Une application hexagonale est structurée autour de trois concepts clés :

• 🔌 Le domaine : c'est le cœur de l'application, où résident les règles métier et la logique de l'application. Il est isolé et ne dépend pas des détails d'implémentation.
• 🔌 Les ports : ce sont des interfaces définissant les entrées et les sorties de l'application. Ils permettent d'interagir avec le domaine et servent de contrat entre les adaptateurs et le domaine.
• 🔌 Les adaptateurs : ce sont des composants responsables de l'interaction avec l'extérieur de l'application. Ils implémentent les interfaces définies par les ports et permettent d'adapter les données et les appels aux besoins spécifiques de chaque technologie.

Avantages de l'architecture hexagonale

L'architecture hexagonale présente de nombreux avantages :

• ✅ Facilité de test : grâce à la séparation claire des responsabilités, il est plus facile de tester chaque composant de manière isolée et de simuler différents scénarios.
• ✅ Développement piloté par le domaine : en se concentrant sur le cœur métier de l'application, l'architecture hexagonale permet de développer des fonctionnalités qui répondent directement aux besoins métier.
• ✅ Résilience aux changements technologiques : en isolant le domaine des détails d'implémentation, l'architecture hexagonale rend l'application plus flexible et résiliente aux changements technologiques.

Implémentation d'une application en architecture hexagonale

Pour illustrer l'implémentation complète d'une application en architecture hexagonale, prenons l'exemple d'une application de gestion de tâches.

Structure de l'application

 ├── src │   ├── Domain │   │   ├── Task.php │   │   ├── TaskRepositoryInterface.php │   │   └── TaskServiceInterface.php │   ├── Application │   │   ├── TaskService.php │   │   └── TaskServiceInterface.php │   ├── Infrastructure │   │   ├── Persistence │   │   │   ├── DatabaseTaskRepository.php │   │   │   └── FileTaskRepository.php │   │   └── ExternalServices │   │       ├── EmailService.php │   │       └── MessageQueueService.php │   └── UI │       └── Web │           ├── Controllers │           │   ├── TaskController.php │           │   └── AuthController.php │           └── Templates │               ├── task_list.twig │               └── task_details.twig ├── tests │   ├── Domain │   │   └── TaskTest.php │   ├── Application │   │   └── TaskServiceTest.php │   └── Infrastructure │       ├── Persistence │       │   ├── DatabaseTaskRepositoryTest.php │       │   └── FileTaskRepositoryTest.php │       └── ExternalServices │           ├── EmailServiceTest.php │           └── MessageQueueServiceTest.php └── index.php 

Domain

Le domaine de l'application contient les règles métier et la logique de l'application.

 // src/Domain/Task.php  class Task {     private \$id;     private \$title;     private \$completed;     // ... }  interface TaskRepositoryInterface {     public function save(Task \$task): void;     public function getById(string \$id): Task;     // ... }  interface TaskServiceInterface {     public function createTask(string \$title): Task;     public function markTaskAsCompleted(Task \$task): void;     // ... } 

Application

La couche d'application contient les cas d'utilisation de l'application. Elle utilise les services du domaine pour effectuer des opérations spécifiques.

 // src/Application/TaskService.php  class TaskService implements TaskServiceInterface {     private \$taskRepository;     // ...     public function createTask(string \$title): Task     {         \$task = new Task(\$title);         \$this->taskRepository->save(\$task);         return \$task;     }     // ... } 

Infrastructure

La couche d'infrastructure est responsable de l'interaction avec l'extérieur de l'application. Elle implémente les interfaces définies par les ports.

 // src/Infrastructure/Persistence/DatabaseTaskRepository.php  class DatabaseTaskRepository implements TaskRepositoryInterface {     // ...     public function save(Task \$task): void     {         // Code pour sauvegarder la tâche dans la base de données     }     public function getById(string \$id): Task     {         // Code pour récupérer une tâche par son ID dans la base de données     }     // ... }  // src/Infrastructure/ExternalServices/EmailService.php  class EmailService {     // ...     public function sendEmail(string \$to, string \$subject, string \$body): void     {         // Code pour envoyer un e-mail     }     // ... } 

UI

La couche UI est responsable de l'interface utilisateur de l'application. Dans notre exemple, nous utiliserons une interface web.

 // src/UI/Web/Controllers/TaskController.php  class TaskController {     private \$taskService;     // ...     public function create(Request \$request, Response \$response): Response     {         \$title = \$request->getParam('title');         \$task = \$this->taskService->createTask(\$title);         // ...     }     // ... } 

Conclusion

L'architecture hexagonale est une approche puissante pour développer des applications PHP flexibles et résilientes. En séparant clairement le domaine métier des détails d'implémentation, cette architecture facilite les tests, permet le développement piloté par le domaine (DDD) et rend l'application résistante aux changements technologiques. En suivant les principes fondamentaux de l'architecture hexagonale et en utilisant une structure claire avec des ports et des adaptateurs, vous pouvez créer des applications évolutives et maintenables.

Projet guidé : Développement d'une application de gestion de tâches

Pour mettre en pratique les concepts de l'architecture hexagonale, nous vous proposons de développer une application de gestion de tâches en utilisant cette approche. Vous pouvez choisir différentes technologies pour les adaptateurs (persistance, interface utilisateur) et suivre les principes de l'architecture hexagonale pour structurer l'application.

", "meta_title": "Développez vos compétences en PHP : Architecture hexagonale (Ports and Adapters)", "meta_description": "Découvrez l'architecture hexagonale (Ports and Adapters) en PHP et apprenez à développer des applications robustes et flexibles. Séparez le domaine métier, inversez les dépendances et utilisez des adaptateurs interchangeables. Obtenez des exemples de code et suivez un projet guidé pour mettre en pratique ces concepts.", "meta_keywords": "PHP, architecture hexagonale, ports and adapters, développement piloté par le domaine, DDD, tests, adaptateurs interchangeables" }