Golang lernt die Verwendung des Web-Frameworks Gin

Golang lernt die Verwendung des Web-Frameworks Gin

Mit der Entwicklung des Internets sind Webanwendungen zur Standardkonfiguration verschiedener Softwaresysteme geworden. Die serverseitigen Entwicklungssprachen für Webanwendungen werden immer vielfältiger. Unter anderem werden die hohe Leistung und der prägnante Syntaxstil von Golang von Entwicklern zunehmend bevorzugt. In diesem Artikel wird eines der am häufigsten verwendeten Web-Frameworks in Golang vorgestellt: Gin.

1. Was ist Gin? Gin ist ein in der Go-Sprache geschriebenes Webanwendungs-Framework. Es basiert auf dem httprouter-Paket und der net/http-Standardbibliothek und bietet hohe Leistung, Effizienz, Benutzerfreundlichkeit und leistungsstarke Funktionen. Verwenden Sie Gin, um schnell einen Webserver zu erstellen und Funktionen wie RESTful API, Routing-Gruppierung, Middleware, Parameterbindung und Vorlagenrendering zu unterstützen.

2. Installation von Gin

Bevor Sie das Gin-Framework verwenden, müssen Sie zuerst Gin installieren. Zur Installation können Sie die folgende Befehlszeile verwenden:

go get -u github.com/gin-gonic/gin

3. Grundlegende Verwendung von Gin

Im Folgenden zeigen wir anhand eines Beispiels, wie Sie mit Gin einen einfachen Webdienst schreiben.

Importieren Sie das Gin-Paket.

1. Importieren Sie das Gin-Paket am Anfang der Codedatei:

import "github.com/gin-gonic/gin"

Erstellen Sie eine Gin-Engine.

2. Verwenden Sie die Methode gin.New(), um eine neue Gin-Engine zu erstellen.

r := gin.New()

Routen definieren

3. Verwenden Sie die Methoden r.GET(), r.POST(), r.PUT() und r.DELETE(), um Routen zu definieren, wobei der erste Parameter der Routing-Pfad ist und der zweite Der erste Parameter ist die Routing-Verarbeitungsfunktion.

r.GET("/", func(c *gin.Context) {
    c.String(http.StatusOK, "Hello World")
})

Starten Sie den Dienst

4. Verwenden Sie die Methode r.Run(), um den Dienst zu starten und geben Sie die Dienstadresse und die Portnummer an.

r.Run(":8080")

Der vollständige Code lautet wie folgt:

package main

import (
    "net/http"

    "github.com/gin-gonic/gin"
)

func main() {
    r := gin.New()

    r.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello World")
    })

    r.Run(":8080")
}

4. Gins Routing

Grundlegendes Routing

1. In Gin besteht Routing aus Routing-Methoden, Anforderungspfaden und Verarbeitungsfunktionen ., LÖSCHEN, PATCH, KOPF, OPTIONEN usw. Verwenden Sie Methoden wie r.GET(), r.POST(), r.PUT() und r.DELETE(), um Routen zu definieren.

r.GET("/index", func(c *gin.Context) {
    c.String(http.StatusOK, "Hello World")
})

Routen mit Parametern

2. Verwenden Sie einen Doppelpunkt (:), um Routen mit Parametern zu definieren.

r.GET("/hello/:name", func(c *gin.Context) {
    name := c.Param("name")
    c.String(http.StatusOK, "Hello %s", name)
})

Routen für mehrere Anforderungstypen

3. Verwenden Sie die Methode r.Handle(), um Routen für mehrere Anforderungstypen zu definieren.

r.Handle("GET", "/hello", func(c *gin.Context) {
    c.String(http.StatusOK, "Hello World")
})

r.Handle("POST", "/hello", func(c *gin.Context) {
    c.String(http.StatusOK, "Hello POST")
})

Routing-Gruppierung

4. Verwenden Sie die r.Group()-Methode, um Routing-Gruppierung zu implementieren. Middleware und gemeinsame Routing-Verarbeitungsfunktionen können der Routing-Gruppe hinzugefügt werden.

v1 := r.Group("/v1")
{
    v1.GET("/hello", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello v1")
    })
}

5. Gin-Middleware

Middleware verwenden

1. Mit der Gin-Middleware können viele nützliche Funktionen erreicht werden, z. Verwenden Sie die Methode r.Use(), um Middleware zu registrieren.

r.Use(gin.Logger())
r.Use(gin.Recovery())

Middleware schreiben

2. Middleware-Methoden schreiben ist sehr einfach. Sie müssen lediglich eine Funktion mit einem Parameter vom Typ gin.Context erstellen und die Methode c.Next() in der Funktion aufrufen, um die Middleware-Funktion zu implementieren.

func Auth() gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.GetHeader("Authorization") != "token" {
            c.AbortWithStatus(http.StatusUnauthorized)
        }
        c.Next()
    }
}

r.GET("/hello", Auth(), func(c *gin.Context) {
    c.String(http.StatusOK, "Hello World")
})

6. Gin-Parameterbindung

Abfrageparameter binden

1. Verwenden Sie die Methode c.Query(), um die Abfrageparameter abzurufen.

r.GET("/hello", func(c *gin.Context) {
    name := c.Query("name")
    age := c.Query("age")
    c.String(http.StatusOK, "name: %s, age: %s", name, age)
})

POST-Formular binden

2. Verwenden Sie die Methode c.PostForm(), um POST-Formulardaten abzurufen.

r.POST("/login", func(c *gin.Context) {
    username := c.PostForm("username")
    password := c.PostForm("password")
    c.JSON(http.StatusOK, gin.H{
        "username": username,
        "password": password,
    })
})

JSON-Daten binden

3. Verwenden Sie die Methode c.BindJSON(), um JSON-Daten zu binden.

type User struct {
    Name     string `json:"name"`
    Password string `json:"password"`
}

r.POST("/login", func(c *gin.Context) {
    var user User
    if err := c.BindJSON(&user); err == nil {
        c.JSON(http.StatusOK, gin.H{
            "name":     user.Name,
            "password": user.Password,
        })
    } else {
        c.JSON(http.StatusBadRequest, gin.H{
            "error": err.Error(),
        })
    }
})

7. Vorlagen-Rendering von Gin

Mit dem Gin-Framework können Vorlagen problemlos gerendert werden und es werden mehrere Vorlagen-Engines wie HTML, JSON, XML usw. unterstützt.

Installieren Sie die Template-Engine.

1. Verwenden Sie den Befehl „go get“, um die Template-Engine zu installieren.

go get -u github.com/gin-gonic/gin
go get -u github.com/gin-gonic/contrib/jwt
go get -u github.com/jinzhu/gorm

Vorlagen laden

2. Verwenden Sie die Methode gin.LoadHTMLGlob(), um Vorlagendateien zu laden.

r.LoadHTMLGlob("html/*")

Vorlagen rendern

3. Verwenden Sie die Methode c.HTML(), um Vorlagen zu rendern.

r.GET("/html", func(c *gin.Context) {
    c.HTML(http.StatusOK, "index.html", gin.H{
        "title": "Welcome Gin Web Framework",
    })
})

8. Fazit

In diesem Artikel werden die grundlegenden Schritte und Techniken zum Erstellen eines Webservers mithilfe des Gin-Frameworks vorgestellt. Die hohe Leistung und der prägnante Syntaxstil von Golang machen es bei Entwicklern bei der Entwicklung von Webdiensten immer beliebter. Ich hoffe, dass dieser Artikel den Entwicklern von Golang-Webservern Inspiration und Hilfe bieten kann.

Das obige ist der detaillierte Inhalt vonGolang lernt die Verwendung des Web-Frameworks Gin. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!