4 Go Web-rutere for din neste nettapp

Nettruting er en teknikk for å tilordne HTTP-forespørsler til behandlerfunksjoner som opererer på den angitte URL-banen. Ruting brukes ofte til å bygge enkeltsideapplikasjoner (SPA-er) og API-er. I ruteren definerer koden rekkefølgen av handlinger som følger med en brukers forespørsel.

Go-standardbiblioteket har det meste av funksjonaliteten du trenger for å bygge nettapplikasjoner, inkludert ruting. Du kan bruke ServeMux skriv inn net/http pakke for grunnleggende rutehåndtering. Hvis du trenger mer kompleks rutehåndtering, er det mange rutepakker å velge mellom.

Komme i gang med Ruting in Go

Gos økosystem er hjemsted for rutingpakker som abstraherer det unødvendige og gjør det enklere å bygge nettapplikasjoner og tjenester.

Mange Go-nettrammeverk implementerer noen av disse rutingpakkene.

Her er en enkel strukturmodell for JSON svar du vil returnere til klienten i denne opplæringen.

type Info struktur {
 Beskjed streng`json:"melding"`
 Beskrivelse streng`json:"beskrivelse"`
}

De fleste Go-rutere bruker fortsatt nett/http ResponseWriter og Be om metoder som parametere i behandlerfunksjoner.

funcHallo(skribent http. ResponseWriter, be om *http. Be om) {
// handler funksjon forretningslogikk her
}

Du må også starte en server med ListenAndServe metode for å starte opp serveren i de fleste pakker.

feil := http. ListenAndServe(":8000", ruter)
hvis feil!= null {
komme tilbake
}

Her er noen av de populære rutepakkene i Go-økosystemet.

1. Gorilla Mux-ruteren

Gorilla Mux-pakken implementerer både en forespørselsruter og en forespørselsformidler for HTTP-forespørsler. Det er som http. ServeMux metode, men med ekstra funksjonalitet.

Gorilla Mux-ruteren implementerer http. Handler grensesnittet og dets metoder er kompatible med ServeMux metode. Pakken implementerer også flere URL-skjemaer, og du kan bruke rutere som underrutere (nestede ruter) for å definere lignende ruter.

De Gorilla Mux pakken er en del av Gorilla-nettverktøysettet. Verktøysettet inneholder nettrelaterte pakker for å løse mange problemer fra holde brukere pålogget med Sessions til datalagring ved hjelp av informasjonskapsler.

Kjør denne kommandoen i terminalen på arbeidsområdet ditt for å installere Gorilla Mux-pakken.

gå få -u github.com/gorilla/mux

Slik kan du sette opp en FÅ be om rute til en behandlerfunksjon som koder til et JSON-svar med Gorilla Mux-pakken.

import (
 "encoding/json"
 "github.com/gorilla/mux"
 "Logg"
 "net/http"
)
funcHallo(skribent http. ResponseWriter, be om *http. Be om) {
 svar := Info {
 Melding: "Suksess",
 Beskrivelse: "Du har skrevet til klienten",
 }
feil := json. NewEncoder (writer).Encode (respons)
hvis feil!= null {
 Logg. Fatalln (feil)
 }
}
funchoved-() {
 ruter := mux. NewRouter()
 ruter. HandleFunc("/hello", hello).Methods("GET")
 feil := http. ListenAndServe(":8000", ruter)
hvis feil!= null {
komme tilbake
 }
}

De Hallo handler-funksjonen koder strukturen til JSON ved å bruke Kode metoden for NewEncoder struktur.

De hoved- funksjonen tildeler en ny Gorilla Mux-ruterforekomst til ruter variabel. Den kaller da HandleFunc metode for å kartlegge ruten til behandlerfunksjonen. Du kan bruke Metoder metode for å spesifisere en forespørselstype.

2. Chi-ruteren

De Chi-ruter er en lett, rask, komponerbar ruter for å bygge HTTP-baserte webtjenester i Go. Chi-ruteren er kompatibel med http pakken, og det er ingen eksterne avhengigheter for ruteren.

I motsetning til mange rutere, gir Chi kontekstkontroll med kontekst pakke for rettidig forespørselshåndtering.

Installer Chi-ruteren på Go-modulene dine med denne kommandoen.

gå skaff deg github.com/gå-chi/chi

Ruting med Gorilla Mux-ruteren og Chi-ruteren er veldig lik. Her er hvordan du kan sette opp en lignende FÅ forespørsel som koder struct til JSON som et svar.

import (
 "encoding/json"
 "github.com/gå-chi/chi/v5"
 "Logg"
 "net/http"
)
funchoved-() {
 ruter := chi. NewRouter()
 ruter. Get("/hei", hei)
 feil := http. ListenAndServe(":8000", ruter)
hvis feil!= null {
komme tilbake
 }
}
funcHallo(skribent http. ResponseWriter, be om *http. Be om) {
 svar := Info {
 Melding: "Suksess",
 Beskrivelse: "Du har skrevet til klienten",
 }
feil := json. NewEncoder (writer).Encode (respons)
hvis feil!= null {
 Logg. Fatalln (feil)
 }
}

De Hallo handlerfunksjon er handlerfunksjonen for FÅ be om.

I hoved- funksjon, den ruter variabel er en Chi-ruterforekomst. Du kan spesifisere en forespørselsmetode med metodenavnet; i dette tilfellet, Få tar inn rute- og behandlerfunksjonsidentifikatoren som parametere.

3. HttpRouter-pakken

De HttpRouter pakken er en svært effektiv, lett forespørselsmultiplekser. Det gir mer funksjonalitet enn ServeMux implementering av http-pakken.

HttpRouter-pakken har et lite minnefotavtrykk, høy ytelse og god skalerbarhet. Det er en av de eldste og mest brukte ruterne i Go-økosystemet, implementert i mange populære Go-rammeverk, gjelder også Gin-biblioteket.

Å kjøre denne kommandoen på terminalen til arbeidskatalogen din vil installere HttpRouter-pakken.

gå skaff deg github.com/julienschmidt/httprouter

Ruting med HttpRouter skiller seg litt fra Chi- og Gorilla Mux-ruterne.

Slik kan du sette opp en enkel GET-forespørsel med HttpRouter-pakken.

import (
 "encoding/json"
 "github.com/julienschmidt/httprouter"
 "Logg"
 "net/http"
)
funchoved-() {
 ruter := httpruter. Ny()
 ruter. GET("/hei", hei)
 feil := http. ListenAndServe(":8000", ruter)
hvis feil!= null {
komme tilbake
 }
}
funcHallo(skribent http. ResponseWriter, be om *http. Forespørsel, _ httpruter. Params) {
 svar := Info {
 Melding: "Suksess",
 Beskrivelse: "Du har nådd API-endepunktet",
 }
feil := json. NewEncoder (writer).Encode (respons)
hvis feil!= null {
 Logg. Fatalln (feil)
 }
}

Behandlerfunksjoner for HttpRouter-pakken må ha Params metoden til HTTP-ruteren.

De ruter variabel er en forekomst av HttpRouter. Du kan sette opp en GET-forespørsel med FÅ metode som tar inn ruten og behandlerfunksjonsidentifikatoren.

4. Pat-ruteren

klapp er en HTTP-forespørselsmultiplekser i Sinatra-stil som fungerer med Go's net/http-pakke. Pat-ruteren har ingen andre funksjoner enn ruting.

Kjør denne kommandoen i arbeidskatalogen din for å installere Pat Router

gå skaff deg github.com/bmizerany/pat

Pat-ruteren implementerer lignende funksjoner som ServeMux metode.

Her er hvordan du kan håndtere forespørselsruting med klapp pakke.

import (
 "encoding/json"
 "github.com/bmizerany/pat"
 "Logg"
 "net/http"
)
funcHallo(skribent http. ResponseWriter, be om *http. Be om) {
 svar := Info {
 Melding: "Suksess",
 Beskrivelse: "Du har nådd endepunktet",
 }
feil := json. NewEncoder (writer).Encode (respons)
hvis feil!= null {
 Logg. Fatalln ("feil")
 }
}
funchoved-() {
 ruter := pat. Ny() // ruterforekomst
 ruter. Get("/hei", http. HandlerFunc (hei))
 http. Håndtak("/", ruter)
 feil := http. ListenAndServe(":12345", null)
hvis feil!= null {
 Logg. Fatal("ListenAndServe: ", feil)
 }
}

De Ny metoden returnerer en ruterforekomst. Du må pakke handlerfunksjonen med HandlerFunc metode. Du kan da bruke Håndtak metode for å spesifisere en rotbane og montere ruterforekomsten før du starter en server.

Å bygge en ruter er ikke så vanskelig

Alle ruterne i denne artikkelen implementerer funksjonalitet fra nett- og http-pakkene. Du kan sjekke ut dokumentasjonen av ServeMux-metoden for å lære hvordan du replikerer en ruter med ekstra funksjonalitet for å passe dine behov.

Rammer som Gin og Fiber inkluderer rutingfunksjonalitet fra nettpakken eller eksterne pakker som implementerer den.