Premiers pas avec le framework Web Golang Learning

Golang est un langage de programmation à haute efficacité et à haute concurrence. De plus en plus de développeurs commencent à utiliser Golang pour créer différents types d'applications. Parmi eux, l'application Web est l'un des scénarios d'application les plus courants dans Golang. Cet article présentera certains frameworks Web couramment utilisés dans Golang et leur utilisation de base.

1. Common Golang Web Framework

1. Gin

Gin est un framework Web rapide et efficace qui fournit des fonctions riches et de bonnes performances. La conception de l'API de Gin est simple et facile à comprendre, Gin est donc très approprié pour créer des API REST et des applications de microservices. Gin fournit des fonctions Web courantes telles que le middleware, le regroupement de routage et la sérialisation JSON/XML.

2. Beego

Beego est un framework Web complet, qui comprend des composants Web courants tels que le routage, le middleware, le rendu de modèles, l'ORM, et fournit une série de fonctions requises pour le développement d'applications Web. Beego peut facilement créer des applications Web à grande échelle et prend en charge l'API RESTful, Websocket et d'autres fonctionnalités.

3. Echo

Echo est un framework Web léger, hautes performances et facile à étendre qui utilise des bibliothèques standard et certains packages tiers pour fournir certaines fonctions, notamment le routage, le middleware, le rendu de modèles, etc. Les performances d'Echo sont très bonnes et conviennent parfaitement à la création d'API et de microservices RESTful.

2. Premiers pas avec le framework Gin

Nous choisissons Gin comme premier framework à présenter. Voyons comment utiliser Gin pour créer une application Web simple.

1. Installer Gin

Vous pouvez utiliser la commande suivante pour installer le framework Gin :

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

2. Hello World

Voici un exemple de Hello World créé à l'aide du framework Gin :

package main

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

func main() {
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, world!")
    })
    r.Run()
}

Tout d'abord, nous importons le package du framework Gin . Ensuite, nous créons une instance Gin et enregistrons une route GET qui renvoie la chaîne "Hello, world!". Enfin, nous utilisons la méthode Run pour démarrer notre application web et écouter sur le port.

Utiliser curl pour demander notre application :

$ curl http://localhost:8080/
Hello, world!

3. Routing

Le routage est le composant principal d'une application Web qui associe les requêtes aux fonctions de gestionnaire.

Ce qui suit est un exemple simple :

package main

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

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

    r.GET("/ping", func(c *gin.Context) {
        c.String(200, "pong")
    })

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

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

    r.Run()
}

Nous utilisons trois routes :

• /ping route, qui renvoie une chaîne "pong" ;
• /hello/:name route, qui reçoit un nom de paramètre et renvoie "Hello " , nommez" cette chaîne ;
• /login route, reçoit la requête POST et renvoie le nom d'utilisateur et le mot de passe demandés.

4. Middleware

Le middleware est une fonctionnalité importante du framework Gin qui peut effectuer des opérations avant et après que la requête atteigne le gestionnaire.

Voici un exemple d'utilisation du middleware Gin :

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "time"
)

func CustomMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        fmt.Println("Starting middleware")
        c.Set("request_time", t)
        c.Next()
        fmt.Println("Ending middleware")
        latency := time.Since(t)
        fmt.Printf("Latency: %v
", latency)
    }
}

func main() {
    r := gin.Default()
    r.Use(CustomMiddleware())

    r.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, world!")
    })

    r.Run()
}

Nous avons créé une fonction middleware appelée CustomMiddleware qui enregistre l'heure de début de la requête, puis elle transmet la requête à la fonction de gestionnaire et gère la fin de la requête une fois terminée.

Nous avons enregistré le middleware dans notre instance Gin et utilisé une simple fonction de gestionnaire dans la route racine pour renvoyer une chaîne "Hello, world!".

Lorsque nous exécuterons notre application, nous verrons l'enregistrement du middleware dans la sortie :

Starting middleware
Ending middleware
Latency: 277.1µs

3. Résumé

Cet article présente brièvement trois frameworks Web couramment utilisés dans Golang : Gin, Beego et Echo. Nous avons également montré comment créer une application Web simple à l'aide du framework Gin et comment utiliser le routage et le middleware.

L'apprentissage du développement web Golang est indissociable de l'apprentissage des frameworks web. Cependant, différents frameworks Web ciblent différents scénarios et besoins d'application, et les développeurs doivent choisir le framework qui leur convient le mieux en fonction de la situation réelle.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!