Gin介绍

Gin是一个轻量级的Web框架，基于Go语言实现。它具有快速、高效、易用等特点，被广泛应用于构建Web应用程序和API服务。以下是Gin框架的一些特点和优势：

高性能：Gin框架使用了Go语言的协程和异步IO等特性，具有非常高的性能，能够处理大量的并发请求。
简单易用：Gin框架的API设计简单明了，易于理解和使用。同时，它提供了丰富的中间件和插件，方便扩展和定制。
路由灵活：Gin框架的路由支持RESTful风格和参数传递，可以满足各种路由需求。
错误处理：Gin框架提供了全局的错误处理机制，可以方便地处理各种错误和异常情况。
渲染模板：Gin框架支持多种模板引擎，可以方便地渲染HTML模板。
中间件支持：Gin框架提供了丰富的中间件支持，包括日志、跨域、认证、缓存等，可以方便地定制和扩展。
调试方便：Gin框架提供了方便的调试工具，可以输出请求和响应的详细信息，方便调试和排查问题。

总之，Gin框架是一个非常优秀的Web框架，具有高性能、简单易用、灵活扩展等特点，非常适合构建Web应用程序和API服务。

Gin安装及使用

以下是使用Gin框架创建Go项目的详细步骤：

安装Go语言环境：在开始之前，需要先安装Go语言环境。可以在官网下载对应操作系统的安装包进行安装。
创建项目目录：在任意位置创建一个新的项目目录，例如 go-gin-demo。
初始化项目：在项目目录下执行以下命令初始化Go项目：

go mod init go-gin-demo

这行代码是用来初始化一个Go模块的，其中"go-gin-demo"是模块的名称。Go模块是Go语言1.11版本之后引入的包管理机制，它可以帮助开发者管理和维护依赖包的版本和更新。在使用Go模块之前，需要先使用该命令来初始化一个模块，以便后续在项目中引入依赖包。该命令会在当前目录下生成一个go.mod文件，用于记录项目的依赖关系和版本信息。

安装Gin框架：执行以下命令安装Gin框架：

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

这个命令会自动下载并安装Gin框架及其依赖包。

windows下使用镜像地址

在Windows系统中，设置环境变量的语法与Linux或macOS有所不同。您可以尝试使用以下命令来设置GO111MODULE环境变量：

set GO111MODULE=on

然后再次尝试执行命令：

set GOPROXY=https://goproxy.cn,direct
go get -u github.com/gin-gonic/gin

这应该可以让您成功地使用goproxy.cn的镜像下载地址安装gin。

查看gin框架是否安装，及版本信息

您可以使用以下命令来检查Gin框架是否已经安装以及其版本信息：

go list -m github.com/gin-gonic/gin

如果Gin框架已经安装，您应该会看到类似以下的输出：

github.com/gin-gonic/gin v1.7.4

其中，v1.7.4是当前安装的Gin框架的版本号。如果您看到类似的输出，那么说明Gin框架已经安装并且版本号为v1.7.4。如果您没有看到任何输出，那么说明Gin框架尚未安装。

创建主程序文件：在项目目录下创建一个名为 main.go 的文件，用于编写主程序代码。
编写代码：在 main.go 文件中编写以下代码：

package main

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

func main() {
    // 创建一个默认的 Gin 实例
    r := gin.Default()
    
    // 当接收到 GET 请求并且 URL 为 "/" 时，执行后面的匿名函数
    //*gin.Context是变量c的类型，由于要修改参数的属性或调用方法，需要传入指针gin.Context前面需要加*
    r.GET("/", func(c *gin.Context) {
        // 使用 JSON 格式返回一个消息，状态码为 200
        c.JSON(200, gin.H{
            "message": "Hello, World!",
        })
    })
    
    // 启动 Gin，监听并在 0.0.0.0:8080 上提供服务
    r.Run()
}

当用户访问根路径时，会返回一个JSON格式的响应。

这段代码创建了一个简单的 Gin 服务，它监听在 0.0.0.0:8080 上，当接收到 GET 请求并且 URL 为 "/" 时，返回一个 JSON 格式的消息 "Hello, World!"。以下是对每行代码的详细解释：

r := gin.Default()：创建一个默认的 Gin 实例，包含 Logger、Recovery 中间件等。
r.GET("/", func(c *gin.Context) { ... })：当接收到 GET 请求并且 URL 为 "/" 时，执行后面的匿名函数。
在 Gin 框架中，gin.Context 表示当前 HTTP 请求的上下文，包含了 HTTP 请求和响应的相关信息，如请求头、请求参数、响应状态码等。
c.JSON(200, gin.H{ "message": "Hello, World!" })：使用 JSON 格式返回一个消息，状态码为 200，消息内容为一个包含 "message" 属性的 JSON 对象。
r.Run()：启动 Gin，监听并在 0.0.0.0:8080 上提供服务。
运行程序：在命令行中进入项目目录，并执行以下命令运行程序：

go run main.go

这个命令会启动Gin应用程序，监听默认端口8080。

测试程序：在浏览器中访问 http://localhost:8080，应该能看到一个JSON格式的响应。

以上就是使用Gin框架创建Go项目的详细步骤。根据需要可以进一步扩展应用程序，添加路由、中间件、数据库等功能。

更改启动端口号

可以通过在 r.Run() 中传入一个字符串参数来更改启动端口号，例如：

r.Run(":8888")

这样就会在 0.0.0.0:8888 上启动 Gin 服务。如果想要在指定的 IP 地址和端口上启动服务，可以传入一个带有 IP 地址和端口号的字符串，例如：

r.Run("127.0.0.1:8888")

这样就会在 127.0.0.1:8888 上启动 Gin 服务。

Gin路由通配符

在 Gin 框架中，常用的路由通配符有以下三种：

*：通配符匹配任意字符，包括 /。可以用于匹配不确定长度的路径片段，例如：

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


r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))

当访问 /user/john 时，name 参数的值为 john；当访问 /user/john/smith 时，name 参数的值为 john/smith。

:：冒号后面的字符会被视为参数名，匹配任意非 / 字符，例如：

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

当访问 /user/john 时，name 参数的值为 john。

/*：匹配所有路径，包括 /，例如：

router.GET("/*path", func(c *gin.Context) {
    path := c.Param("path")
    c.String(http.StatusOK, "Path is %s", path)
})

当访问 /user/john 时，path 参数的值为 /user/john；当访问 /user/john/smith 时，path 参数的值为 /user/john/smith。

以上是 Gin 框架中常用的三种路由通配符，它们可以灵活地处理不同的路由匹配需求。

gin

Default()

gin.Default() 方法的签名如下：

func Default() *Engine

其中，返回值是一个指向 Engine 结构体的指针。Engine 结构体是 gin 框架的核心结构体，负责处理所有的 HTTP 请求，并将它们分发到对应的路由处理函数中。Default() 方法会创建一个默认的 Engine 实例，并添加一些默认的中间件和配置。

gin.Default() 是 gin 框架中的一个函数，用于创建一个默认的 gin.Engine 实例。在 gin 中，gin.Engine 是整个框架的核心，它负责处理所有的 HTTP 请求，并将它们分发到对应的路由处理函数中。

gin.Default() 函数会创建一个默认的 gin.Engine 实例，并添加一些默认的中间件，例如 Logger 中间件和 Recovery 中间件，这些中间件可以帮助我们记录日志和处理异常。此外，它还会设置一些默认的配置，例如监听的端口号和模式等。

以下是一个简单的示例，演示了如何使用 gin.Default() 函数创建一个默认的 gin.Engine 实例：

package main

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

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

    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })

    r.Run(":8080")
}

在上面的示例中，我们使用 gin.Default() 函数创建了一个默认的 gin.Engine 实例，并定义了一个路由处理函数，对应 GET /ping 请求。通过这种方式，我们可以快速创建一个简单的 Web 服务。

HandlerFunc类型

gin.HandlerFunc 是 Gin 框架中的一个类型，它是一个处理 HTTP 请求的函数类型。它的原型如下：

type HandlerFunc func(*Context)

参数 *Context 是 Gin 框架中的上下文对象，它包含了当前请求的信息和响应的信息。

下面是每个参数的含义：

*Context：当前请求的上下文对象，包含了请求的信息和响应的信息。

下面是一个简单的示例，展示了如何使用 gin.HandlerFunc：

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

    // 使用 HandlerFunc 处理 GET 请求
    r.GET("/", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message": "Hello, World!",
        })
    })

    r.Run(":8080")
}

这个示例中，我们使用 gin.HandlerFunc 处理了根路径的 GET 请求。当收到 GET 请求时，函数会返回一个 JSON 响应，包含了一个简单的消息。

gin.HandlerFunc 的作用是处理 HTTP 请求，并根据请求返回相应的响应。它是 Gin 框架中最常用的处理请求的方法之一。

Engine

在 Gin 框架中，Engine 是核心结构体之一，代表了整个 web 应用程序。Engine 中封装了 HTTP 服务器的实例、路由、中间件等核心组件，提供了方便的 API 来注册路由、中间件和处理函数等。我们可以通过 Engine 结构体的实例来启动 HTTP 服务器，监听并处理来自客户端的请求。

Use

//...代表可以注册多个中间件函数
func (engine *Engine) Use(middleware ...HandlerFunc)

该方法用于向 Engine 实例添加中间件。参数 middleware 是一个可变参数，表示要添加的中间件函数列表。每个中间件函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    // 添加一个全局中间件
    r.Use(func(c *gin.Context) {
        c.Set("foo", "bar")
        c.Next()
    })

    r.GET("/", func(c *gin.Context) {
        foo := c.MustGet("foo").(string)
        c.String(200, "foo is %s", foo)
    })

    r.Run(":8080")
}

注册多个中间件函数的代码示例

HandlerFunc 类型的函数通常都需要一个 *Context 参数，用于处理 HTTP 请求和响应。

Logger、Auth 和 RateLimit 这三个中间件函数是这样定义的：

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 实现日志记录逻辑
        c.Next()
    }
}

func Auth() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 实现认证逻辑
        c.Next()
    }
}

func RateLimit() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 实现限流逻辑
        c.Next()
    }
}

在上面的示例中，我们分别定义了 Logger、Auth 和 RateLimit 三个中间件函数，它们都满足中间件函数的要求。在每个中间件函数中，我们实现了相应的逻辑，并在最后调用了 c.Next()，以便让请求继续传递给下一个中间件或路由处理函数。

在使用中间件时，我们需要使用 gin.Use() 方法将中间件函数注册到路由器中。例如：

func main() {
    r := gin.Default()
    r.Use(Logger(), Auth(), RateLimit())
    r.GET("/hello", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, Gin!")
    })
    r.Run(":8080")
}

在上面的示例中，我们使用了 Logger、Auth 和 RateLimit 三个中间件函数，并将它们注册到了路由器中。这样，每个请求到达 /hello 路由时，都会依次经过这三个中间件函数的处理。

Run

启动一个 HTTP 服务器

Engine.Run 方法的原型如下：

func (engine *Engine) Run(addr ...string) (err error)

其中，参数 addr 是可选的，表示要监听的地址。如果不传递该参数，则默认监听 localhost:8080。

下面是一个简单的示例：

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() // 默认监听 localhost:8080
    r.Run(":8080") //监听其他端口
}

在上面的示例中，我们创建了一个默认的 Gin 引擎 r，并注册了一个路由处理函数，该函数会返回一个字符串 "Hello, world!"。最后，我们调用了 r.Run() 方法，启动了一个 HTTP 服务器，监听默认的地址 localhost:8080。

GET

func (engine *Engine) GET(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个 GET 请求的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

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(":8080")
}

带请求参数，返回值是文件的写法

// @Summary 文字转语音
// @Description Retrieve a file for download based on query parameters
// @Tags files
// @Accept  json
// @Produce  octet-stream
// @Param message query string true "First parameter"
// @Param format query string true "Second parameter"
// @Success 200 {file} byte "File content"
// @Failure 404 {object} map[string]interface{} "File not found!"
// @Router /voice/textToVoice [get]
func textToVoice(c *gin.Context) {
	//message := "你好，这是一个测试示例"
	//todo 检查文件是否存在，存在则将其删除，防止覆盖掉
	filePath := "demo.mp3"
	//format := "mp3"
	//filePath := "demo.pcm"

	// 获取请求参数
	message := c.Query("message")
	format := c.Query("format")

	VoiceParser.TextToVoice(message, format, filePath)
	//text, _ := VoiceParser.VoiceToText(filePath, format)
	//fmt.Printf(text)
	// 检查文件是否存在
	if _, err := os.Stat(filePath); os.IsNotExist(err) {
		c.JSON(http.StatusNotFound, gin.H{"message": "File not found!"})
		return
	}

	// 设置下载的文件名
	// 可以根据需要设置，例如根据参数生成文件名
	c.Header("Content-Disposition", "attachment; filename="+filepath.Base(filePath))

	// 提供文件供下载
	c.File(filePath)
}

POST

func (engine *Engine) POST(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个 POST 请求的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    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(":8080")
}

DELETE

func (engine *Engine) DELETE(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个 DELETE 请求的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    r.DELETE("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(200, gin.H{
            "message": "delete user " + id + " successfully",
        })
    })

    r.Run(":8080")
}

PATCH

func (engine *Engine) PATCH(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个 PATCH 请求的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    r.PATCH("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(200, gin.H{
            "message": "update user " + id + " successfully",
        })
    })

    r.Run(":8080")
}

PUT

func (engine *Engine) PUT(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个 PUT 请求的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    r.PUT("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.JSON(200, gin.H{
            "message": "update user " + id + " successfully",
        })
    })

    r.Run(":8080")
}

Any

func (engine *Engine) Any(relativePath string, handlers ...HandlerFunc)

该方法用于向 Engine 实例添加一个支持任意 HTTP 方法的路由。参数 relativePath 是路由的相对路径，参数 handlers 是一个可变参数，表示要添加的处理函数列表。每个处理函数都需要满足 gin.HandlerFunc 类型的函数签名。

示例代码：

package main

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

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

    r.Any("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        method := c.Request.Method
        c.JSON(200, gin.H{
            "message": method + " user " + id + " successfully",
        })
    })

    r.Run(":8080")
}

Group

gin.Engine.Group() 方法是 Gin 框架中的一个路由分组方法，用于创建一组具有相同前缀的路由。该方法的签名如下：

func (engine *Engine) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup

其中，参数 relativePath 是路由分组的前缀，参数 handlers 是可选的中间件处理函数，类型为 ...HandlerFunc，表示可以传入多个 HandlerFunc 函数。

下面是每个参数的含义和作用：

relativePath：路由分组的前缀，用于指定一组具有相同前缀的路由。例如，如果我们想要创建一组以 /api 为前缀的路由，可以将 relativePath 参数设置为 /api。
handlers：可选的中间件处理函数，用于对该路由分组中的所有路由进行处理。这些处理函数可以是全局的中间件处理函数，也可以是针对该路由分组的中间件处理函数。例如，我们可以在路由分组中添加一个 AuthMiddleware 中间件函数，用于对该路由分组中的所有路由进行身份验证。

下面是一个示例代码，展示了如何使用 gin.Engine.Group() 方法来创建一个路由分组：

package main

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

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

    // 创建一个以 /api 为前缀的路由分组
    api := r.Group("/api")

    // 在路由分组中添加一个全局中间件处理函数
    api.Use(AuthMiddleware)

    // 添加一个 GET 请求路由
    api.GET("/users", ListUsers)

    // 添加一个 POST 请求路由
    api.POST("/users", CreateUser)

    r.Run(":8080")
}

func AuthMiddleware(c *gin.Context) {
    // 在这里进行身份验证
}

func ListUsers(c *gin.Context) {
    // 处理 GET /api/users 请求
}

func CreateUser(c *gin.Context) {
    // 处理 POST /api/users 请求
}

在上面的示例代码中，我们首先创建了一个以 /api 为前缀的路由分组，然后在路由分组中添加了一个全局中间件处理函数 AuthMiddleware，用于对该路由分组中的所有路由进行身份验证。接着，我们在路由分组中添加了一个 GET 请求路由 /users 和一个 POST 请求路由 /users，分别对应处理函数 ListUsers 和 CreateUser。最后，我们启动了 Gin 应用程序，并监听在端口 8080 上。

参数2的用法

当我们在使用 gin.Engine.Group() 方法时，可以通过参数 handlers 来传入一个或多个中间件处理函数。这些中间件函数将会在该路由分组中的所有路由处理函数之前被调用。

下面是一个示例代码，展示了如何使用参数2来添加一个中间件处理函数：

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

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

    // 创建一个路由分组，并添加一个中间件处理函数
    api := r.Group("/api", AuthMiddleware)

    // 添加一个 GET 请求路由
    api.GET("/users", ListUsers)

    r.Run(":8080")
}

func AuthMiddleware(c *gin.Context) {
    // 在这里进行身份验证
    token := c.GetHeader("Authorization")
    if token != "Bearer token123" {
        c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
        return
    }
    c.Next()
}

func ListUsers(c *gin.Context) {
    // 处理 GET /api/users 请求
    c.JSON(http.StatusOK, gin.H{"message": "List users"})
}

在上面的示例代码中，我们首先创建了一个路由分组 /api，并通过参数2的方式添加了一个中间件处理函数 AuthMiddleware。该中间件函数用于对该路由分组中的所有路由进行身份验证，判断请求头中的 Authorization 字段是否为 Bearer token123，如果不是，则返回 401 Unauthorized 响应。如果验证通过，则调用 c.Next() 方法，将请求传递给下一个处理函数。

接着，我们在路由分组中添加了一个 GET 请求路由 /users，对应处理函数 ListUsers。当请求 /api/users 时，该路由将会被匹配，并依次调用中间件处理函数 AuthMiddleware 和路由处理函数 ListUsers。如果身份验证失败，则中间件处理函数将会中止请求处理，并返回 401 Unauthorized 响应。

RouterGroup

结构体原型

type RouterGroup struct {
    Handlers HandlersChain
    basePath string
    engine   *Engine
    root     bool
}

参数含义

Handlers HandlersChain：存储中间件处理函数的切片。
basePath string：路由分组的完整路径。
engine *Engine：该路由分组所属的 Engine 实例。
root bool：表示该路由分组是否为根路由分组。

常用方法

Use

func (group *RouterGroup) Use(middleware ...HandlerFunc)

该方法用于为当前路由分组添加一个或多个中间件处理函数。这些中间件函数将会在该路由分组中的所有路由处理函数之前被调用。

Group

func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup

该方法用于在当前路由分组下创建一个新的路由分组，并返回该路由分组的指针。

GET

func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes

该方法用于添加一个 GET 请求路由。relativePath 表示路由的相对路径，handlers 表示该路由的处理函数列表。

POST

func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes

该方法用于添加一个 POST 请求路由。relativePath 表示路由的相对路径，handlers 表示该路由的处理函数列表。

PUT

func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes

该方法用于添加一个 PUT 请求路由。relativePath 表示路由的相对路径，handlers 表示该路由的处理函数列表。

DELETE

func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes

该方法用于添加一个 DELETE 请求路由。relativePath 表示路由的相对路径，handlers 表示该路由的处理函数列表。

代码示例

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

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

    // 创建一个路由分组，并添加一个中间件处理函数
    api := r.Group("/api", AuthMiddleware)

    // 添加一个 GET 请求路由
    api.GET("/users", ListUsers)

    // 添加一个 POST 请求路由
    api.POST("/users", CreateUser)

    r.Run(":8080")
}

func AuthMiddleware(c *gin.Context) {
    // 在这里进行身份验证
    token := c.GetHeader("Authorization")
    if token != "Bearer token123" {
        c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Unauthorized"})
        return
    }
    c.Next()
}

func ListUsers(c *gin.Context) {
    // 处理 GET /api/users 请求
    c.JSON(http.StatusOK, gin.H{"message": "List users"})
}

func CreateUser(c *gin.Context) {
    // 处理 POST /api/users 请求
    c.JSON(http.StatusOK, gin.H{"message": "Create user"})
}

在上面的示例代码中，我们首先创建了一个路由分组 /api，并通过 AuthMiddleware 方法添加了一个中间件处理函数。接着，我们在该路由分组中添加了一个 GET 请求路由 /users，对应处理函数 ListUsers，以及一个 POST 请求路由 /users，对应处理函数 CreateUser。当请求 /api/users 时，该路由将会被匹配，并依次调用中间件处理函数 AuthMiddleware 和路由处理函数 ListUsers。当请求 /api/users 并使用 POST 方法时，该路由将会被匹配，并依次调用中间件处理函数 AuthMiddleware 和路由处理函数 CreateUser。

gin.Context

在 Go 语言的 Gin 框架中，gin.Context 是一个结构体，代表了当前 HTTP 请求的上下文信息，包括请求和响应的信息，例如请求方法、请求头、请求参数、响应状态码、响应头、响应正文等。

gin.Context 的作用主要有以下几个方面：

通过 gin.Context 可以获取当前请求的所有信息，例如请求方法、请求 URL、请求参数等。
可以通过 gin.Context 对响应进行设置，例如设置响应状态码、响应头、响应正文等。
gin.Context 还提供了一些便捷的方法，例如 Bind()、JSON()、XML() 等，可以帮助我们快速地解析请求体，并将响应数据序列化为 JSON、XML 等格式。
gin.Context 还可以用于在中间件中传递数据，例如将用户信息存储在 gin.Context 中，在后续的请求处理中可以方便地获取该用户信息。

gin.Context.Next() 方法的原型如下：

func (c *Context) Next()

Next() 方法的作用是将请求传递给下一个中间件函数或路由处理函数。当一个中间件函数处理完请求后，调用 Next() 方法即可将请求传递给下一个中间件函数或路由处理函数。

下面是一个简单的示例，演示了如何使用 Next() 方法：

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 打印请求开始的日志
        log.Printf("Started %s %s", c.Request.Method, c.Request.URL.Path)

        // 调用 Next() 方法，将请求传递给下一个中间件函数或路由处理函数
        c.Next()

        // 打印请求结束的日志
        log.Printf("Completed %s %s", c.Request.Method, c.Request.URL.Path)
    }
}

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

    // 注册中间件函数
    r.Use(Logger())

    // 注册路由处理函数
    r.GET("/hello", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, Gin!")
    })

    r.Run(":8080")
}

在上面的示例中，我们定义了一个 Logger 中间件函数，用于记录请求的开始和结束时间。在中间件函数中，我们先打印请求开始的日志，然后调用 Next() 方法将请求传递给下一个中间件函数或路由处理函数，最后再打印请求结束的日志。

在 main 函数中，我们将 Logger 中间件函数注册到路由器中，然后注册了一个 /hello 路由处理函数，当请求到达 /hello 路由时，会先经过 Logger 中间件函数的处理，然后再经过路由处理函数的处理。在中间件函数和路由处理函数的处理过程中，我们都调用了 Next() 方法，以便将请求传递给下一个中间件函数或路由处理函数。

Param

func (c *Context) Param(key string) string

该方法用于获取路由参数中指定名称的值。参数 key 是路由参数的名称。

示例代码：

package main

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

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

    r.GET("/users/:id", func(c *gin.Context) {
        id := c.Param("id")
        c.String(200, "user id is %s", id)
    })

    r.Run(":8080")
}

Query

func (c *Context) Query(key string) string

该方法用于获取 URL 查询参数中指定名称的值。参数 key 是查询参数的名称。

示例代码：

package main

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

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

    r.GET("/users", func(c *gin.Context) {
        name := c.Query("name")
        age := c.Query("age")
        c.String(200, "name is %s, age is %s", name, age)
    })

    r.Run(":8080")
}

PostForm

func (c *Context) PostForm(key string) string

该方法用于获取 POST 请求中表单参数中指定名称的值。参数 key 是表单参数的名称。

示例代码：

package main

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

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

    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(":8080")
}

Set

gin.Context.Set() 方法的签名如下：

func (c *Context) Set(key string, value interface{})

Set() 方法的作用是将一个键值对存储到 gin.Context 实例中。这个键值对可以在后续的中间件函数或路由处理函数中被获取到。通过 Set() 方法，我们可以在 gin.Context 实例中存储一些与请求相关的数据，这些数据可以在后续的处理过程中被访问和使用。

下面是一个示例，演示了如何使用 Set() 方法：

func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 检查请求头中是否包含 Authorization 字段
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "missing Authorization header"})
            return
        }

        // 假设我们已经验证了 Authorization 字段，并从中提取出了用户信息
        user := "Alice"

        // 将用户信息存储到 gin.Context 实例中
        c.Set("user", user)

        // 调用 Next() 方法，将请求传递给下一个中间件函数或路由处理函数
        c.Next()
    }
}

func HelloHandler(c *gin.Context) {
    // 从 gin.Context 实例中获取用户信息
    user, exists := c.Get("user")
    if !exists {
        c.String(http.StatusInternalServerError, "missing user information")
        return
    }

    c.String(http.StatusOK, "Hello, %s!", user)
}

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

    // 注册中间件函数
    r.Use(AuthMiddleware())

    // 注册路由处理函数
    r.GET("/hello", HelloHandler)

    r.Run(":8080")
}

在上面的示例中，我们定义了一个 AuthMiddleware 中间件函数，用于检查请求头中是否包含 Authorization 字段，并从中提取出用户信息。在验证通过后，我们将用户信息存储到 gin.Context 实例中，然后调用 Next() 方法将请求传递给下一个中间件函数或路由处理函数。

在 HelloHandler 路由处理函数中，我们从 gin.Context 实例中获取用户信息，并根据用户信息生成响应。通过 Set() 方法和 Get() 方法，我们可以在中间件函数和路由处理函数之间共享数据。

Get

gin.Context.Get(key string) interface{} 方法用于获取指定键名对应的值。它返回一个 interface{} 类型的值，需要根据实际情况进行类型断言。

作用：获取指定键名对应的值。

代码示例：

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

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

	router.GET("/user/:name", func(c *gin.Context) {
		name := c.Param("name")
		age := c.Query("age")
		c.Set("user", name)
		c.Set("age", age)
		c.String(http.StatusOK, "Hello %s, age is %s", name, age)
	})

	router.GET("/get_user", func(c *gin.Context) {
		user := c.MustGet("user").(string)
		age := c.MustGet("age").(string)
		c.String(http.StatusOK, "user is %s, age is %s", user, age)
	})

	router.Run(":8080")
}

在上面的示例中，我们在第一个路由处理函数中使用了 c.Set 方法将键值对 "user": name 和 "age": age 存储到了 gin.Context 中。在第二个路由处理函数中，我们使用了 c.MustGet 方法获取了键名分别为 "user" 和 "age" 的值，并进行了类型断言。如果断言失败，程序会抛出 panic。最后，我们将获取到的值格式化后返回给客户端。

MustGet

gin.Context.MustGet(key string) interface{} 方法用于获取指定键名对应的值，如果键名不存在，会触发 panic。

含义：获取指定键名对应的值，如果键名不存在，会触发 panic。

代码示例：

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

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

	router.GET("/user/:name", func(c *gin.Context) {
		name := c.Param("name")
		age := c.Query("age")
		c.Set("user", name)
		c.Set("age", age)
		c.String(http.StatusOK, "Hello %s, age is %s", name, age)
	})

	router.GET("/get_user", func(c *gin.Context) {
		user := c.MustGet("user").(string)
		age := c.MustGet("age").(string)
		c.String(http.StatusOK, "user is %s, age is %s", user, age)
	})

	router.Run(":8080")
}

在上面的示例中，我们在第一个路由处理函数中使用了 c.Set 方法将键值对 "user": name 和 "age": age 存储到了 gin.Context 中。在第二个路由处理函数中，我们使用了 c.MustGet 方法获取了键名分别为 "user" 和 "age" 的值，并进行了类型断言。如果键名不存在，程序会抛出 panic。最后，我们将获取到的值格式化后返回给客户端。

GetHeader

func (c *Context) GetHeader(key string) string

该方法用于获取请求头中指定名称的值。参数 key 是请求头的名称。

示例代码：

package main

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

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

    r.GET("/users", func(c *gin.Context) {
        userAgent := c.GetHeader("User-Agent")
        c.String(200, "User-Agent is %s", userAgent)
    })

    r.Run(":8080")
}

SetHeader

func (c *Context) SetHeader(key string, value string)

该方法用于设置响应头中指定名称的值。参数 key 是响应头的名称，参数 value 是要设置的值。

示例代码：

package main

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

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

    r.GET("/users", func(c *gin.Context) {
        c.SetHeader("Content-Type", "application/json")
        c.JSON(200, gin.H{
            "message": "hello, world",
        })
    })

    r.Run(":8080")
}

JSON

func (c *Context) JSON(code int, obj interface{})

该方法用于以 JSON 格式返回响应结果。参数 code 是 HTTP 状态码，参数 obj 是要返回的 JSON 对象。

示例代码：

package main

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

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

    r.GET("/users", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "name": "Tom",
            "age":  18,
        })
    })

    r.Run(":8080")
}

gin.Context.JSON() 是 Gin 框架中的一个方法，用于将 JSON 格式的数据作为 HTTP 响应返回给客户端。它的函数签名如下：

//interface{}代表任意类型，obj interface{}代表obj是任意类型
func (c *Context) JSON(code int, obj interface{})

其中，code 表示 HTTP 响应状态码，obj 表示要返回的 JSON 数据。obj 参数可以是任何 Go 语言中的数据类型，包括基本数据类型、结构体、数组、切片等。

gin.Context.JSON() 方法会自动将 obj 参数转换为 JSON 格式的字符串，并设置响应头的 Content-Type 为 application/json。在返回响应时，它会自动将 JSON 字符串作为响应体发送给客户端。

下面是一个示例代码，演示了如何使用 gin.Context.JSON() 方法返回一个 JSON 格式的数据：

func handler(c *gin.Context) {
    // 定义一个结构体作为返回的 JSON 数据
    type Response struct {
        //`json:"message"`是一个注释，指定结构体字段在序列化为 JSON 格式时的名称
        Message string `json:"message"`
    }

    // 创建一个 Response 实例
    resp := Response{
        Message: "Hello, World!",
    }

    // 使用 JSON 格式返回 Response 实例
    c.JSON(http.StatusOK, resp)
}

在上面的代码中，我们定义了一个名为 Response 的结构体，其中包含一个 Message 字段。然后，我们创建了一个 Response 实例 resp，并将其作为参数传递给 gin.Context.JSON() 方法。在处理 HTTP 请求时，gin.Context.JSON() 方法会自动将 resp 转换为 JSON 格式的字符串，并将其作为 HTTP 响应发送给客户端。

c.JSON(http.StatusOK, resp) 的意思是将 resp 对象序列化为 JSON 格式，并将其作为 HTTP 响应的主体发送给客户端，同时设置 HTTP 状态码为 200。

String

func (c *Context) String(code int, format string, values ...interface{})

该方法用于以字符串格式返回响应结果。参数 code 是 HTTP 状态码，参数 format 是字符串格式，参数 values 是要格式化的值列表。

示例代码：

package main

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

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

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

    r.Run(":8080")
}

ShouldBindJson取出body体

在Gin框架中，如果你想从客户端接收一个map[string]interface{}类型的参数，通常的做法是接收JSON格式的请求体，并将其解析为Go中的map结构。

以下是一个简单的示例，展示如何在Gin框架中接收并处理这种类型的参数：

package main

import (
    "github.com/gin-gonic/gin"
    "net/http"
)

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

    r.POST("/api/data", func(c *gin.Context) {
        var data map[string]interface{}

        if err := c.ShouldBindJSON(&data); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }

        // 打印接收到的数据
        c.JSON(http.StatusOK, gin.H{"received_data": data})
    })

    r.Run(":8080")
}

在上述代码中，我们定义了一个POST路由/api/data。当客户端发送一个包含JSON请求体的POST请求到这个路由时，Gin会尝试将请求体解析为map[string]interface{}类型，并将其存储在data变量中。

你可以使用以下的curl命令测试这个示例：

curl -X POST -H "Content-Type: application/json" -d '{"key1":"value1", "key2":42}' http://localhost:8080/api/data

响应：

{"received_data":{"key1":"value1","key2":42}}

这样，你就成功地从客户端接收了一个map[string]interface{}类型的参数，并在服务器端进行了处理。

如果只想绑定body体中的一个子json，可以定义一个结构体。bind到这个结构体上，只用一个字段的值即可。

type RequestData struct {
	SpecificField map[string]interface{} `json:"specificField"`
}

gin.H

在 Go 语言的 Gin 框架中，gin.H 是一个 map[string]interface{} 类型的别名，它表示一个键值对的集合，用于存储 HTTP 响应的头部信息。

gin.H 的作用主要有以下几个方面：

gin.H 提供了一种便捷的方式来设置 HTTP 响应的头部信息，例如设置 Content-Type、Cache-Control 等。
gin.H 还可以用于构建 JSON、XML 等格式的响应数据，例如通过 c.JSON() 方法将 gin.H 对象序列化为 JSON 格式的响应数据。
在 Gin 框架中，gin.Context 的 Header() 方法返回的就是一个 gin.H 对象，因此可以通过该对象来获取当前 HTTP 请求的头部信息。

需要注意的是，由于 gin.H 是一个 map[string]interface{} 类型的别名，因此可以在其中存储任意类型的值。但是在实际使用中，建议只存储字符串类型的值，以免出现类型转换错误。

以下是一个使用 gin.H 设置响应头的示例代码：

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

    r.GET("/", func(c *gin.Context) {
        c.Header("Content-Type", "text/plain")
        c.Header("Cache-Control", "no-cache")
        c.String(http.StatusOK, "Hello, World!")
    })

    r.GET("/json", func(c *gin.Context) {
        data := gin.H{
            "message": "Hello, World!",
            "code":    http.StatusOK,
        }
        c.JSON(http.StatusOK, data)
    })

    r.Run(":8080")
}

在上述代码中，第一个路由处理函数中使用 c.Header() 方法分别设置了 Content-Type 和 Cache-Control 响应头。第二个路由处理函数中则使用 gin.H 构建了一个 JSON 格式的响应数据，并通过 c.JSON() 方法将其返回。

假设使用浏览器访问 http://localhost:8080/，则响应报文如下：

HTTP/1.1 200 OK
Content-Type: text/plain
Cache-Control: no-cache
Date: Wed, 09 Jun 2023 06:44:09 GMT
Content-Length: 13

Hello, World!

假设使用浏览器访问 http://localhost:8080/json，则响应报文如下：

HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Date: Wed, 09 Jun 2023 06:45:12 GMT
Content-Length: 39

{"code":200,"message":"Hello, World!"}

可以看到，第一个路由处理函数设置的 Content-Type 和 Cache-Control 响应头都被正确地返回了。第二个路由处理函数返回的 JSON 格式的响应数据也被正确地解析了。

Set

func (h H) Set(key string, value interface{}) H

该方法用于设置指定键的值。参数 key 是要设置的键名，参数 value 是要设置的值。

示例代码：

package main

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

func main() {
    h := gin.H{
        "name": "Tom",
        "age":  18,
    }

    h.Set("gender", "male")

    // 输出 {"name":"Tom","age":18,"gender":"male"}
    fmt.Println(h)
}

Get

func (h H) Get(key string) interface{}

该方法用于获取指定键的值。参数 key 是要获取的键名。

示例代码：

package main

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

func main() {
    h := gin.H{
        "name": "Tom",
        "age":  18,
    }

    name := h.Get("name")

    // 输出 Tom
    fmt.Println(name)
}

Del

func (h H) Del(key string) H

该方法用于删除指定键的值。参数 key 是要删除的键名。

示例代码：

package main

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

func main() {
    h := gin.H{
        "name": "Tom",
        "age":  18,
    }

    h.Del("age")

    // 输出 {"name":"Tom"}
    fmt.Println(h)
}

Merge

func (h H) Merge(m2 H) H

该方法用于将当前的 gin.H 对象与另一个 gin.H 对象合并。参数 m2 是要合并的另一个 gin.H 对象。

示例代码：

package main

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

func main() {
    h1 := gin.H{
        "name": "Tom",
        "age":  18,
    }

    h2 := gin.H{
        "gender": "male",
    }

    h := h1.Merge(h2)

    // 输出 {"name":"Tom","age":18,"gender":"male"}
    fmt.Println(h)
}

go：Gin框架

Gin介绍

Gin安装及使用

更改启动端口号

Gin路由通配符

gin

Default()

HandlerFunc类型

Engine

Use

Run

GET

POST

DELETE

PATCH

PUT

Any

Group

RouterGroup

结构体原型

参数含义

常用方法

Use

Group

GET

POST

PUT

DELETE

代码示例

gin.Context

Next

Param

Query

PostForm

Set

Get

MustGet

GetHeader

SetHeader

JSON

String

ShouldBindJson取出body体

gin.H

Set

Get

Del

Merge