Go-apps kunnen veel verschillende soorten broncodebestanden combineren, dus het gebruik van een solide, conventionele structuur heeft veel voordelen.

De hexagonale (of "poorten en adapters") architectuur is een populair software-architectuurpatroon dat u kunt toepassen terwijl u uw Go-apps bouwt. Door het te gebruiken, kunt u de schaalbaarheid, onderhoudbaarheid en testbaarheid van uw app verbeteren.

Deze architectuur helpt bedrijfslogica te scheiden van externe afhankelijkheden en infrastructuur, waardoor uw toepassing flexibel en gemakkelijker te onderhouden is.

Wat is de zeshoekige architectuur?

De hexagonale architectuur verdeelt applicaties in drie hoofdlagen:

  1. DeApplicatielaag herbergt de kernlogica van de toepassing, onafhankelijk van eventuele afhankelijkheden van derden. De applicatielaag moet uw bedrijfslogica, domeinmodellen en applicatieservices bevatten.
  2. DePoorten en adapters laag herbergt de adapters die communiceren met de bestaande applicaties. Poorten zijn interfaces die de bewerkingen voor uw toepassing definiëren, terwijl adapters implementaties van de interfaces zijn. Adapters kunnen databases, HTTP-API's, berichtenmakelaars of andere externe systemen zijn.
    instagram viewer
  3. De infrastructuurlaag herbergt de implementatie van de adapters. De infrastructuurlaag moet databases, berichtenmakelaars en andere externe systemen bevatten.

Voordelen van het gebruik van de zeshoekige architectuur

De zeshoekige architectuur is populair vanwege de volgende voordelen die het biedt.

Projectschaalbaarheid en onderhoudbaarheid

De verdeling van uw applicaties zorgt voor een modulaire en ontkoppelde codebase die het gemakkelijker maakt om uw app te schalen en te onderhouden.

U kunt adapters verwijderen zonder de kernlogica te beïnvloeden en de kernlogica wijzigen zonder de adapters te beïnvloeden. Dit betekent dat u eenvoudig adapters kunt vervangen zonder uw hele applicatie te herschrijven.

Testbaarheid en integratiegemak

De zeshoekige architectuur bevordert de testbaarheid, omdat u unit-tests voor kernlogica kunt schrijven zonder onechte externe afhankelijkheden. U kunt testdubbels, zoals vervalsingen of stubs, gebruiken zonder dat u dat hoeft te doen een databank opzetten of berichtenmakelaar.

De hexagonale architectuur maakt het ook eenvoudig om uw applicatie te integreren met andere systemen. Aangezien de adapters gescheiden zijn van de kernlogica, kunt u ze hergebruiken in andere toepassingen of voor microservices. U kunt ook de API's van de poort van uw toepassing beschikbaar stellen voor gebruik in andere systemen.

Flexibiliteit en aanpassingsvermogen aan veranderende eisen

De zeshoekige architectuur biedt flexibiliteit en aanpassingsvermogen aan veranderende eisen. Aangezien de kernlogica onafhankelijk is van de adapters, kunt u de functionaliteit van de toepassing eenvoudig wijzigen of uitbreiden zonder de adapters te beïnvloeden.

U kunt uw app in de loop van de tijd ontwikkelen door vast te houden aan specifieke externe systemen.

Go en de zeshoekige architectuur

In de kern gaat de zeshoekige architectuur over het scheiden van de kernbedrijfslogica van de applicatie van de infrastructuur, zodat u kunt afhankelijkheden verwisselen zonder de kernlogica van de toepassing aan te tasten, waardoor het eenvoudiger wordt om de sollicitatie.

De typische zeshoekige Go-applicatie gebruikt vier hoofddirectories: cmd, intern, pkg, En leverancier.

De cmd directory bevat de belangrijkste toepassingen voor het project. De code die u hier schrijft, roept doorgaans functies aan van bestanden in de pkg en interne mappen.

De intern directory moet een privé-toepassingscode bevatten waarvan u niet wilt dat gebruikers deze in hun toepassing importeren. De Go-compiler dwingt het interne lay-outpatroon af en u kunt zoveel interne mappen in andere mappen hebben als u wilt. U bent niet beperkt tot een interne directory op het hoogste niveau.

De pkg directory moet de bibliotheekcode bevatten die u door externe toepassingen wilt laten importeren en gebruiken. Hoewel het gebruik van de pkg directory is een gangbare praktijk, het is niet universeel geaccepteerd of afgedwongen.

De leverancier directory moet toepassingsafhankelijkheden bevatten (handmatig of automatisch beheerd). U kunt de ga mod-verkoper opdracht om een /vendor directory om gebruik te maken van de functionaliteiten die Go biedt aan leveranciers.

Implementatie van de zeshoekige architectuur in Go

De bestandsstructuur van uw project is belangrijk bij het implementeren van hexagonale architectuur in elke taal, inclusief Go.

Hier is een voorbeeld van een bestandsstructuur voor het implementeren van de Hexagonal Architecture in Go:

.
├── cmd
│ └── http
│ └── main.go
├── intern
│ ├── adapters
│ │ ├──api
│ │ │ └── api_adapter.go
│ │ └── databank
│ │ └── db_adapter.go
│ ├──-app
│ │ ├── domein
│ │ │ ├── entiteit1.go
│ │ │ └── entiteit2.go
│ │ ├── poorten
│ │ │ ├── invoer
│ │ │ │ ├── input_port1.go
│ │ │ │ └── input_port2.go
│ │ │ └── uitvoer
│ │ │ ├── output_port1.go
│ │ │ └── output_port2.go
│ │ └── toepassingen
│ │ ├── usecase1.go
│ │ └── usecase2.go
├── pkg
│ ├── invoer
│ │ ├── input1.go
│ │ └── input2.go
│ └── uitvoer
│ ├── output1.go
│ └── output2.go
└── verkoper
 ├──module1
 │ ├── bestand1.go
 │ └── bestand2.go
 └──module2
 ├── bestand1.go
 └── bestand2.go

De pkg directory bevat de invoer- en uitvoerpoorten van uw toepassing in dit voorbeeld. U definieert interfaces voor invoer- en uitvoerpoorten in deze bestanden.

De intern directory bevat het toepassingsdomein en use cases. In deze bestanden schrijft u de bedrijfslogica van uw toepassing.

De adapters directory bevat de infrastructuurcode die uw applicatie verbindt met de database en API.

De bestandsstructuur van de zeshoekige architectuur opzetten

Het opzetten van de hexagonale architectuurbestandsstructuur van uw project kan omslachtig zijn, maar u kunt een bash-script schrijven om het maken van mappen te automatiseren.

Voer deze opdracht uit in de werkmap van uw project naar maak een bash-script, zeshoekig.sh, en geef er lees-, schrijf- en uitvoeringsrechten aan:

touch hexagonaal.sh && chmod 777 hexagonaal.sh

Voer deze bash-code in zeshoekig.sh om de bestandsstructuur in uw huidige werkdirectory te maken:

#!/bin/bash
# maak mappen op het hoogste niveau
mkdir cmd interne pkg-leverancier


# creëer cmd/http-directory
mkdir cmd/http


# maak interne mappen aan
mkdir internal/adapters internal/app internal/app/domain internal/app/ports internal/app/ports/input internal/app/ports/output internal/app/usecases


# maak interne / adapters-mappen aan
mkdir intern/adapters/api intern/adapters/database


# maak interne/app/poorten-directories
mkdir internal/app/ports/input internal/app/ports/output


# leverancierslijsten maken
mkdir leverancier/module1 leverancier/module2
# succesbericht afdrukken
echo"Directorystructuur gemaakt."

U kunt dit bash-script uitvoeren met de volgende opdracht:

./hexagonaal.sh

Het bash-programma maakt de mappen en submappen zodat u verder kunt gaan met het maken van bestanden en het schrijven van de bedrijfslogica voor uw toepassing.

De zeshoekige architectuur is handig voor het bouwen van complexe applicaties

Het implementeren van de hexagonale architectuur kan tijdrovend zijn, maar de voordelen wegen op de lange termijn zwaarder dan de kosten. Door zorgen te scheiden en uw code meer modulair te maken, kunt u uw applicaties eenvoudig onderhouden en testen.

Er zijn veel andere architecturale patronen, elk met voor- en nadelen voor het bouwen van flexibele, performante applicaties. Deze omvatten de populaire MVC-architectuur (model, view, controller) voor het maken van webapplicaties.