Webbutveckling är ett av många områden där du kan använda Go. Många företag och projekt använder Go på baksidan av sina webbapplikationer, främst för dess hastighet, användarvänlighet och paketekosystem.

De net/http paketet har de flesta funktioner du behöver för att bygga webbapplikationer i Go. Du kan använda andra paket från det funktionsrika standardbiblioteket. De kodning paketet hanterar datakonvertering på låg nivå och html paketet låter dig interagera med webbsidor.

Utöver detta ger Gos ekosystem av tredjepartspaket extra funktioner för att underlätta webbutveckling.

1. Gin-ramverket

Gin är ett av Gos mest populära webbutvecklingspaket. Gin är ett högpresterande mikro-ramverk för att bygga webbapplikationer och mikrotjänster i Go.

Gin är snabb och ger inbyggd rendering, middleware och JSON-valideringsfunktioner. Den har enkel felhantering och utbyggbarhet. Du kan dokumentera dina Gin-applikationer med OpenAPI3-specifikationen och swagger.

Gin har ett Martini-liknande API, och projektet påstår sig vara fyrtio gånger snabbare. För mikrotjänster kan du återanvända Gins modulära komponenter för att utveckla pipelines för förfrågningshantering.

instagram viewer

Du kan installera Gin-ramverket med detta kommando:

gå skaffa github.com/gin-gonic/gin

Så här ställer du in en enkel begäranslutpunkt med Gin-ramverket.

importera (
 "github.com/gin-gonic/gin"
 "logga"
 "net/http"
)
funchuvud() {
 router := gin. Standard()


router. GET("/hej", func(sammanhang *gin. Sammanhang) {
 sammanhang. JSON(http. StatusOK, gin. H{"success": "Träffade slutpunkten framgångsrikt"})
 })
logga. Fatalln (http. ListenAndServe(":8080", noll))
}

Du kan skapa en routerinstans med Standard metod för gin paket. De SKAFFA SIG metod för GET-förfrågningar tar in sökvägen (slutpunkten) och en hanterarfunktionsdeklaration. Denna exempelfunktion returnerar en 200 HTTP-statuskod till klienten och ett lyckat JSON-svar i svarskroppen.

2. Fiberramverket

Fiber är minnessäker, ExpressJS-liknande ram byggd på det blixtrande snabba snabbhttp paket. Den erbjuder bra prestanda och riktar sig till nybörjare och erfarna Javascript-backend-utvecklare.

Fiber har de flesta funktioner du behöver i ett backend-ramverk. Den hanterar routing, förfrågningsgruppering, validering, mallar, krokar, felhantering och mycket mer. Fiber är förlängningsbar, och du kan göra Fiber snabbare med en anpassad kodare och avkodare.

Installera den senaste versionen (v2) av fiberramverket med detta kommando:

gå hämta github.com/gofiber/fiber/v2

Så här kan du ställa in en enkel GET-begäranslutpunkt med Fiber-ramverket.

importera "github.com/gofiber/fiber/v2"
funchuvud() {
 app := fiber. Ny()


app. Get("/hej", func(ctx *fiber. Ctx)fel {
lämna tillbaka ctx. SendString("Hej")
 })
logga. Fatal (app. Lyssna(":8080"))
}

De Ny metod returnerar en ny instans av en Fiber-app. De Skaffa sig metoden är för installation SKAFFA SIG förfrågningar. I det här fallet /hello endpoint returnerar strängen Hallå.

Du ställer in appen för att lyssna på port localhost port 8080 med Lyssna metoden för appen.

3. Iris-ramverket

Iris är ett plattformsoberoende, effektivt, fullfjädrat, väldesignat webbramverk. Du kan använda den för att bygga högpresterande, bärbara API: er och webbappar i Go. Precis som Fiber inspirerar Iris är ExpressJS några av designmönstren i Iris.

Du kan snabbt bygga serverlösa appar med Iris och distribuera dem på AWS, Netlify och många andra tjänster. Iris-paketet har en CLI-app som du kan använda för att ladda om Iris-mallar live och övervaka din app.

Iris-paketet har funktioner som gör utvecklingen extremt enkel. Iris har ett Sinatra-liknande API som tillgodoser loggning, routing, sessioner och Websockets. Den stöder också GRPC, filservering, autentisering, auktorisering och testfunktioner.

Kör det här kommandot i terminalen på din arbetsyta för att installera Iris-ramverket på dina Go-moduler.

gå hämta github.com/kataras/iris/v12@lastest

Så här kan du ställa in en SKAFFA SIG begäran med Iris-ramverket att köras på localhost-porten 8080.

importera "github.com/kataras/iris/v12"
funchuvud() {
 app := iris. Ny() // ny Iris-instans


app. Handle("GET", "/hej", func(ctx iris. Sammanhang) {
 _, fel := ctx. JSON(iris. Karta{"meddelande": "hej"})


om fel!= noll {
lämna tillbaka
 }
 })


fel := app. Kör (iris. Adr(":8080"), iris. WithoutServerError (iris. ErrServerClosed))
om fel!= noll {
lämna tillbaka
 }
}

De app variabel är instansen av en ny Iris-app. De SKAFFA SIG hanteraren returnerar ett JSON-meddelande för att begära på /hello rutt.

4. Beego-ramverket

Beego är ett lättanvänt, intelligent och högpresterande Go-ramverk för att bygga webbappar. Beego gör det enkelt att bygga modulära applikationer. Den kommer med en inbyggd ORM (objektrelationell kartläggare) och router, tillsammans med mallfunktionalitet.

Beego integrerar Go-specifika funktioner med gränssnitt och strukturinbäddning. Den har en fantastisk API-struktur, optimerad för hastighet med sessions- och distributionsstöd och internalisering.

Beego är utbrett och många företag, från Opera till Huawei, Tencent och Weico, använder Beego i produktionen.

Du kan använda det här kommandot för att installera Beego Framework i ditt projekt.

gå skaffa -u github.com/beego/beego/v2

Så här kan du ställa in en enkel SKAFFA SIG begär API-slutpunkt med Beego-ramverket.

importera "github.com/beego/beego/v2/server/web"
typ ControllerInstance struktur {
 webb. Kontroller // ingångspunkt för beego-appen
}


func(controller *ControllerInstance)Skaffa sig() {
 kontroller. Ctx. WriteString("hej värld")
}
funchuvud() {
 webb. Router("/hej", &ControllerInstance{}) // montering med beego
 webb. Springa() // kör beego-appen
}

De ControllerInstance struct är startpunkten för Beego-appen. De Skaffa sig hanterarfunktionen innehåller logiken för en SKAFFA SIG begäran till /hello slutpunkt. Den returnerar "hej världen"-strängen som ett svar.

5. Revel Framework

Frossa lyser för den flexibilitet det ger för att bygga webbapplikationer. Du kan använda Revels typsäkra routing, bygga kontroller och använda Gå mallar med Revel.

Revel tillhandahåller funktionalitet för routing, enkel JSON-kodning och avkodning och sessionshantering. Den innehåller också funktioner för att hantera cachning, felsökning och testning av webbappar. Revel har ett CLI-paket för att bygga CLI: er för dina appar. Du kan visa statiska filer med Revel och bygga chattappar med dess Websocket-funktionalitet.

Installera Revel-ramverket i din projektkatalog med detta kommando:

gå hämta github.com/revel/revel

Det är enkelt att konfigurera en Revel-app. Här är en enkel hanterarfunktion för en SKAFFA SIG begära endpoint med Revel-ramverket.

importera (
 "github.com/revel/revel"
)
typ Modell struktur { // enkel modellstruktur 
 Meddelande sträng`json:"meddelande"`
 Beskrivning sträng`json:"beskrivning"`
}


typ App struktur {
 *frossa. Kontroller // ingångspunkt för förfrågningarna
}


func(app app)Hallå()frossa.Resultat {
 modell := Modell{ 
 Meddelande: "framgång",
 Beskrivning: "Hej!, Världen",
 }
app. Svar. ContentType = "applikation/json"
lämna tillbaka app. RenderJSON(modell)
}

De App struct är startpunkten för Revel-appen. Dina hanterare kommer att implementera appstrukturen. Svarsinnehållstypen är JSON, och Hallå hanterarfunktionen returnerar en kodad JSON-struktur.

Akta dig för skillnaden mellan routrar och ramverk

Du hittar många webbpaket i Go-ekosystemet, varav de flesta är routrar eller ramverk. Routrar är till för att ta emot förfrågningar via HTTP-protokollet.

Du behöver ytterligare paket för att fungera med routrar. Liksom de i denna handledning inkluderar de flesta ramverk inbyggda routrar tillsammans med annan funktionalitet.