4 Go Web Routers pro vaši další webovou aplikaci

Webové směrování je technika přiřazování požadavků HTTP funkcím obslužných rutin, které fungují na zadané cestě URL. Směrování se často používá k vytváření jednostránkových aplikací (SPA) a rozhraní API. V routeru kód definuje sekvenci akcí doprovázejících požadavek uživatele.

Standardní knihovna Go má většinu funkcí, které budete potřebovat k vytváření webových aplikací, včetně směrování. Můžete použít ServeMux zadejte v net/http balíček pro základní manipulaci s trasou. Pokud potřebujete složitější zpracování tras, existuje spousta balíčků směrování, ze kterých si můžete vybrat.

Začínáme s trasováním v Go

Ekosystém Go je domovem směrovacích balíčků, které abstrahují nepotřebné a usnadňují vytváření webových aplikací a služeb.

Mnoho webových frameworků Go implementuje některé z těchto směrovacích balíčků.

Zde je jednoduchý model struktury pro JSON odpověď, kterou vrátíte klientovi v tomto tutoriálu.

typ Info strukturovat {
 Zpráva tětiva`json:"zpráva"`
 Popis tětiva`json:"popis"`
}

Většina směrovačů Go stále používá síť net/http

ResponseWriter a Žádost metody jako parametry ve funkcích obsluhy.

funcAhoj(spisovatel http. ResponseWriter, požadavek *http. Žádost) {
// funkce obsluhy zde obchodní logika
}

Také budete muset spustit server s ListenAndServe metoda pro spuštění serveru ve většině balíčků.

chyba := http. ListenAndServe(":8000", router)
-li chyba!= nula {
vrátit se
}

Zde jsou některé z oblíbených balíčků směrování v ekosystému Go.

1. Směrovač Gorilla Mux Router

Balíček Gorilla Mux implementuje směrovač požadavků i dispečer požadavků pro požadavky HTTP. Je to jako http. ServeMux metoda, ale s přidanou funkčností.

Router Gorilla Mux implementuje http. Psovod rozhraní a jeho metody jsou kompatibilní s ServeMux metoda. Balíček také implementuje několik schémat URL a můžete použít směrovače jako podsměrovače (vnořené cesty) k definování podobných cest.

The Gorila Mux balíček je součástí sady nástrojů Gorilla web. Sada nástrojů obsahuje balíčky související s webem, které řeší mnoho problémů udržení uživatelů přihlášených pomocí relací k ukládání dat pomocí souborů cookie.

Spusťte tento příkaz v terminálu svého pracovního prostoru a nainstalujte balíček Gorilla Mux.

jít get -u github.com/gorilla/mux

Zde je návod, jak můžete nastavit a DOSTAT request route to handler function, která kóduje do odpovědi JSON s balíčkem Gorilla Mux.

import (
 "kódování/json"
 "github.com/gorilla/mux"
 "log"
 "net/http"
)
funcAhoj(spisovatel http. ResponseWriter, požadavek *http. Žádost) {
 odpověď := Info {
 Zpráva: "Úspěch",
 Popis: "Úspěšně jste odepsali klientovi",
 }
chyba := json. NewEncoder (writer).Encode (odpověď)
-li chyba!= nula {
 log. Fatalln (chyba)
 }
}
funchlavní() {
 router := mux. NewRouter()
 router. HandleFunc("/ahoj", ahoj).Methods("GET")
 chyba := http. ListenAndServe(":8000", router)
-li chyba!= nula {
vrátit se
 }
}

The Ahoj funkce handler zakóduje strukturu do JSON pomocí Zakódovat metoda NewEncoder strukturovat.

The hlavní funkce přiřadí novou instanci routeru Gorilla Mux k router variabilní. Poté zavolá HandleFunc metoda k mapování trasy na funkci handleru. Můžete použít Metody metoda k určení typu požadavku.

2. Směrovač Chi

The Chi Router je lehký, rychlý, skládací router pro vytváření webových služeb založených na HTTP v Go. Router Chi je kompatibilní s http balíček a pro router neexistují žádné externí závislosti.

Na rozdíl od mnoha směrovačů poskytuje Chi kontextové ovládání s kontext balíček pro včasné vyřízení požadavku.

Pomocí tohoto příkazu nainstalujte směrovač Chi do modulů Go.

jít získat github.com/jít-chi/chi

Směrování s routerem Gorilla Mux a routerem Chi je velmi podobné. Zde je návod, jak můžete nastavit podobný DOSTAT požadavek, který zakóduje strukturu do JSON jako odpověď.

import (
 "kódování/json"
 "github.com/jít-chi/chi/v5"
 "log"
 "net/http"
)
funchlavní() {
 router := chi. NewRouter()
 router. Get("/ahoj", ahoj)
 chyba := http. ListenAndServe(":8000", router)
-li chyba!= nula {
vrátit se
 }
}
funcAhoj(spisovatel http. ResponseWriter, požadavek *http. Žádost) {
 odpověď := Info {
 Zpráva: "Úspěch",
 Popis: "Úspěšně jste odepsali klientovi",
 }
chyba := json. NewEncoder (writer).Encode (odpověď)
-li chyba!= nula {
 log. Fatalln (chyba)
 }
}

The Ahoj handler function je handler funkce pro DOSTAT žádost.

V hlavní funkce, router proměnná je instance Chi routeru. Můžete zadat metodu požadavku s názvem metody; v tomto případě, Dostat jako parametry přebírá identifikátor funkce trasy a obslužné rutiny.

3. Balíček HttpRouter

The HttpRouter balíček je vysoce výkonný, lehký multiplexer požadavků. Poskytuje více funkcí než ServeMux implementace balíčku http.

Balíček HttpRouter má malé nároky na paměť, vysoký výkon a dobrou škálovatelnost. Je to jeden z nejstarších a nejpoužívanějších routerů v ekosystému Go, implementovaný v mnoha populární rámce Go, počítaje v to knihovna Gin.

Spuštěním tohoto příkazu na terminálu vašeho pracovního adresáře se nainstaluje balíček HttpRouter.

jít získejte github.com/julienschmidt/httprouter

Směrování pomocí routeru HttpRouter se mírně liší od routerů Chi a Gorilla Mux.

Zde je návod, jak můžete nastavit jednoduchý požadavek GET s balíčkem HttpRouter.

import (
 "kódování/json"
 "github.com/julienschmidt/httprouter"
 "log"
 "net/http"
)
funchlavní() {
 router := httprouter. Nový()
 router. GET("/ahoj", ahoj)
 chyba := http. ListenAndServe(":8000", router)
-li chyba!= nula {
vrátit se
 }
}
funcAhoj(spisovatel http. ResponseWriter, požadavek *http. Žádost, _ httprouter. parametry) {
 odpověď := Info {
 Zpráva: "Úspěch",
 Popis: "Úspěšně jste dosáhli koncového bodu API",
 }
chyba := json. NewEncoder (writer).Encode (odpověď)
-li chyba!= nula {
 log. Fatalln (chyba)
 }
}

Funkce obsluhy pro balíček HttpRouter musí mít příponu Parametry metodu HTTP routeru.

The router proměnná je instancí HttpRouter. Požadavek GET můžete nastavit pomocí DOSTAT metoda, která přebírá cestu a identifikátor funkce handleru.

4. Směrovač Pat

Pat je multiplexer požadavků HTTP ve stylu Sinatry, který pracuje s balíčkem net/http společnosti Go. Router Pat nemá žádné jiné funkce než směrování.

Spusťte tento příkaz ve vašem pracovním adresáři a nainstalujte Pat Router

jít získat github.com/bmizerany/pat

Router Pat implementuje podobné funkce jako ServeMux metoda.

Zde je návod, jak můžete zvládnout směrování požadavků pomocí pat balík.

import (
 "kódování/json"
 "github.com/bmizerany/pat"
 "log"
 "net/http"
)
funcAhoj(spisovatel http. ResponseWriter, požadavek *http. Žádost) {
 odpověď := Info {
 Zpráva: "Úspěch",
 Popis: "Úspěšně jste dosáhli koncového bodu",
 }
chyba := json. NewEncoder (writer).Encode (odpověď)
-li chyba!= nula {
 log. Fatalln("chyba")
 }
}
funchlavní() {
 router := pat. Nový() // instance routeru
 router. Get("/ahoj", http. HandlerFunc (ahoj))
 http. Handle("/", router)
 chyba := http. ListenAndServe(":12345", nula)
-li chyba!= nula {
 log. Fatal("ListenAndServe: ", chyba)
 }
}

The Nový metoda vrací instanci routeru. Budete muset zabalit funkci manipulátoru s HandlerFunc metoda. Poté můžete použít Rukojeť metoda k určení kořenové cesty a připojení instance routeru před spuštěním serveru.

Sestavení routeru není tak obtížné

Všechny směrovače v tomto článku implementují funkce z balíčků net a http. Můžete se podívat na dokumentaci metody ServeMux, kde se dozvíte, jak replikovat router s dalšími funkcemi, aby vyhovoval vašim potřebám.

Rámce jako Gin a Fiber zahrnují funkci směrování ze síťového balíčku nebo externích balíčků, které ji implementují.