L’architecture hexagonale (ou « ports et adaptateurs ») est un modèle d’architecture logicielle populaire que vous pouvez appliquer lors de la création de vos applications Go. En l’utilisant, vous pouvez améliorer l’évolutivité, la maintenabilité et la testabilité de votre application.
Cette architecture permet de séparer la logique métier des dépendances externes et de l’infrastructure, ce qui rend votre application flexible et plus facile à maintenir.
Qu’est-ce que l’architecture hexagonale ?
L’architecture hexagonale divise les applications en trois couches principales :
- Le Couche d’application La couche d’application héberge la logique de base de l’application, indépendamment de toute dépendance à l’égard de tiers. La couche d’application doit contenir votre logique d’entreprise, vos modèles de domaine et vos services d’application.
- La couche Couche ports et adaptateurs abrite les adaptateurs qui interagissent avec les applications existantes. Les ports sont des interfaces qui définissent les opérations pour votre application, tandis que les adaptateurs sont des implémentations de ces interfaces. Les adaptateurs peuvent être des bases de données, des API HTTP, des courtiers en messages ou tout autre système externe.
- La couche Infrastructure héberge la mise en œuvre des adaptateurs. La couche infrastructure devrait inclure des bases de données, des courtiers en messages et d’autres systèmes externes.
Avantages de l’architecture hexagonale
L’architecture hexagonale est appréciée pour les avantages suivants qu’elle offre.
Évolutivité et maintenabilité du projet
La division de vos applications permet une base de code modulaire et découplée qui facilite l’évolution et la maintenance de votre application.
Vous pouvez supprimer les adaptateurs sans affecter la logique de base et modifier la logique de base sans affecter les adaptateurs. Cela signifie que vous pouvez facilement remplacer les adaptateurs sans réécrire l’ensemble de votre application.
Testabilité et facilité d’intégration
L’architecture hexagonale favorise la testabilité puisque vous pouvez écrire des tests unitaires pour la logique de base sans simuler de dépendances externes. Vous pouvez utiliser des doubles de test, tels que des fakes ou des stubs, sans avoir à mettre en place une base de données ou un courtier de messages.
L’architecture hexagonale facilite également l’intégration de votre application avec d’autres systèmes. Comme les adaptateurs sont séparés de la logique de base, vous pouvez les réutiliser dans d’autres applications ou pour des microservices. Vous pouvez également exposer les API du port de votre application pour qu’elles soient consommées par d’autres systèmes.
Flexibilité et adaptabilité à l’évolution des besoins
L’architecture hexagonale offre souplesse et adaptabilité à l’évolution des besoins. Comme la logique de base est indépendante des adaptateurs, vous pouvez facilement modifier ou étendre la fonctionnalité de l’application sans affecter les adaptateurs.
Vous pouvez faire évoluer votre application au fil du temps, en vous limitant à des systèmes externes spécifiques.
Go et l’architecture hexagonale
À la base, l’architecture hexagonale consiste à séparer la logique métier de l’application de l’infrastructure, de sorte que vous puissiez remplacer les dépendances sans affecter la logique de base de l’application, ce qui facilite la maintenance et le test de l’application.
L’application Go hexagonale typique utilise quatre répertoires principaux : cmd, interne, pkget vendeur.
Les cmd contient les principales applications du projet. Le code que vous écrivez ici appellera généralement des fonctions des fichiers des répertoires pkg et internal.
Le répertoire interne doit contenir le code d’une application privée que vous ne voulez pas que les utilisateurs importent dans leur application. Le compilateur Go applique le modèle de disposition interne, et vous pouvez avoir autant de répertoires internes dans d’autres répertoires que vous le souhaitez. Vous n’êtes pas limité à un répertoire interne de premier niveau.
L’option pkg doit contenir le code de la bibliothèque que vous souhaitez que les applications externes importent et utilisent. Bien que l’utilisation du répertoire pkg L’utilisation de l’annuaire des entreprises est une pratique courante, mais elle n’est pas universellement acceptée ou mise en œuvre.
Le vendeur doit contenir les dépendances de l’application (gérées manuellement ou automatiquement). Vous pouvez utiliser le répertoire go mod vendor pour créer un /vendeur afin d’exploiter les fonctionnalités que Go offre aux vendeurs.
Implémentation de l’architecture hexagonale en Go
La structure des fichiers de votre projet est importante lors de l’implémentation de l’architecture hexagonale dans n’importe quel langage, y compris Go.
Voici un exemple de structure de fichier pour la mise en œuvre de l’architecture hexagonale en Go :
.
├── cmd
│ └── http
│ └── main.go
├── internal
│ ├── adapters
│ │ ├── api
│ │ │ └── api_adapter.go
│ │ └── database
│ │ └── db_adapter.go
│ ├── app
│ │ ├── domain
│ │ │ ├── entity1.go
│ │ │ └── entity2.go
│ │ ├── ports
│ │ │ ├── input
│ │ │ │ ├── input_port1.go
│ │ │ │ └── input_port2.go
│ │ │ └── output
│ │ │ ├── output_port1.go
│ │ │ └── output_port2.go
│ │ └── usecases
│ │ ├── usecase1.go
│ │ └── usecase2.go
├── pkg
│ ├── input
│ │ ├── input1.go
│ │ └── input2.go
│ └── output
│ ├── output1.go
│ └── output2.go
└── vendor
├── module1
│ ├── file1.go
│ └── file2.go
└── module2
├── file1.go
└── file2.go
Le fichier pkg contient les ports d’entrée et de sortie de votre application dans cet exemple. Vous définirez les interfaces des ports d’entrée et de sortie dans ces fichiers.
Le fichier interne contient le domaine d’application et les cas d’utilisation. C’est dans ces fichiers que vous écrirez la logique commerciale de votre application.
Le répertoire adaptateurs contient le code d’infrastructure qui connecte votre application à la base de données et à l’API.
Configuration de la structure des fichiers de l’architecture hexagonale
La mise en place de la structure de fichiers de l’architecture hexagonale de votre projet peut être fastidieuse, mais vous pouvez écrire un script bash pour automatiser le processus de création des répertoires.
Exécutez cette commande dans le répertoire de travail de votre projet pour créer un script bash, hexagonal.shet lui accorder les droits de lecture, d’écriture et d’exécution :
touch hexagonal.sh && chmod 777 hexagonal.sh
Entrez ce code bash dans hexagonal.sh pour créer la structure du fichier dans votre répertoire de travail actuel :
#!/bin/bash
# create top level directories
mkdir cmd internal pkg vendor
# create cmd/http directory
mkdir cmd/http
# create internal directories
mkdir internal/adapters internal/app internal/app/domain internal/app/ports internal/app/ports/input internal/app/ports/output internal/app/usecases
# create internal/adapters directories
mkdir internal/adapters/api internal/adapters/database
# create internal/app/ports directories
mkdir internal/app/ports/input internal/app/ports/output
# create vendor directories
mkdir vendor/module1 vendor/module2
# print success message
echo "Directory structure created successfully."
Vous pouvez exécuter ce script bash avec la commande suivante :
./hexagonal.sh
Le programme bash crée les dossiers et les sous-dossiers afin que vous puissiez créer des fichiers et écrire la logique métier de votre application.
L’architecture hexagonale est pratique pour construire des applications complexes
La mise en œuvre de l’architecture hexagonale peut prendre du temps, mais les avantages l’emportent sur le coût à long terme. En séparant les préoccupations et en rendant votre code plus modulaire, vous pouvez facilement maintenir et tester vos applications.
Il existe de nombreux autres modèles architecturaux, chacun présentant des avantages et des inconvénients pour la création d’applications flexibles et performantes. Il s’agit notamment de l’architecture MVC (modèle, vue, contrôleur), très répandue pour la création d’applications web.