Les applications Go peuvent combiner de nombreux types de fichiers de code source différents. L'utilisation d'une structure solide et conventionnelle présente donc de nombreux avantages.
L'architecture hexagonale (ou "ports et adaptateurs") est un modèle d'architecture logicielle populaire que vous pouvez appliquer lorsque vous créez vos applications Go. En l'utilisant, vous pouvez améliorer l'évolutivité, la maintenabilité et la testabilité de votre application.
Cette architecture aide à séparer la logique métier des dépendances externes et de l'infrastructure, ce qui rend votre application flexible et plus facile à entretenir.
Qu'est-ce que l'architecture hexagonale?
L'architecture hexagonale divise les applications en trois couches principales :
- LeCouche d'application héberge la logique de base de l'application indépendamment de toute dépendance tierce. La couche d'application doit contenir votre logique métier, vos modèles de domaine et vos services d'application.
- LeCouche ports et adaptateurs abrite les adaptateurs interagissant avec les applications existantes. Les ports sont des interfaces qui définissent les opérations de votre application, tandis que les adaptateurs sont des implémentations des interfaces. Les adaptateurs peuvent être des bases de données, des API HTTP, des courtiers de messages ou tout autre système externe.
- La couche infrastructure abrite la mise en œuvre des adaptateurs. La couche d'infrastructure doit inclure des bases de données, des courtiers de messages et d'autres systèmes externes.
Avantages de l'utilisation de l'architecture hexagonale
L'architecture hexagonale est populaire 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 la mise à l'échelle et la maintenance de votre application.
Vous pouvez supprimer des adaptateurs sans affecter la logique centrale et modifier la logique centrale sans affecter les adaptateurs. Cela signifie que vous pouvez facilement remplacer les adaptateurs sans réécrire l'intégralité 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 fausses dépendances externes. Vous pouvez utiliser des doublons de test, tels que des faux ou des talons, sans avoir à mettre en place une base de données ou courtier de messages.
L'architecture hexagonale facilite également l'intégration de votre application avec d'autres systèmes. Étant donné que les adaptateurs sont distincts de la logique principale, 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 les utiliser dans d'autres systèmes.
Flexibilité et adaptabilité aux exigences changeantes
L'architecture hexagonale offre flexibilité et adaptabilité aux exigences changeantes. Étant donné que la logique de base est indépendante des adaptateurs, vous pouvez facilement modifier ou étendre les fonctionnalités de l'application sans affecter les adaptateurs.
Vous pouvez faire évoluer votre application au fil du temps, en vous en tenant à des systèmes externes spécifiques.
Go et l'architecture hexagonale
À la base, l'architecture hexagonale consiste à séparer la logique métier de base de l'application de l'infrastructure afin que vous pouvez échanger les dépendances sans affecter la logique de base de l'application, ce qui facilite la maintenance et le test du application.
L'application Go hexagonale typique utilise quatre répertoires principaux: commande, interne, paquet, et fournisseur.
Le commande répertoire contient les principales applications du projet. Le code que vous écrivez ici appellera généralement des fonctions à partir de fichiers dans les répertoires pkg et internal.
Le interne Le répertoire doit contenir un code d'application privé que vous ne souhaitez pas que les utilisateurs importent dans leur application. Le compilateur Go applique le modèle de mise en page 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 niveau supérieur.
Le paquet Le répertoire doit contenir le code de la bibliothèque que vous souhaitez que les applications externes importent et utilisent. Bien qu'utilisant le paquet répertoire est une pratique courante, il n'est pas universellement accepté ou appliqué.
Le fournisseur Le répertoire doit contenir les dépendances de l'application (gérées manuellement ou automatiquement). Vous pouvez utiliser le aller vendeur de mod commande pour créer un /vendor répertoire pour tirer parti des fonctionnalités que Go fournit aux fournisseurs.
Implémentation de l'architecture hexagonale dans Go
La structure de fichiers de votre projet est importante lors de la mise en œuvre d'une architecture hexagonale dans n'importe quel langage, y compris Go.
Voici un exemple de structure de fichier pour implémenter l'architecture hexagonale dans Go :
.
├── cmd
│ └── http
│ └── main.go
├── interne
│ ├── adaptateurs
│ │ ├── API
│ │ │ └── api_adapter.go
│ │ └── base de données
│ │ └── db_adapter.go
│ ├── appli
│ │ ├── domaine
│ │ │ ├── entity1.go
│ │ │ └── entity2.go
│ │ ├── ports
│ │ │ ├── entrée
│ │ │ │ ├── input_port1.go
│ │ │ │ └── input_port2.go
│ │ │ └── sortie
│ │ │ ├── output_port1.go
│ │ │ └── sortie_port2.go
│ │ └── cas d'utilisation
│ │ ├── usecase1.go
│ │ └── usecase2.go
├── paquet
│ ├── entrée
│ │ ├── input1.go
│ │ └── input2.go
│ └── sortie
│ ├── sortie1.go
│ └── sortie2.go
└── vendeur
├── module1
│ ├── fichier1.go
│ └── fichier2.go
└── module2
├── fichier1.go
└── fichier2.go
Le paquet Le répertoire contient les ports d'entrée et de sortie de votre application dans cet exemple. Vous allez définir des interfaces pour les ports d'entrée et de sortie dans ces fichiers.
Le interne répertoire contient le domaine d'application et les cas d'utilisation. Vous écrirez la logique métier de votre application dans ces fichiers.
Le adaptateurs Le répertoire contient le code d'infrastructure qui connecte votre application à la base de données et à l'API.
Configuration de la structure de fichiers d'architecture hexagonale
La configuration de la structure de fichiers d'architecture hexagonale de votre projet peut être fastidieuse, mais vous pouvez écrire un script bash pour automatiser le processus de création de répertoires.
Exécutez cette commande dans le répertoire de travail de votre projet pour créer un script bash, hexagonale.sh, et accordez-lui des autorisations de lecture, d'écriture et d'exécution :
toucher hexagonal.sh && chmod 777 hexagonal.shEntrez ce code bash dans hexagonale.sh pour créer la structure de fichiers dans votre répertoire de travail actuel :
#!/bin/bash# créer des répertoires de niveau supérieur
mkdir cmd fournisseur de pkg interne# créer un répertoire cmd/http
mkdircmd/http# créer des répertoires internes
mkdir interne/adaptateurs interne/application interne/application/domaine interne/application/ports interne/application/ports/entrée interne/application/ports/sortie interne/application/cas d'utilisation# créer des répertoires internes/adaptateurs
mkdir interne/adaptateurs/api interne/adaptateurs/base de données# créer des répertoires internes/app/ports
mkdir interne/application/ports/entrée interne/application/ports/sortie# créer des répertoires de fournisseurs
mkdir fournisseur/module1 fournisseur/module2
# imprimer le message de réussite
écho"Structure de répertoires créée avec succès."
Vous pouvez exécuter ce script bash avec la commande suivante :
./hexagonal.sh
Le programme bash crée les dossiers et sous-dossiers afin que vous puissiez continuer à créer des fichiers et écrire la logique métier de votre application.
L'architecture hexagonale est pratique pour créer 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 populaire MVC (modèle, vue, contrôleur) pour la création d'applications Web.