Go-apper kan kombinere mange forskjellige typer kildekodefiler, så bruk av en solid, konvensjonell struktur har mange fordeler.

Den sekskantede (eller "porter og adaptere") arkitektur er et populært programvarearkitekturmønster du kan bruke mens du bygger Go-appene dine. Ved å bruke den kan du forbedre appens skalerbarhet, vedlikeholdbarhet og testbarhet.

Denne arkitekturen hjelper med å skille forretningslogikk fra eksterne avhengigheter og infrastruktur, noe som gjør applikasjonen din fleksibel og enklere å vedlikeholde.

Hva er den sekskantede arkitekturen?

Den sekskantede arkitekturen deler applikasjoner inn i tre hovedlag:

  1. DePåføringslag inneholder applikasjonens kjernelogikk uavhengig av eventuelle tredjepartsavhengigheter. Applikasjonslaget bør inneholde forretningslogikken din, domenemodeller og applikasjonstjenester.
  2. DeLaget porter og adaptere inneholder adaptere som samhandler med eksisterende applikasjoner. Porter er grensesnitt som definerer operasjonene for applikasjonen din, mens adaptere er implementeringer av grensesnittene. Adaptere kan være databaser, HTTP APIer, meldingsmeglere eller et hvilket som helst annet eksternt system.
  3. Infrastrukturlaget huser implementeringen av adaptere. Infrastrukturlaget bør inkludere databaser, meldingsmeglere og andre eksterne systemer.

Fordeler med å bruke den sekskantede arkitekturen

Den sekskantede arkitekturen er populær for følgende fordeler den gir.

Prosjekt skalerbarhet og vedlikehold

Inndelingen av applikasjonene dine gir mulighet for en modulær og frakoblet kodebase som gjør det enklere å skalere og vedlikeholde appen din.

Du kan fjerne adaptere uten å påvirke kjernelogikken og endre kjernelogikken uten å påvirke adapterene. Dette betyr at du enkelt kan bytte ut adaptere uten å skrive om hele applikasjonen.

Testbarhet og enkel integrering

Den sekskantede arkitekturen fremmer testbarhet siden du kan skrive enhetstester for kjernelogikk uten falske eksterne avhengigheter. Du kan bruke testdobler, som forfalskninger eller stubber, uten å måtte sette opp en database eller meldingsmegler.

Den sekskantede arkitekturen gjør det også enkelt å integrere applikasjonen din med andre systemer. Siden adaptere er atskilt fra kjernelogikk, kan du gjenbruke dem i andre applikasjoner eller for mikrotjenester. Du kan også eksponere applikasjonens ports API-er for forbruk i andre systemer.

Fleksibilitet og tilpasningsevne til endrede krav

Den sekskantede arkitekturen gir fleksibilitet og tilpasningsevne til endrede krav. Siden kjernelogikken er uavhengig av adapterene, kan du enkelt endre eller utvide applikasjonens funksjonalitet uten å påvirke adapterene.

Du kan utvikle appen din over tid ved å holde deg til spesifikke eksterne systemer.

Gå og den sekskantede arkitekturen

I kjernen handler den sekskantede arkitekturen om å skille applikasjonens kjernevirksomhetslogikk fra infrastruktur slik at du kan bytte ut avhengigheter uten å påvirke applikasjonens kjernelogikk, noe som gjør det enklere å vedlikeholde og teste applikasjon.

Den typiske sekskantede Go-applikasjonen bruker fire hovedkataloger: cmd, innvendig, pkg, og Leverandør.

De cmd katalogen inneholder hovedapplikasjonene for prosjektet. Koden du skriver her vil typisk kalle opp funksjoner fra filer i pkg og interne kataloger.

De innvendig katalogen skal inneholde en privat applikasjonskode du ikke vil at brukerne skal importere til applikasjonen deres. Go-kompilatoren håndhever det interne layoutmønsteret, og du kan ha så mange interne kataloger i andre kataloger du vil. Du er ikke begrenset til en intern katalog på toppnivå.

De pkg katalogen skal inneholde bibliotekkoden du vil at eksterne applikasjoner skal importere og bruke. Selv om du bruker pkg katalog er vanlig praksis, den er ikke universelt akseptert eller håndhevet.

De Leverandør katalogen skal inneholde applikasjonsavhengigheter (manuelt eller automatisk administrert). Du kan bruke go mod-leverandør kommando for å lage en /vendor katalog for å utnytte funksjonene Go gir for leverandører.

Implementering av den sekskantede arkitekturen i Go

Prosjektets filstruktur er viktig når du implementerer sekskantet arkitektur på alle språk, inkludert Go.

Her er et eksempel på en filstruktur for implementering av Hexagonal Architecture in Go:

.
├── cmd
│ └── http
│ └── main.go
├── intern
│ ├── adaptere
│ │ ├── api
│ │ │ └── api_adapter.go
│ │ └── database
│ │ └── db_adapter.go
│ ├── app
│ │ ├── domene
│ │ │ ├── entity1.go
│ │ │ └── entity2.go
│ │ ├── porter
│ │ │ ├── inngang
│ │ │ │ ├── input_port1.go
│ │ │ │ └── input_port2.go
│ │ │ └── utgang
│ │ │ ├── output_port1.go
│ │ │ └── output_port2.go
│ │ └── bruksområder
│ │ ├── usecase1.go
│ │ └── usecase2.go
├── pk
│ ├── inngang
│ │ ├── input1.go
│ │ └── input2.go
│ └── utgang
│ ├── utgang1.go
│ └── output2.go
└── leverandør
 ├── modul1
 │ ├── file1.go
 │ └── file2.go
 └── modul2
 ├── file1.go
 └── file2.go

De pkg katalogen inneholder applikasjonens inngangs- og utgangsporter i dette eksemplet. Du definerer grensesnitt for inngangs- og utgangsporter i disse filene.

De innvendig katalogen inneholder applikasjonsdomenet og brukstilfeller. Du skriver applikasjonens forretningslogikk i disse filene.

De adaptere katalogen inneholder infrastrukturkoden som kobler applikasjonen din til databasen og API.

Sette opp den sekskantede arkitekturfilstrukturen

Å sette opp prosjektets sekskantede arkitekturfilstruktur kan være tungvint, men du kan skrive et bash-skript for å automatisere katalogopprettingsprosessen.

Kjør denne kommandoen i prosjektets arbeidskatalog til lage et bash-skript, hexagonal.sh, og gi tillatelser til å lese, skrive og utføre den:

trykk på hexagonal.sh && chmod 777 hexagonal.sh

Skriv inn denne bash-koden hexagonal.sh for å lage filstrukturen i din nåværende arbeidskatalog:

#!/bin/bash
# lag kataloger på toppnivå
mkdir cmd intern pkg-leverandør


# opprett cmd/http-katalog
mkdir cmd/http


# opprette interne kataloger
mkdir intern/adaptere intern/app intern/app/domene intern/app/porter intern/app/porter/inngang intern/app/porter/utgang intern/app/brukssaker


# opprett interne/adapterkataloger
mkdir intern/adaptere/api intern/adaptere/database


# opprett interne/app/porter-kataloger
mkdir intern/app/porter/inngang intern/app/porter/utgang


# opprett leverandørkataloger
mkdir leverandør/modul1 leverandør/modul2
# skriv ut suksessmelding
ekko"Katalogstruktur opprettet vellykket."

Du kan kjøre dette bash-skriptet med følgende kommando:

./hexagonal.sh

Bash-programmet oppretter mappene og undermappene slik at du kan fortsette å lage filer og skrive forretningslogikken for applikasjonen din.

Den sekskantede arkitekturen er nyttig for å bygge komplekse applikasjoner

Implementering av den sekskantede arkitekturen kan være tidkrevende, men fordelene oppveier kostnadene i det lange løp. Ved å skille bekymringer og gjøre koden din mer modulær, kan du enkelt vedlikeholde og teste applikasjonene dine.

Det er mange andre arkitektoniske mønstre, hver med fordeler og ulemper for å bygge fleksible, effektive applikasjoner. Disse inkluderer den populære MVC-arkitekturen (modell, visning, kontroller) for å lage webapplikasjoner.