Golang learning the use of web framework gin

Usage of Web framework gin for Golang learning

With the development of the Internet, Web applications have become the standard configuration of various software systems. The server-side development languages ​​for web applications are becoming more and more diversified. Among them, Golang's high performance and concise syntax style are increasingly favored by developers. This article will introduce one of the commonly used web frameworks in Golang: gin.

1. What is gin

gin is a web application framework written in Go language. It is based on the httprouter package and the net/http standard library, providing high performance, efficiency, ease of use and powerful functions. Use gin to quickly build a web server and support functions such as RESTful API, routing grouping, middleware, parameter binding, and template rendering.

2. Installation of gin

Before using the gin framework, you need to install gin first. You can use the following command line to install:

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

3. Basic use of gin

Below, we use an example to demonstrate how to use gin to write a simple Web service.

1. Import the gin package

Import the gin package at the head of the code file:

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

2. Create the gin engine

Use the gin.New() method to create a new gin engine.

r := gin.New()

3. Define routes

Use r.GET(), r.POST(), r.PUT() and r.DELETE() methods to define routes, Among them, the first parameter is the routing path, and the second parameter is the routing processing function.

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

4. Start the service

Use the r.Run() method to start the service and specify the service address and port number.

r.Run(":8080")

The complete code is as follows:

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. Gin routing

1. Basic routing

In gin, the routing is It consists of routing methods, request paths and processing functions. The routing methods include GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS, etc. Use methods such as r.GET(), r.POST(), r.PUT(), and r.DELETE() to define routes.

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

2. Routes with parameters

Use colon (:) to define routes with parameters.

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

3. Routing for multiple request types

Use the r.Handle() method to define routing for multiple request types.

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")
})

4. Routing grouping

Use the r.Group() method to implement routing grouping. You can add middleware and shared routing processing functions to the routing group.

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

5. Gin middleware

1. Using middleware

Using gin middleware can achieve many useful functions, such as authentication and logging , caching, performance analysis, etc. Use the r.Use() method to register middleware.

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

2. Writing middleware

Writing middleware method is very simple. You only need to create a function with a parameter of type gin.Context and call it in the function. c.Next() method can realize the function of middleware.

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 parameter binding

1. Binding Query parameters

Use the c.Query() method to obtain query parameters.

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)
})

2. Bind POST form

Use the c.PostForm() method to obtain POST form data.

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,
    })
})

3. Bind JSON data

Use the c.BindJSON() method to bind JSON data.

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. Gin template rendering

Using the gin framework can facilitate template rendering and supports multiple template engines, such as html, json, xml, etc.

1. Install the template engine

Use the go get command to install the template engine.

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

2. Load template

Use the gin.LoadHTMLGlob() method to load the template file.

r.LoadHTMLGlob("html/*")

3. Rendering template

Use the c.HTML() method to render the template.

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

8. Conclusion

This article introduces the basic steps and techniques to build a Web server using the gin framework. Golang's high performance and concise syntax style make it more and more popular among developers in the development of web services. I hope this article can bring some inspiration and help to Golang web server developers.

The above is the detailed content of Golang learning the use of web framework gin. For more information, please follow other related articles on the PHP Chinese website!