Bonjour! Dans cet article, je discuterai brièvement de Clean Architecture et de Golang.

Une introduction

L'architecture propre est un modèle de conception de logiciel populaire qui met l'accent sur la modularité, l'évolutivité et la maintenabilité des systèmes logiciels.

Dans Clean Architecture, nous séparons les préoccupations d'un système logiciel en couches distinctes, chaque couche étant responsable d'un ensemble spécifique de responsabilités.

L'objectif principal de ce modèle de développement logiciel est de réduire le couplage et d'augmenter la cohésion dans un système logiciel, le rendant plus modulaire, testable et maintenable.

Les couches d'architecture propre :

L'architecture propre se compose de quatre couches principales.

1. La couche des entités

Les entités doivent être indépendantes de toute logique d'application spécifique ou de ressources externes et ne doivent dépendre d'aucune autre couche ou module. En d'autres termes, les entités peuvent être considérées comme la définition des modèles de base de données. Bien qu'ils soient différents, les termes « entité » et « modèle » sont liés, mais pas exactement la même chose.

1. La couche des cas d'utilisation :

Les cas d'utilisation doivent être indépendants de toute interface utilisateur spécifique ou de tout système externe, et comme les entités, ils ne doivent dépendre d'aucune autre couche ou module.

1. La couche Interfaces (ou Adaptateurs) :

Cette couche contient l'implémentation métier de l'application et doit être la couche la plus volatile. La couche Adapters (ou Interfaces, encore une fois, c'est la même chose) doit adapter le système externe aux besoins de l'application et vice versa.

La couche Adaptateurs (ou Interfaces) doit être implémentée à l'aide d'interfaces, permettant une substitution facile des composants et un découplage des détails d'implémentation.

1. La couche Frameworks (pilotes) :

Un dernier mot

Il est important de noter que les calques ne doivent dépendre que des calques situés en dessous d'eux. Cela signifie que les entités ne doivent dépendre de rien d'autre, les cas d'utilisation ne doivent dépendre que des entités, les interfaces ne doivent dépendre que des cas d'utilisation et des entités, et les frameworks ne doivent dépendre que des interfaces.

Cela crée une séparation claire des préoccupations et une architecture modulaire facile à maintenir et à faire évoluer.

Résumé de l'architecture propre

En résumé, les couches Clean Architecture offrent une séparation claire des préoccupations, permettant une maintenance et une évolution faciles de l'application. En suivant cette architecture, les développeurs peuvent créer des applications faciles à tester, à maintenir et à étendre.

Architecture propre et langage de programmation Go

Bon, maintenant nous en savons un peu plus sur la Clean Architecture. Voyons un bref exemple de la façon de l'utiliser avec Go

Supposons que nous ayons une application de commerce électronique et que nous souhaitions y mettre en œuvre les principes de l'architecture propre, nous commençons d'abord par les entités

1. La couche des entités

type Cart struct {
    Id string
    UserId string
    ProductId string
    TotalPrice float64
    // And so on...
}

Les cas d'utilisation sont utilisés pour définir la logique métier de l'application, vous pouvez définir chaque cas d'utilisation de chaque partie de l'application (je veux dire les entités) comme des interfaces Go distinctes avec des méthodes qui définissent l'action spécifique qui peut être effectuée sur chaque entité.

type CartUseCase interface {
    AddToCart(productId string, userId string) error
    GetCart(userId string) (*Cart, error)
    // And so on...
}

Cette couche définit la communication entre l'application et le monde extérieur.

Dans le contexte d'une application Web, cette couche est généralement l'endroit où vous définissez vos points de terminaison d'API RESTful et implémentez les gestionnaires qui exécutent les cas d'utilisation définis dans la couche ci-dessous.

type CartHandler interface {
    AddToCart(w http.ResponseWriter, r *http.Request)
    GetCart(w http.ResponseWriter, r *http.Request)
    // And so on...
}

Dans la couche frameworks, vous définissez les détails techniques de l'application, y compris les frameworks Web, les bases de données et d'autres composants techniques.

Par exemple, vous pouvez utiliser Echole framework pour implémenter votre API RESTful, ou utiliser Gorm pour interagir avec la base de données... et ainsi de suite.

En structurant votre application à l'aide de Clean Architecture et de Golang, vous créez une séparation claire des préoccupations et une architecture modulaire facile à maintenir et à faire évoluer. Vous pouvez facilement tester chaque couche de l'application de manière isolée et remplacer n'importe quelle couche par une nouvelle implémentation si nécessaire.

Et oui, c'était une introduction très simple à Clean Architecture et Golang. Je suis encore novice et en apprentissage, j'ai donc décidé d'écrire cet article pour mieux le comprendre. Et je tiens à remercier ChatGPT de m'avoir beaucoup aidé en fournissant des exemples et en corrigeant la grammaire ! :3

Ressources

1. Architecture épurée .
2. Architecture propre et Golang Les avantages .