Webbrouting är en teknik för att tilldela HTTP-förfrågningar till hanterarfunktioner som fungerar på den angivna URL-sökvägen. Routing används ofta för att bygga ensidiga applikationer (SPA) och API: er. I routern definierar koden sekvensen av åtgärder som följer med en användares begäran.
Go-standardbiblioteket har de flesta funktioner du behöver för att bygga webbapplikationer, inklusive routing. Du kan använda ServeMux skriv in net/http paket för grundläggande rutthantering. Om du behöver mer komplex rutthantering finns det massor av ruttpaket att välja mellan.
Komma igång med Routing in Go
Go’s ekosystem är hem för routingpaket som abstraherar det onödiga och gör det lättare att bygga webbapplikationer och tjänster.
Många Go-webbramverk implementerar några av dessa routingpaket.
Här är en enkel strukturmodell för JSON svar kommer du att returnera till klienten i denna handledning.
typ Info struktur {
Meddelande sträng`json:"meddelande"`
Beskrivning sträng`json:"beskrivning"`
}
De flesta Go-routrar använder fortfarande net/http
ResponseWriter och Begäran metoder som parametrar i hanterarfunktioner.funcHallå(författare http. ResponseWriter, begär *http. Begäran) {
// hanterarfunktion affärslogik här
}
Du måste också starta en server med ListenAndServe metod för att starta upp servern i de flesta paket.
fel := http. ListenAndServe(":8000", router)
om fel!= noll {
lämna tillbaka
}
Här är några av de populära ruttpaketen i Go-ekosystemet.
1. Gorilla Mux-routern
Gorilla Mux-paketet implementerar både en förfrågningsrouter och en förfrågningssändare för HTTP-förfrågningar. Det är som http. ServeMux metod men med extra funktionalitet.
Gorilla Mux-routern implementerar http. Hanterare gränssnittet och dess metoder är kompatibla med ServeMux metod. Paketet implementerar också flera URL-scheman och du kan använda routrar som underroutrar (kapslade rutter) för att definiera liknande rutter.
De Gorilla Mux paketet är en del av Gorilla webbverktygslåda. Verktygslådan innehåller webbrelaterade paket att lösa många problem från hålla användare inloggade med Sessions till datalagring med hjälp av cookies.
Kör det här kommandot i terminalen på din arbetsyta för att installera Gorilla Mux-paketet.
gå skaffa -u github.com/gorilla/mux
Så här kan du ställa in en SKAFFA SIG begär rutt till en hanterarfunktion som kodar till ett JSON-svar med Gorilla Mux-paketet.
importera (
"encoding/json"
"github.com/gorilla/mux"
"logga"
"net/http"
)funcHallå(författare http. ResponseWriter, begär *http. Begäran) {
svar := Info {
Meddelande: "Framgång",
Beskrivning: "Du har framgångsrikt skrivit till klienten",
}fel := json. NewEncoder (writer).Encode (svar)
om fel!= noll {
logga. Fatalln (fel)
}
}funchuvud() {
router := mux. NewRouter()
router. HandleFunc("/hej", hej).Methods("GET")
fel := http. ListenAndServe(":8000", router)
om fel!= noll {
lämna tillbaka
}
}
De Hallå hanterarfunktionen kodar strukturen till JSON med hjälp av Koda metod för NewEncoder struktur.
De huvud funktionen tilldelar en ny Gorilla Mux-routerinstans till router variabel. Den kallar sedan HandleFunc metod för att mappa rutten till hanterarfunktionen. Du kan använda Metoder metod för att ange en begäranstyp.
2. Chi-routern
De Chi Router är en lätt, snabb, komponerbar router för att bygga HTTP-baserade webbtjänster i Go. Chi-routern är kompatibel med http paketet, och det finns inga externa beroenden för routern.
Till skillnad från många routrar ger Chi kontextkontroll med sammanhang paket för snabb hantering av begäran.
Installera Chi-routern på dina Go-moduler med detta kommando.
gå skaffa github.com/gå-chi/chi
Routing med Gorilla Mux-routern och Chi-routern är väldigt lika. Så här kan du ställa in en liknande SKAFFA SIG begäran som kodar struct till JSON som ett svar.
importera (
"encoding/json"
"github.com/gå-chi/chi/v5"
"logga"
"net/http"
)funchuvud() {
router := chi. NewRouter()
router. Get("/hej", hej)
fel := http. ListenAndServe(":8000", router)om fel!= noll {
lämna tillbaka
}
}funcHallå(författare http. ResponseWriter, begär *http. Begäran) {
svar := Info {
Meddelande: "Framgång",
Beskrivning: "Du har framgångsrikt skrivit till klienten",
}fel := json. NewEncoder (writer).Encode (svar)
om fel!= noll {
logga. Fatalln (fel)
}
}
De Hallå hanterarfunktionen är hanterarfunktionen för SKAFFA SIG begäran.
I den huvud funktion, den router variabel är en Chi-routerinstans. Du kan ange en begäranmetod med metodnamnet; I detta fall, Skaffa sig tar in rutt- och hanterarfunktionsidentifieraren som parametrar.
3. HttpRouter-paketet
De HttpRouter paketet är en högpresterande, lätt multiplexerare för begäran. Det ger mer funktionalitet än ServeMux implementering av http-paketet.
HttpRouter-paketet har ett litet minnesutrymme, hög prestanda och god skalbarhet. Det är en av de äldsta och mest använda routrarna i Go-ekosystemet, implementerad i många populära Go-ramverk, Inklusive Gin-biblioteket.
Om du kör det här kommandot på terminalen i din arbetskatalog installeras HttpRouter-paketet.
gå skaffa github.com/julienschmidt/httprouter
Routing med HttpRouter skiljer sig något från Chi- och Gorilla Mux-routrarna.
Så här kan du ställa in en enkel GET-förfrågan med HttpRouter-paketet.
importera (
"encoding/json"
"github.com/julienschmidt/httprouter"
"logga"
"net/http"
)funchuvud() {
router := httprouter. Ny()
router. GET("/hej", hej)
fel := http. ListenAndServe(":8000", router)om fel!= noll {
lämna tillbaka
}
}funcHallå(författare http. ResponseWriter, begär *http. Begäran, _ httprouter. Params) {
svar := Info {
Meddelande: "Framgång",
Beskrivning: "Du har lyckats nå API-slutpunkten",
}fel := json. NewEncoder (writer).Encode (svar)
om fel!= noll {
logga. Fatalln (fel)
}
}
Hanteringsfunktioner för HttpRouter-paketet måste ha Params metod för HTTP-routern.
De router variabel är en instans av HttpRouter. Du kan ställa in en GET-förfrågan med SKAFFA SIG metod som tar in rutten och hanterarens funktionsidentifierare.
4. Pat-routern
Klappa är en HTTP-begäran multiplexer i Sinatra-stil som fungerar med Gos net/http-paket. Pat-routern har inga andra funktioner än routing.
Kör det här kommandot i din arbetskatalog för att installera Pat Router
gå hämta github.com/bmizerany/pat
Pat-routern implementerar liknande funktioner som ServeMux metod.
Så här kan du hantera begäran om routing med klappa paket.
importera (
"encoding/json"
"github.com/bmizerany/pat"
"logga"
"net/http"
)funcHallå(författare http. ResponseWriter, begär *http. Begäran) {
svar := Info {
Meddelande: "Framgång",
Beskrivning: "Du har lyckats nå slutpunkten",
}fel := json. NewEncoder (writer).Encode (svar)
om fel!= noll {
logga. Fatalln("fel")
}
}funchuvud() {
router := pat. Ny() // routerinstans
router. Get("/hej", http. HandlerFunc (hej))
http. Handle("/", router)
fel := http. ListenAndServe(":12345", noll)
om fel!= noll {
logga. Fatal("ListenAndServe: ", fel)
}
}
De Ny metod returnerar en routerinstans. Du måste slå in hanterarfunktionen med HandlerFunc metod. Du kan sedan använda Hantera metod för att ange en rotsökväg och montera routerinstansen innan du startar en server.
Att bygga en router är inte så svårt
Alla routrar i den här artikeln implementerar funktioner från nätet och http-paketen. Du kan kolla in dokumentationen för ServeMux-metoden för att lära dig hur du replikerar en router med extra funktionalitet för att passa dina behov.
Ramar som Gin och Fiber inkluderar routingfunktionalitet från nätpaketet eller externa paket som implementerar det.
