Web-routing er en teknik til at tildele HTTP-anmodninger til behandlerfunktioner, der fungerer på den angivne URL-sti. Routing bruges ofte til at bygge single-page applikationer (SPA'er) og API'er. I routeren definerer koden rækkefølgen af handlinger, der ledsager en brugers anmodning.
Go-standardbiblioteket har det meste af den funktionalitet, du skal bruge for at bygge webapplikationer, inklusive routing. Du kan bruge ServeMux skriv i net/http pakke til grundlæggende rutehåndtering. Hvis du har brug for mere kompleks rutehåndtering, er der masser af rutepakker at vælge imellem.
Kom godt i gang med Routing in Go
Go’s økosystem er hjemsted for routingpakker, der abstraherer det unødvendige og gør det nemmere at bygge webapplikationer og tjenester.
Mange Go-webrammer implementerer nogle af disse routingpakker.
Her er en simpel strukturmodel for JSON svar, du vender tilbage til klienten i denne vejledning.
type Info struktur {
Besked snor`json:"meddelelse"`
Beskrivelse snor`json:"beskrivelse"`
}
De fleste Go-routere bruger stadig nettet/http ResponseWriter og Anmodning metoder som parametre i handlerfunktioner.
funcHej(forfatter http. ResponseWriter, anmod om *http. Anmodning) {
// handler funktion forretningslogik her
}
Du skal også starte en server med ListenAndServe metode til at starte serveren i de fleste pakker.
fejl := http. ListenAndServe(":8000", router)
hvis fejl!= nul {
Vend tilbage
}
Her er nogle af de populære routingpakker i Go-økosystemet.
1. Gorilla Mux-routeren
Gorilla Mux-pakken implementerer både en anmodningsrouter og en anmodningsdispatcher for HTTP-anmodninger. Det er ligesom http. ServeMux metode men med ekstra funktionalitet.
Gorilla Mux-routeren implementerer http. Handler interface og dets metoder er kompatible med ServeMux metode. Pakken implementerer også flere URL-skemaer, og du kan bruge routere som underroutere (indlejrede ruter) til at definere lignende ruter.
Det Gorilla Mux pakken er en del af Gorilla-webværktøjssættet. Værktøjssættet indeholder web-relaterede pakker til at løse mange problemer fra holde brugere logget ind med Sessions til datalagring ved hjælp af cookies.
Kør denne kommando i terminalen på dit arbejdsområde for at installere Gorilla Mux-pakken.
gå få -u github.com/gorilla/mux
Sådan kan du konfigurere en FÅ anmod om rute til en handlerfunktion, der koder til et JSON-svar med Gorilla Mux-pakken.
importere (
"encoding/json"
"github.com/gorilla/mux"
"log"
"net/http"
)funcHej(forfatter http. ResponseWriter, anmod om *http. Anmodning) {
svar := Info {
Besked: "Succes",
Beskrivelse: "Du har skrevet til klienten med succes",
}fejl := json. NewEncoder (writer).Encode (svar)
hvis fejl!= nul {
log. Fatalln (fejl)
}
}funcvigtigste() {
router := mux. NewRouter()
router. HandleFunc("/hej", hej).Methods("GET")
fejl := http. ListenAndServe(":8000", router)
hvis fejl!= nul {
Vend tilbage
}
}
Det Hej handler-funktionen koder strukturen til JSON ved hjælp af Indkode metoden til NewEncoder struktur.
Det vigtigste funktion tildeler en ny Gorilla Mux-routerinstans til router variabel. Det kalder så HandleFunc metode til at kortlægge ruten til handlerfunktionen. Du kan bruge Metoder metode til at angive en anmodningstype.
2. Chi-routeren
Det Chi Router er en let, hurtig, komponerbar router til opbygning af HTTP-baserede webtjenester i Go. Chi-routeren er kompatibel med http pakke, og der er ingen eksterne afhængigheder for routeren.
I modsætning til mange routere giver Chi kontekstkontrol med sammenhæng pakke til rettidig anmodningshåndtering.
Installer Chi-routeren på dine Go-moduler med denne kommando.
gå få github.com/gå-chi/chi
Routing med Gorilla Mux-routeren og Chi-routeren er meget ens. Sådan kan du konfigurere en lignende FÅ anmodning, der koder struct til JSON som et svar.
importere (
"encoding/json"
"github.com/gå-chi/chi/v5"
"log"
"net/http"
)funcvigtigste() {
router := chi. NewRouter()
router. Get("/hej", hej)
fejl := http. ListenAndServe(":8000", router)hvis fejl!= nul {
Vend tilbage
}
}funcHej(forfatter http. ResponseWriter, anmod om *http. Anmodning) {
svar := Info {
Besked: "Succes",
Beskrivelse: "Du har skrevet til klienten med succes",
}fejl := json. NewEncoder (writer).Encode (svar)
hvis fejl!= nul {
log. Fatalln (fejl)
}
}
Det Hej handlerfunktion er handlerfunktionen for FÅ anmodning.
I den vigtigste funktion, den router variabel er en Chi-router-forekomst. Du kan angive en anmodningsmetode med metodenavnet; I dette tilfælde, Få tager rute- og handlerfunktionsidentifikationen ind som parametre.
3. HttpRouter-pakken
Det HttpRouter pakken er en yderst effektiv, let anmodningsmultiplekser. Det giver mere funktionalitet end ServeMux implementering af http-pakken.
HttpRouter-pakken har et lille hukommelsesfodaftryk, høj ydeevne og god skalerbarhed. Det er en af de ældste og mest brugte routere i Go-økosystemet, implementeret i mange populære Go-frameworks, herunder Gin biblioteket.
Hvis du kører denne kommando på terminalen i dit arbejdsbibliotek, installeres HttpRouter-pakken.
gå få github.com/julienschmidt/httprouter
Routing med HttpRouteren adskiller sig lidt fra Chi- og Gorilla Mux-routerne.
Sådan kan du konfigurere en simpel GET-anmodning med HttpRouter-pakken.
importere (
"encoding/json"
"github.com/julienschmidt/httprouter"
"log"
"net/http"
)funcvigtigste() {
router := httprouter. Ny()
router. GET("/hej", hej)
fejl := http. ListenAndServe(":8000", router)hvis fejl!= nul {
Vend tilbage
}
}funcHej(forfatter http. ResponseWriter, anmod om *http. Anmodning, _ httprouter. Params) {
svar := Info {
Besked: "Succes",
Beskrivelse: "Du har nået API-endepunktet",
}fejl := json. NewEncoder (writer).Encode (svar)
hvis fejl!= nul {
log. Fatalln (fejl)
}
}
Handlerfunktioner for HttpRouter-pakken skal have Params metoden for HTTP-routeren.
Det router variabel er en forekomst af HttpRouter. Du kan oprette en GET-anmodning med FÅ metode, der tager ruten og handlerfunktions-id'en ind.
4. Pat-routeren
Klappe er en HTTP-anmodningsmultiplekser i Sinatra-stil, der fungerer med Go's net/http-pakke. Pat-routeren har ingen andre funktioner end routing.
Kør denne kommando i din arbejdsmappe for at installere Pat Router
gå få github.com/bmizerany/pat
Pat-routeren implementerer lignende funktioner som ServeMux metode.
Her er, hvordan du kan håndtere anmodningsdirigering med klappe pakke.
importere (
"encoding/json"
"github.com/bmizerany/pat"
"log"
"net/http"
)funcHej(forfatter http. ResponseWriter, anmod om *http. Anmodning) {
svar := Info {
Besked: "Succes",
Beskrivelse: "Du har nået slutpunktet",
}fejl := json. NewEncoder (writer).Encode (svar)
hvis fejl!= nul {
log. Fatalln("fejl")
}
}funcvigtigste() {
router := pat. Ny() // router instans
router. Hent("/hej", http. HandlerFunc (hej))
http. Håndtag("/", router)
fejl := http. ListenAndServe(":12345", nul)
hvis fejl!= nul {
log. Fatal("ListenAndServe: ", fejl)
}
}
Det Ny metode returnerer en routerforekomst. Du bliver nødt til at pakke handlerfunktionen med HandlerFunc metode. Du kan derefter bruge Håndtere metode til at angive en rodsti og montere routerforekomsten, før du starter en server.
Det er ikke så svært at bygge en router
Alle routerne i denne artikel implementerer funktionalitet fra nettet og http-pakker. Du kan tjekke dokumentationen for ServeMux-metoden for at lære, hvordan du replikerer en router med ekstra funktionalitet, der passer til dine behov.
Rammer som Gin og Fiber inkluderer routingfunktionalitet fra netpakken eller eksterne pakker, der implementerer den.