gin(结）

最新推荐文章于 2024-05-17 21:12:53 发布

TOMOT77

最新推荐文章于 2024-05-17 21:12:53 发布

阅读量1.3k

点赞数 13

文章标签： gin 前端 golang 网络

本文链接：https://blog.csdn.net/TOMOT77/article/details/136124196

版权

gin day1

今天的目标就是学懂，看懂每一步代码。

gin框架

gin框架就是go语言的web框架。框架你也可以理解成一个库。里面有一堆封装好的工具，帮你实现各种各样的功能，这样使得你可以关注业务本身，而在写代码上少费力。

快速入门：

先懂得这些概念：
1.什么是模块
Go模块（Go Module）是Go语言的包管理和依赖管理系统，自Go 1.11版本引入。它提供了一种管理Go项目依赖的机制，使得开发者可以在项目中明确指定所使用的外部依赖包的版本。这种机制确保了项目的构建是可重复的，同时也简化了包的共享和版本控制。

Go模块的特点
版本控制：Go模块支持语义版本控制（Semantic Versioning），每个模块的版本号清晰地反映了该版本的变更性质（如向后兼容的更新、新特性添加或大变更）。

依赖管理：通过go.mod文件，Go模块允许你为项目指定精确的依赖版本，包括直接依赖和间接依赖。

易于共享：Go模块使得共享和使用其他开发者编写的Go代码变得更加简单，只需通过import语句引入模块路径即可使用。

模块代理：Go 1.13引入了模块代理（Module Proxy）的概念，允许通过设置GOPROXY环境变量来指定模块下载源，加快模块下载速度，提高依赖管理的效率。

使用Go模块
要在项目中启用Go模块支持：

初始化模块：在项目根目录下执行go mod init 命令，这会创建一个go.mod文件。通常是项目的包名或代码库的路径。

添加依赖：通过import语句在代码中引入所需的包，然后运行go build、go test或go mod tidy等命令。Go工具会自动更新go.mod文件，并可能创建一个go.sum文件来存储依赖的确切版本和校验和。

升级和管理依赖：可以使用go get命令来添加、更新或移除依赖。go mod tidy命令会移除项目不再使用的依赖，并更新go.mod文件以反映当前的依赖状态。

Go模块的好处
项目隔离：每个项目可以有自己的依赖版本，不同项目之间的依赖版本不会相互冲突。

构建可重复性：由于所有依赖的版本都被精确记录，项目的构建结果在任何环境下都是一致的。

简化依赖管理：无需将第三方包的源代码直接包含在项目仓库中，通过go.mod文件管理依赖使项目结构更清晰，依赖更新更简单。

2.工作区是什么？
工作区（Workspace）是一个概念，它用于组织和管理一个或多个相关的项目或模块，使得这些项目或模块可以作为一个整体被开发和管理。在不同的编程环境和工具中，工作区的具体实现和用法可能有所不同，但基本概念是一致的。对于Go语言来说，工作区的概念在Go 1.18版本中通过go.work文件被引入，主要用于管理和协调多个Go模块。

3.Go工作区的特点
多模块管理：Go工作区允许在一个共享的开发环境中同时处理多个Go模块。这对于开发大型项目或多个相互依赖的微服务非常有用。

本地协调：在工作区中，你可以本地修改多个模块，并且这些修改会被整个工作区中的其他模块所识别和使用，而不需要先将更改推送到远程仓库。

灵活的依赖管理：工作区使得跨模块的依赖管理变得更加灵活。你可以轻松地在本地模块之间进行更改，测试这些更改对其他模块的影响，然后再一次性提交所有的更改。

4.使用Go工作区
要在Go中创建一个工作区，你需要：

1.创建go.work文件：在工作区的根目录下创建一个名为go.work的文件。这个文件告诉Go工具链，哪些模块属于这个工作区。

2.指定工作区中的模块：在go.work文件中使用use关键字列出工作区包含的所有模块的路径。例如：

plaintext
Copy code
go 1.18

use (
./module-a
./module-b
)
3.开发和构建：在工作区根目录下执行Go命令（如go build、go test等）时，Go工具链会考虑到所有在go.work文件中指定的模块。

5.工作区的好处
简化本地开发：工作区简化了同时开发多个模块时的流程，特别是当这些模块相互依赖时。
提高生产力：无需频繁地推送和拉取远程仓库中的更改，开发者可以更快地测试和迭代。
灵活的测试：在提交更改之前，可以在本地环境中测试模块间的集成，确保所有更改都能协同工作。

快速入门解读：

D:\go\project>mkdir ginlearn
D:\go\project>cd ginlearn
D:\go\project\ginlearn>go work init
D:\go\project\ginlearn>mkdir helloworld
D:\go\project\ginlearn>cd helloworld
D:\go\project\ginlearn\helloworld>go mod init test.com/helloworld
go: creating new go.mod: module test.com/helloworld
D:\go\project\ginlearn\helloworld>cd ..
D:\go\project\ginlearn>go work use ./helloworld

解读：
创建一个新的项目目录
mkdir ginlearn：在D:\go\project目录下创建一个名为ginlearn的新目录，这将作为新项目的根目录。
cd ginlearn：切换到刚创建的ginlearn目录，后续的操作都将在这个目录下进行。

初始化Go工作区
go work init：在当前目录（D:\go\project\ginlearn）初始化一个新的Go工作区，这会创建一个go.work文件。这个文件用于定义工作区内包含的Go模块，使得你可以在本地开发环境中轻松管理和协调多个模块。

创建并初始化一个新的Go模块
mkdir helloworld：在ginlearn项目目录下创建一个名为helloworld的子目录，用于存放一个新的Go模块。
cd helloworld：切换到helloworld目录，准备在这个目录下初始化新的Go模块。
go mod init test.com/helloworld：在当前目录（D:\go\project\ginlearn\helloworld）初始化一个新的Go模块，模块名为test.com/helloworld。这会创建一个go.mod文件，该文件描述了模块的名称和其他依赖信息。

将新模块添加到工作区
cd …：返回到ginlearn项目根目录。
go work use ./helloworld：将helloworld模块添加到工作区。这个命令更新go.work文件，包含对helloworld模块的引用。这样，当你在工作区根目录（D:\go\project\ginlearn）中运行Go命令时，Go工具链会考虑到helloworld模块。

安装gin

下载安装gin后，依赖是灰色的代表还没有使用它。

package main

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

func main() {
	r := gin.Default()
	r.GET("/hello", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{
			"name": "hello",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}
}

解读：
1.先导包
2.**gin.Default()**创建了一个Gin引擎实例r。Default方法返回一个默认的路由引擎，已经包括了Logger和Recovery中间件，这两个中间件可以帮助记录日志和管理panic，使得服务更加稳定。
3.

	r.GET("/hello", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{
			"name": "hello",
		})
	})

这是设置路由：
设置了一个路由/hello，用于处理GET请求。当访问这个路由时，会执行一个匿名函数，这个函数接受一个*gin.Context类型的参数ctx，它封装了请求的上下文信息。函数内部，使用ctx.JSON方法返回一个JSON响应，状态码为200，内容是一个包含"name": "hello"键值对的JSON对象。

光是这样的理解我觉得还是很困难：再进一步解读：
要搞懂匿名函数的意义和ctx是什么。
匿名函数：
在Gin框架中，路由处理函数通常以匿名函数的形式提供。匿名函数允许你直接在路由定义中实现处理逻辑，而不需要单独定义一个函数。这种方式使得代码简洁且易于理解，特别是当处理逻辑相对简单时。
这里，r.GET(“/hello”, …)定义了一个处理HTTP GET请求的路由/hello。当这个路由被访问时，紧随其后的匿名函数就会被执行。

ctx（Context）
ctx是*gin.Context类型的实例，它是Gin框架提供的一个上下文对象，封装了当前HTTP请求的所有信息，以及对请求的响应操作的方法。你可以将ctx视为当前请求的上下文，通过它可以访问请求的数据（如查询参数、表单值、JSON请求体等），设置响应的数据，以及执行其他与请求处理相关的操作。

访问请求信息：比如，使用ctx.Query(“param”)来获取URL查询参数param的值，或者ctx.PostForm(“field”)来获取表单中名为field的字段值。

设置响应：在你的例子中，ctx.JSON(200, gin.H{“name”: “hello”})是使用ctx设置响应的一个例子。这条语句发送了一个HTTP状态码为200的响应，内容是一个JSON对象{“name”: “hello”}。gin.H是Gin提供的一个便利的方式来创建一个map，这个map会被自动转换为JSON。

最后启动HTTP服务器，监听8080端口。

路由 — 请求方法

package main

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

func main() {
	r := gin.Default()
	r.GET("/hello", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{
			"name": "hello",
		})
	})
	r.GET("/get", func(ctx *gin.Context) {
		ctx.JSON(200, "get")
	})
	r.POST("/post", func(ctx *gin.Context) {
		ctx.JSON(200, "post")
	})
	r.PUT("/put", func(ctx *gin.Context) {
		ctx.JSON(200, "update")
	})
	r.DELETE("/delete", func(ctx *gin.Context) {
		ctx.JSON(200, "delete")
	})
	r.Any("/any", func(ctx *gin.Context) {
		ctx.JSON(200, "Any")
	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}
}

这个就说几个要点：
指定了路由的响应方法，你用其他的方法去访问这个路由，就会报404。
如果想一个路由可以支持所有的方法，那么就要用Any来进行设置。
如果想一个路由支持某几种方法，那就分别写这个路由的这几种方法的实现。

路由—URL

URL书写时，我们不需要关系scheme和authority这两部分，我们主要通过path和query两部分的书写来进行资源定位。
静态url：

r.POST("/user/find", func(ctx *gin.Context) {
})

路径参数，比如/user/find/:id

r.POST("/user/find/:id", func(ctx *gin.Context) {
		param := ctx.Param("id")
		ctx.JSON(200, param)
	})

创建了一个路由/user/find/:id，其中:id是一个路径参数（path parameter），用于在URL路径中动态地表示数据（在这个例子中是用户的ID）。这种路由定义方式允许服务器接受包含特定ID的请求，如/user/find/123，其中123会被识别为ID的值。

param := ctx.Param(“id”)：这行代码通过调用ctx.Param方法，从请求的URL路径中提取名为id的路径参数的值，并将这个值存储在变量param中。例如，如果请求的URL是/user/find/123，那么param的值将会是"123"。

*模糊匹配，比如/user/path

r.POST("/user/*path", func(ctx *gin.Context) {
		param := ctx.Param("path")
		ctx.JSON(200, param)
})

r.POST("/user/path", …)定义了一个路由规则，它可以匹配如/user/action、/user/settings/profile等任意以/user/开头的POST请求。**这里的path是一个动态部分，它会匹配这个位置及之后的所有路径。**
param := ctx.Param(“path”)：这行代码通过ctx.Param方法从请求的URL中提取名为path的参数值。例如，如果请求的URL是/user/settings/profile，则param将包含settings/profile。

有一个点需要注意，就是两种动态方式，不能一起用，这里我说的一起用是前缀不能相同，否则就会产生矛盾。

分组路由

v1 := r.Group("/v1")
	{
		v1.GET("find", func(ctx *gin.Context) {
			ctx.JSON(200, "v1 find")
		})
		v1.GET("save", func(ctx *gin.Context) {
			ctx.JSON(200, "v1 save")
		})
	}

	v2 := r.Group("/v2")
	{
		v2.GET("find", func(ctx *gin.Context) {
			ctx.JSON(200, "v2 find")
		})
		v2.GET("save", func(ctx *gin.Context) {
			ctx.JSON(200, "v2 save")
		})
	}

这个思想对于业务上是很直观的，
比如一个程序版本是v1，那么对其的所有程序的编写那就是v1版本，当想提升版本的时候，总不可能去对v1进行改动，这里就采用了组的形式，可以有效的分组进行版本管理，可以看到上述例子还是非常的直观。
对于用户来说就是去改了一点点域名，由访问/v1而改去访问/v2
这种思想在分模块里面也是很好用的，比如我可以进行分组/user 和/goods。

请求参数

http://localhost:8080/user/save?id=11&name=zhangsan
比如我要获取这个里面的参数：？号后面的就是参数，这个显然是键值对的形式。

r := gin.Default()
	//http://localhost:8080/user/save?id=11&name=zhangsan
	r.GET("user/save", func(ctx *gin.Context) {
		id := ctx.Query("id")
		name := ctx.Query("name")
		ctx.JSON(200, gin.H{
			"id":   id,
			"name": name,
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

这里是通过Query，来获取里面的参数，传参传的是key，返回值是value。
还可以通过GetQuery，这种方式相比Query的好处就是它有一个返回值是判断，
GetQuery(“address”),实际上我要访问的这个url中，根本就没有这个参数，那么返回值就是""和flase。这种在处理如果没有该字段那就进行处理这种场景也是很好用的。
ctx.DefaultQuery(“address”,“beijing”)，这个就是如果不存在就会给个默认值这种用法。这个用法也是很常见的。

上面这种方法有它的不足，使用这几个方法，得到的返回值value都是string类型的。那么有没有方法，可以直接返回上面参数，并且类型要符合要求，比如id那就是int，name那就是string。
回答是可以的，要通过结构体实现ctx.BindQuery(&struct)

type User struct {
	Id   int64  `form:"id"`
	Name string `form:"name"`
}

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.BindQuery(&user)
		if err != nil {
			log.Println(err)
		}
		ctx.JSON(200, user)
	})
	err := r.Run()
	if err != nil {
		log.Fatalln(err)
	}

这个结构体中的tag标签也是非常重要，这样才能使得参数与结构体里面的属性绑定起来，这样返回到结构体中的数据，那不就是有数据类型了 ，也就达到了要求。

但是更推荐使用ShouldBindQuery
再来看看这个例子

type User struct {
	Id      int64  `form:"id"`
	Name    string `form:"name"`
	Address string `form:"address" binding:"required"`
}
这个多加的binding：required表示在绑定的时候这个字段是必须的。

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		err := ctx.ShouldBindQuery(&user)
		if err != nil {
			log.Println(err)
		}
		ctx.JSON(200, user)
	})
	err := r.Run()
	if err != nil {
		log.Fatalln(err)
	}

现在调用的话，虽然结果不会错（状态码是对的），但是在ide环境上是会报错的，原因也是很简单，那就是Address属性是必须的，但是代码中并没有发生address的值绑定。
但是如果在加了这个标签的情况下，那就会发生错误，状态码直接400，而且返回值你会发现好像不是Json类型了。

总结：
一般用ShouldBindQuery，因为这种更方便，就算ide报了错，在结果上是不会产生影响的。ide上的错误处理又非常的容易。

两个方法如果属性都对应的上，那么确实是会出现两种方式都可以的情况。

数组参数

传数组类型的参数是这么来传
http://localhost:8080/user/save?address=Beijing&address=shanghai
传参的时候传相同的参数名 ，只是值不同，值相同也是可以的。

理解：
这个URL相当于前端，后端我们就是要用个数组去接收value，现在我们的关注点就是怎么用数组接。

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		http: //localhost:8080/user/save?address=Beijing&address=shanghai
		address := ctx.QueryArray("address")
		ctx.JSON(200, address)

	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

这里采用了QueryArray，返回值是string类型的切片。
同理可以使用GetQueryArray，有个判断的功能。
注意这个就没有Default的功能。

仍然可以实现绑定功能。

type User struct {
	Id      int64    `form:"id"`
	Name    string   `form:"name"`
	Address []string `form:"address" binding:"required"`
}

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		var user User
		ctx.ShouldBindQuery(&user)
		ctx.JSON(200, user)

	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

map参数

先看map传参时，url的格式是如何传的。
http://localhost:8080/user/save?addressMap[home]=Beijing&addressMap[company]=shanghai

现在我们要关注的就是后端怎么去接收这样的参数。
主要是通过ctx.QueryMap(map名)来实现的，对于上面参数，[]里面的就是key，=就是value。

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		addressMap := ctx.QueryMap("addressMap")
		ctx.JSON(200, addressMap)
	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

map不支持绑定的方式去拿。
只能通过QueryMap

Post请求参数

post一般针对的是表单参数和Json参数。
所以要发送的是Post请求。

这个例子是获取Form表单的参数
用的一般是PostForm,当然也有Get前缀的方法和Default前缀的方法，这个在前面也学习过，一种是带判断，一种是带默认值。

怎么理解数组参数，就是一个key有多个value。这就是数组。

r := gin.Default()
	r.POST("/user/save", func(ctx *gin.Context) {
		id := ctx.PostForm("id")
		name := ctx.PostForm("name")
		address := ctx.PostFormArray("address")
		addressMap := ctx.PostFormMap("addressMap")
		ctx.JSON(200, gin.H{
			"id":         id,
			"name":       name,
			"address":    address,
			"addressMap": addressMap,
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

当然也是可以使用结构体绑定，这里绑定就是单纯的ShouldBind(&user)

r := gin.Default()
	r.POST("/user/save", func(ctx *gin.Context) {
		var user User
		ctx.ShouldBind(&user)
		ctx.JSON(200, user)
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

但是有同样的问题，map同样获取不到。如果你一定要这个user里面的map有值，你只能直接去通过QueryMap单独获取了然后对user结构体的map字段赋值，然后再进行响应设置。

Json参数

这种获取参数可以采用绑定的形式

r := gin.Default()
	r.POST("/user/save", func(ctx *gin.Context) {
		var user User
		ctx.ShouldBindJSON(&user)
		ctx.JSON(200, user)
	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

这里在知道是Json数据的情况下最好使用ShouldBindJSON

路径参数

这里有一个问题：

type User struct {
	Id         int64                  `form:"id"`
	Name       string                 `form:"name"`
	Address    []string               `form:"address" binding:"required"`
	AddressMap map[string]interface{} `form:"addressMap"`
}

这里说的是关于映射关系：
比如我访问的时候：

{
    "Id": 11,
    "Name": "zhangsan",
    "Address": [
        "beijing",
        "shanghai"
    ],
    "AddressMap": {
        "home":"beijing"
    }
}

我的json数据我突然改了Address改为Addressess，这显然肯定就映射不到了。
这里我们想当然的去更改结构体里面的标签，想通过form标签的修改从而使得Address和addressess又匹配上。但是你这么做你就会发现还是匹配不上：这里说说原理：
这是因为实际上这个匹配关系根form标签没什么关系，这里默认情况下Json是将字段名转成小写实现了匹配，这里要想实现匹配，那么用的标签就不是form而是使用json标签来做修改。
这是用json匹配的一个重点。

路径参数：

r := gin.Default()
	r.POST("/user/save/:id/:name", func(ctx *gin.Context) {
		id := ctx.Param("id")
		name := ctx.Param("name")
		ctx.JSON(200, gin.H{
			"id":   id,
			"name": name,
		})
	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

这个其实也讲过，就是利用Param从url里提取参数，然后进行返回。

也可以用绑定的形式去获取。
这个有个要点，要加上uri的tag。不然ShouldBindUri(&user)进行绑定时找不到它要对应的属性。
uri:“id” 这样的tag。

简单情况下就用param。复杂用tag

文件参数

用的MultipartFor

r := gin.Default()
	r.POST("/user/save", func(ctx *gin.Context) {
		form, err1 := ctx.MultipartForm()
		if err1 != nil {
			log.Fatalln(err1)
		}
		value := form.Value
		files := form.File
		for _, fileArray := range files {
			for _, v := range fileArray {
				ctx.SaveUploadedFile(v, "./"+v.Filename)
			}
		}

		ctx.JSON(200, value)
	})

	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

我看的时候心中还是有疑惑的。

form, err1 := ctx.MultipartForm()：从请求中解析多部分表单数据。这个方法返回两个值：一个multipart.Form对象和一个可能的错误。如果解析过程中出现错误，错误会被记录，并通过log.Fatalln(err1)输出。

value := form.Value：form.Value包含了所有表单的文本字段（键值对）。这些是非文件字段。

files := form.File：form.File包含了所有上传的文件，这些文件被组织为一个映射，其中键是表单字段名，值是对应的一组文件。

一组文件的理解：
不是文件夹：在这个上下文中，“一组文件”指的是用户通过单个表单字段上传的多个文件，而不是指一个文件夹或目录。这些文件以列表（Slice）的形式存在，每个列表项代表一个文件。
这个就是非常字面的意思，比如一个file1（key），它可以有多个value（别问为什么，就是这样的），允许用户为同一个字段名（在这个例子中是file1）选择多个文件进行上传。这意味着对于这个字段名file1，可以上传多个文件，比如1.png, 2.png等。。所以一个key就代表了一个文件组，里面的文件以slice的形式存在，所以才需要先遍历for range 所有的文件组，然后才是遍历这个文件组里面的文件。

现在我正式来解读这段代码：
form, err1 := ctx.MultipartForm()
这个就是直接从请求中解析多部分得表单数据。会得到一给multipart.Form对象。
对这个对象调用这两个字段value := form.Value
files := form.File
两个都是获取得map。

value是map[string][]string类型的，代表了所有非文件的表单key和value的映射，并且这里也考虑到了key相同而且value有几个的情况，这也是很常见的，比如前面说到的json数组参数。

files是map[string]*[]FileHeader类型的，代表了文件组里面一层就是文件组中的文件。
这就是为什么要搞for循环的原因。

for _, fileArray := range files {
			for _, v := range fileArray {
				ctx.SaveUploadedFile(v, "./"+v.Filename)
			}
		}

外循环
for _, fileArray := range files：这个循环遍历files映射中的每个条目。每次迭代，fileArray会被赋值为与当前字段名相关联的文件数组（或说是切片）。这意味着，如果你的表单允许用户在多个不同的字段上传文件，这个循环会依次处理每个字段上传的所有文件。
内循环
for _, v := range fileArray：对于每个字段名对应的文件数组，这个内部循环会遍历数组中的每个文件。在每次迭代中，v被赋值为当前的文件，它是一个*multipart.FileHeader实例，代表一个上传的文件。
文件保存
ctx.SaveUploadedFile(v, “./”+v.Filename)：对于每个文件v，这行代码调用SaveUploadedFile方法将它保存到服务器上。第一个参数是文件（*multipart.FileHeader类型），第二个参数是保存路径。这里使用"./"+v.Filename作为保存路径，意味着文件将被保存在服务器应用程序的当前工作目录下，文件名与上传时使用的文件名相同。

响应

所谓响应就是客户端请求发过来了，服务器给客户端返回什么东西。

gin中响应有多种方式（看需求选择）：

1.string方式：

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.String(200, "this is %s", "ms string value")
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

2.Json方式，前面用的一直是json形式。

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.JSON(200, gin.H{
			"name": "666",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

3.xml方式，这个结构上和json类似
相较于json，就只是改个函数调用，值得格式都是一样。
只是xml不像json搞得键值对，而是这种形式666，key直接括起value。

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.XML(200, gin.H{
			"name": "666",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

当然也可以自行定义结构体，但是注意要打标签xml:"id"

4.文件方式

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.File("文件路径")
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

这个如果你用浏览器去访问，那其实就是下载
如果改成ctx.FileAttachment(”文件路径“，“下载的时候改文件的名字”）

5.设置http响应头

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.Header("test","ms")
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

test是key，ms是value
这个就是用来在响应的时候更改头信息。

6.重定向
就是在访问的时候跳转到另一个地方去。
注意这个用状态码不能用200，只能用301，这个在http包下是http.StatusMovedPermanently

r := gin.Default()
	r.GET("/user/save", func(ctx *gin.Context) {
		ctx.Redirect(http.StatusMovedPermanently,"https://www.baidu.com")
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

后面第二个参数就是重定向后的地址。就实现跳转到百度了。

7.YAML方式
用法和json一样的。就是函数改成YAML
这种格式只是有时候对这种格式有需求的时候就可以用。

8.还可以返回protoBuf格式。

模板渲染

模板是golang语言的一个标准库，使用场景很多，gin框架同样支持模板。
1.基本使用

r := gin.Default()
	r.LoadHTMLFiles("./templates/index.tmpl") 
	r.GET("/index", func(ctx *gin.Context) {
		ctx.HTML(200, "index.tmpl", gin.H{
			"title": "hello template",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

1.先加载模板，就是模板的路径
2.然后还是构造get请求，访问的路由是/index，处理函数。是在响应的时候返回HTML，第二个参数就是使用模板，直接写模板的名字，然后就是传入占位符的参数，这里串了一个结构体进去，与占位符title完成映射。

2.多个模板渲染
如果有多个模板。可以统一进行渲染。
就是templates这个文件夹下，可能有多个模板文件。
想要同时使用多个，比如两个，仍然可以使用r,LoadHTMLFiles函数。直接在后面打个逗号再多加载一个模板，然后再针对这个模板写一个Get请求时的响应方式即可。

r := gin.Default()
	r.LoadHTMLFiles("./templates/index.tmpl","./templates/user.tmpl")
	r.GET("/index", func(ctx *gin.Context) {
		ctx.HTML(200, "index.tmpl", gin.H{
			"title": "hello template",
		})
	})
	r.GET("/user", func(ctx *gin.Context) {
		ctx.HTML(200, "user.tmpl", gin.H{
			"title": "hello user template",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

如果模板再多一点，那加载模板就要写一堆，这里还有方法：
可以使用正则表达式：
加载模板的函数改成这个：r.LoadHTMLGlob("./templates/") 加载templates下面的所有模板。
这种方法有注意事项。如果templates里面还有一个文件夹里面还有模板，那么这种情况叫做加载子模板，这个时候就要用./templates//*代表子模版，不然就会报错

自定义模板函数

啥时候用：当我们想对模板进行一些处理时用。这样能够使用起来更加的便捷。

实现也非常容易，但是注意这个要在加载模板之前完成。要先定义后加载。
模板：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>gin_templates</title>
</head>
<body>
{{.title | safe}}
</body>
</html>

r := gin.Default()

	r.SetFuncMap(template.FuncMap{
		"safe": func(str string) template.HTML {
			return template.HTML(str)
		},
	})

	// 模板解析,解析templates目录下的所有模板文件
	r.LoadHTMLGlob("templates/**")

	r.GET("/index", func(c *gin.Context) {
		// HTML请求
		// 模板的渲染
		c.HTML(http.StatusOK, "index.tmpl", gin.H{
			"title": "<a href='http://baidu.com'>跳转到其他地方</a>",
		})
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}
}

首先具体说说自定义模板函数有什么用：
从模板文件就可以看出来，主函数只是实现。
在提供的HTML模板文件中，{{.title | safe}}使用了一个占位符title。这里，title是模板渲染时传入的数据的一部分，可以被动态替换。| safe表示在渲染title变量时，会通过名为safe的函数进行处理。这个函数的目的是将传入的字符串标记为安全的HTML，不会被自动转义。

总的来说这个模板函数的作用就是在你使用模板的时候，你要传参，那么这个函数就可以对传入的这个参数进行处理，这个参数在模板中的体现就是这个占位符。
{{.title | safe}}这里就注意下这种格式。

然后就是函数实现：

r.SetFuncMap(template.FuncMap{
		"safe": func(str string) template.HTML {
			return template.HTML(str)
		},
	})

参数对于这个函数就是str，然后返回值是一个HTML类型的。
“title”: “跳转到其他地方”,
正常来说那就直接对这个进行打印了，因为这就是一个字符串。但是经过这个处理函数处理之后，就会进行转义变成HTML格式的。

静态文件处理：

如果在模板中引入静态文件，比如样式文件index.css
模板文件为这样：

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>gin_templates</title>
    <link rel="stylesheet" href="/css/index.css">
</head>
<body>
{{.title}}
</body>
</html>

这里就引入了样式表，但是显然这个路径是不对的，正确的应该是./static/css/index.css才行
但是这里我就要这样做，看看有什么方法进行处理。
我要想办法让他能够找到这个正确的路径，这里的做法：
用了静态加载
r.Static("映射“,“映射到正确的目录”）

r.Static("/css", "./static/css")

这里就相当于对这个css做了映射。
简而言之就是前者是我在模板里面用的，后者就是实际这个文件所在的目录。

甚至可以直接指定正确的文件在哪个目录。

会话

会话涉及到cookie和session的使用。

cookie

1、设置cookie
func (c *Context) SetCookie(name, value string, maxAge int, path, domain string, secure, httpOnly bool)
name:cookie名
value:cookie值
maxAge:有效时间
path:cookie路径
domain:cookie作用域
secure:这个用来设置cookie只能用https发送给服务器
httpOnly：设置cookie不能被js获取到

r := gin.Default()
	r.GET("/cookie", func(c *gin.Context) {
		// 设置cookie
		c.SetCookie("site_cookie", "cookievalue", 3600, "/", "localhost", false, true)
	})
	err := r.Run(":8080")
	if err != nil {
		log.Fatalln(err)
	}

直接使用SetCookie函数，然后把那些参数都填好就完成了cookie的设置。

既然可以设置那就可以读取cookie。

2.读取cookie（根据cookie的名字读取）
就是通过data,err:=ctx.Cookie(“name”)来实现，err一般就是你访问的cookie根本就不存在，这个时候就会报错了。
读出来是cookie的value

3.删除cookie。
通过将cookie的MaxAge设置为-1达到删除cookie的目的，所以这还是用到了setcookie函数。别的都不用动，动这个Maxage字段就完成了实现。
调用之后你去浏览器里f12看，就会发现那个cookie不见了

Session

在gin框架中，我们可以依赖gin-contrib/sessions中间件处理session
安装session包

go get github.com/gin-contrib/sessions

看例子：

r := gin.Default()
	// 创建基于cookie的存储引擎，secret 参数是用于加密的密钥
	store := cookie.NewStore([]byte("secret"))
	// 设置session中间件，参数mysession，指的是session的名字，也是cookie的名字
	// store是前面创建的存储引擎，我们可以替换成其他存储引擎
	r.Use(sessions.Sessions("mysession", store))

	r.GET("/hello", func(c *gin.Context) {
		// 初始化session对象
		session := sessions.Default(c)
		// 通过session.Get读取session值
		// session是键值对格式数据，因此需要通过key查询数据
		if session.Get("hello") != "world" {
			fmt.Println("没读到")
			// 设置session数据
			session.Set("hello", "world")
			session.Save()
		}
		c.JSON(200, gin.H{"hello": session.Get("hello")})
	})
	r.Run(":8080")

虽然注释的很清楚了，但是我心中有一些疑问：
这里从知识方面再解读：
Session在Web应用中是用来持久化用户状态的一种机制。当用户与应用交互时，HTTP协议本身是无状态的，意味着服务器默认情况下不会记住用户之前的操作。Session通过在服务器端存储用户特定的信息来跨多个请求保持状态，而这些信息通过客户端的Cookie来引用。

当我们说“这些信息通过客户端的Cookie来引用”时，我们是指Session机制如何在客户端（例如，用户的浏览器）和服务器之间维持状态信息的关联。这个过程大致如下：
1. 服务器创建Session
当用户第一次访问应用时，服务器为该用户创建一个Session。这个Session包含一个唯一的标识符（通常称为Session ID）和与该用户相关的任何状态信息。

2. 发送Session ID到客户端
一旦Session创建完毕，服务器会将Session ID发送到客户端，方法是设置一个Cookie。这个Cookie包含Session ID，并随着HTTP响应一起发送回用户的浏览器。

3. 客户端存储Session ID
用户的浏览器接收到这个Cookie后，会将其存储起来。在之后的每次请求中，浏览器都会自动将这个Cookie（即包含Session ID的Cookie）随请求一起发送到服务器。

4.服务器识别Session
对于接下来的每一个请求，服务器通过请求中携带的Cookie中的Session ID，识别出是哪个用户发起的请求。服务器然后可以查找对应的Session数据，进而访问该用户的状态信息。

5. 状态信息的引用
这里，“通过客户端的Cookie来引用”实际上是指，客户端的Cookie（具体来说，是Cookie中的Session ID）被用作在服务器上查找特定Session数据的键。换句话说，客户端的Cookie（Session ID）为服务器提供了一个引用或索引，服务器用它来找到存储的状态信息，这些状态信息包含了用户特定的数据（如登录状态、购物车内容等）。

结论
因此，尽管状态信息（Session数据）存储在服务器端，客户端的Cookie（携带Session ID）起到了桥梁的作用，使得服务器能够为不同的用户请求匹配到正确的Session，从而“记住”用户的状态跨多个请求。这是一种在无状态的HTTP协议上实现状态保持的常用技术。

现在看这个代码压力就不大了。

cookie.NewStore([]byte(“secret”))创建一个基于Cookie的Session存储引擎，其中"secret"是用于加密Cookie的密钥，以保护Session数据的安全。
sessions.Sessions(“mysession”, store)中间件被添加到Gin应用中，其中"mysession"是Session（同时也是Cookie）的名字。这个中间件负责处理所有通过Gin路由的请求，为它们提供Session支持。

处理请求和操作Session
sessions.Default©获取当前请求的Session对象。
session.Get(“hello”)尝试从Session中读取键为"hello"的值。如果这是用户的第一次请求或者Session中没有设置该值，结果将为nil。
如果session.Get(“hello”)的结果不是"world"，则**通过session.Set(“hello”, “world”)在Session中设置值，并调用session.Save()**来确保更改被保存。这些更改将被存储在服务器端的Session存储中，并通过客户端的Cookie来引用。
c.JSON(200, gin.H{“hello”: session.Get(“hello”)})返回一个JSON响应，其中包含了从Session中读取的"hello"键的值。

多session

package main

import (
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	store := cookie.NewStore([]byte("secret"))
	sessionNames := []string{"a", "b"}
	r.Use(sessions.SessionsMany(sessionNames, store))

	r.GET("/hello", func(c *gin.Context) {
		sessionA := sessions.DefaultMany(c, "a")
		sessionB := sessions.DefaultMany(c, "b")

		if sessionA.Get("hello") != "world!" {
			sessionA.Set("hello", "world!")
			sessionA.Save()
		}

		if sessionB.Get("hello") != "world?" {
			sessionB.Set("hello", "world?")
			sessionB.Save()
		}

		c.JSON(200, gin.H{
			"a": sessionA.Get("hello"),
			"b": sessionB.Get("hello"),
		})
	})
	r.Run(":8080")
}

配置多Session中间件：r.Use(sessions.SessionsMany(sessionNames, store))向Gin引擎添加一个中间件，该中间件配置了多个Session。sessionNames := []string{“a”, “b”}定义了两个Session的名称"a"和"b"，这些Session将使用前面创建的cookie存储引擎。

设置路由和处理函数：
在GET /hello路由的处理函数中，使用sessions.DefaultMany(c, “a”)和sessions.DefaultMany(c, “b”)分别获取名为"a"和"b"的Session实例。然后就可以对Session进行进一步的操作。
检查每个Session中是否存在键"hello"，如果不存在或值不匹配，则分别设置它们的值为"world!“和"world?”，并保存更改。
最后，响应包含了从两个Session中获取到的"hello"键的值，展示了如何在同一个请求中独立管理多个Session。

也可以把Session存储在数据库中，比如redis。

中间件

在Gin框架中，中间件（Middleware）指的是可以拦截http请求-响应生命周期的特殊函数，在请求-响应生命周期中可以注册多个中间件，每个中间件执行不同的功能，一个中间执行完再轮到下一个中间件执行。

换句话说就是：请求发过来要穿过中间件，响应返回也要通过穿过中间件。

中间件的常见应用场景如下：

请求限速
api接口签名处理
权限校验
统一错误处理

Gin支持设置全局中间件和针对路由分组设置中间件，设置全局中间件意思就是会拦截所有请求，针对分组路由设置中间件，意思就是仅对这个分组下的路由起作用。

1.中间件的使用
从这个gin.Default的源码可以看出：

func Default() *Engine {
	debugPrintWARNINGDefault()
	engine := New()
	engine.Use(Logger(), Recovery())
	return engine
}

发现了创建中间件，然后调用中间件这样的操作。这里就使用了两个中间件一个Logger一个是Recovery

 r := gin.New()
	// 通过use设置全局中间件
	// 设置日志中间件，主要用于打印请求日志
	r.Use(gin.Logger())
	// 设置Recovery中间件，主要用于拦截paic错误，不至于导致进程崩掉
	r.Use(gin.Recovery())
	r.GET("/test", func(ctx *gin.Context) {
		panic(errors.New("test error"))
	})
	r.Run(":8080")

这里在请求中报了一个panic，如果用了中间件，那么就不会导致我们的程序启动不起来，会发现状态码是500，但是如果你没有用Recovery中间件，没有拦截panic错误，那么就会直接崩掉，你去访问这个路由会发现路由都是不存在的，因为服务器都没启动起来。

里面还用到了一个日志中间件，会打印日志。

中间件有啥好处：就是利用这些功能提供很大的便捷。

2.自定义中间件
可以去看看我们用的中间件有什么特征：

func Logger() HandlerFunc {
	return LoggerWithConfig(LoggerConfig{})
}

可以发现就是一个返回了HandlerFunc类型的函数。我们实际上就是去开发这个函数。可以看到内部返回了一个函数，我们自定义的目标就是去实现这样的内部返回函数。
比如我这里也来一个

func Logger() gin.HandleFunc{
	return func(c *gin.Context){
	fmt.Println("my custom midd)
	}
}

然后直接主函数里面调用use就可以了。这样就实现了一个简单的中间件的自定义。调用之后由于前面说过，请求会穿过中间件，那么我这个中间件在遇到请求的时候就会工作起来，然后打印一个my custom midd

package main
// 导入gin包
import (
"github.com/gin-gonic/gin"
	"log"
	"time"
)

// 自定义个日志中间件
func Logger() gin.HandlerFunc {
	return func(c *gin.Context) {
		t := time.Now()

		// 可以通过上下文对象，设置一些依附在上下文对象里面的键/值数据
		c.Set("example", "12345")

		// 在这里处理请求到达控制器函数之前的逻辑
     
		// 调用下一个中间件，或者控制器处理函数，具体得看注册了多少个中间件。
		c.Next()

		// 在这里可以处理请求返回给用户之前的逻辑
		latency := time.Since(t)
		log.Print(latency)

		// 例如，查询请求状态吗
		status := c.Writer.Status()
		log.Println(status)
	}
}

func main() {
	r := gin.New()
	// 注册上面自定义的日志中间件
	r.Use(Logger())

	r.GET("/test", func(c *gin.Context) {
		// 查询我们之前在日志中间件，注入的键值数据
		example := c.MustGet("example").(string)
		// it would print: "12345"
		log.Println(example)
	})

	// Listen and serve on 0.0.0.0:8080
	r.Run(":8080")
}

我觉得我第一次看不懂主要出现在纠结这个c.Next()的问题。下面详细解读：

调用c.Next()确实会将控制权传递给后续的处理链，通常是业务逻辑处理函数。然而，c.Next()的调用方式确实有点类似于"中断"或"钩子"的概念，但更准确地说，这是一种"中间件模式"的实现，它允许在请求的前后执行特定的代码。

如何理解c.Next()和中间件的工作机制？
当Gin处理一个请求时，它会按照中间件和路由处理函数注册的顺序构建一个调用栈。每个中间件会被依次调用，直到调用栈中的最后一个函数（通常是实际的业务逻辑处理函数）。c.Next()在中间件中的作用是将控制权传递给调用栈中的下一个函数。

在c.Next()之前的代码：这部分代码在请求达到业务逻辑处理函数之前执行。 可以用于设置一些预处理条件，比如记录请求开始的时间、检查请求头部等。

调用c.Next()：这个调用启动了调用栈中的下一个中间件或者路由处理函数的执行。如果没有更多的中间件或处理函数，Gin将开始逐步回溯调用栈。

在c.Next()之后的代码：这部分代码在所有后续的中间件和业务逻辑处理完成之后执行。这是处理请求后的逻辑，如记录处理时间、发送监控指标、记录响应状态等。

中间件的执行流程
假设有中间件A和中间件B，以及最终的业务处理函数C：

中间件A的c.Next()之前的代码执行。
中间件B的c.Next()之前的代码执行。
业务处理函数C执行。
中间件B的c.Next()之后的代码执行。
中间件A的c.Next()之后的代码执行。

如果中间件B中没有c.Next这个流程会怎样？
中间件A的c.Next()之前的代码执行。
中间件B的c.Next()之前的代码执行。
在这一步，由于中间件B没有调用c.Next()，请求处理流程在此中断，不会继续传递到业务处理函数C或任何后续的中间件。
业务处理函数C不会被执行。
因为中间件B没有传递控制权，所以即使有业务逻辑定义在C中，它也不会得到执行。
中间件B的c.Next()之后的代码不会执行。
由于c.Next()未被调用，所以实际上并没有进入到B中间件的“之后”阶段。
中间件A的c.Next()之后的代码也不会执行。
同样，由于请求处理流程在B中被中断，所以A中间件的后续逻辑也不会被执行。

所以c.Next这个流程是很重要的，我也不用去考虑多了，因为一旦有这种情况，后面都指向终端。没有这个调用那么处理流程就会提前终止。

现在再来分析代码逻辑：

r.GET("/test", func(c *gin.Context) {
		// 查询我们之前在日志中间件，注入的键值数据
		example := c.MustGet("example").(string)
		// it would print: "12345"
		log.Println(example)
	})

1.这里先发送到/test路由的请求。
2.然后由于设置了中间件，所以会先到中间件函数。
中间件函数中的c.Next之前的就会先执行。

t := time.Now()
c.Set("example", "12345")

记录当前的时间，然后在gin的上下文中设置一个键值对"example": “12345”
然后调用c.Next()：此时，控制权被传递给调用栈中的下一个中间件或处理函数。在这个例子中，下一个处理函数是/test路由的处理函数。

执行路由处理函数
c.MustGet(“example”)从Gin的上下文中检索键名为"example"的值。这个值是在之前执行的日志中间件中设置的。MustGet方法会返回一个interface{}类型的值，所以我们通过类型断言(string)将其转换为string类型。如果键名"example"不存在，MustGet会引发panic，因此使用它时需要确保该键确实存在。

打印获取的值：如果一切顺利，example变量应该包含字符串"12345"，这个值接着被打印到日志中。

4.中间件后置处理
计算延迟：计算从请求开始到现在的总耗时latency，并通过log.Print(latency)打印出来。
记录状态码：获取并打印响应的HTTP状态码status。