golang-gin框架教程笔记

云闲不收

已于 2025-04-14 17:01:26 修改

阅读量1.7k

点赞数 28

文章标签： gin 笔记

于 2024-03-14 22:26:58 首次发布

本文链接：https://blog.csdn.net/S_ZaiJiangHu/article/details/123646088

版权

参考

官方中文文档：https://gin-gonic.com/zh-cn/docs/introduction/ 但是示例截图少
https://www.kancloud.cn/shuangdeyu/gin_book/949411
https://www.topgoer.com/gin%E6%A1%86%E6%9E%B6/ 这个网站不光有gin框架适合阅读

吉米老师的：https://www.liwenzhou.com/posts/Go/Gin_framework/
他的其他链接：https://www.liwenzhou.com/posts/Go/golang-menu/
docker部署go项目：https://www.liwenzhou.com/posts/Go/how_to_deploy_go_app_using_docker/

官方网站：https://gin-gonic.github.io/gin/
Github地址：https://github.com/gin-gonic/gin

什么是框架

框架是指半成品的应用，一般需要填充少许代码或者无需填充代码就可以运行，只是这样的应用缺少业务逻辑。

我们使用框架开发，主要工作就是在框架上补充业务逻辑代码。所以，借助框架进行开发，不仅可以减少开发时间、提高效率，也有助于团队统一编码风格，形成编程规范。

gin 框架是一个 Web 框架，它封装了路由、Cookie、Session、参数处理、数据编解码以及中间件等功能，简单高效，降低了开发 Web 应用的难度。

gin 是一个使用 Go 语言编写的 Web 后端框架，具有简洁、轻量、支持高并发、封装优雅、API 友好、快速灵活、容错方便等特点。

gin 和 beego 是 Go 语言编写 Web 应用最常用的后端框架。

使用 Go 语言开发 Web 应用，对于框架的依赖要比其它编程语言要小。Go 语言内置的 net/http 包简单轻便，性能优良。而且，大多数的 Go 语言 Web 框架都是在其之上进行的封装。

曾经我以为Python世界里的框架已经够多了，后来发现相比golang简直小巫见大巫。golang提供的net/http库已经很好了，对于http的协议的实现非常好，基于此再造框架，也不会是难事，因此生态中出现了很多框架。既然构造框架的门槛变低了，那么低门槛同样也会带来质量参差不齐的框架。

考察了几个框架，通过其github的活跃度，维护的team，以及生产环境中的使用率。发现Gin还是一个可以学习的轻巧框架。

Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确，已经发布了1.0版本。具有快速灵活，容错方便等特点。其实对于golang而言，web框架的依赖要远比Python，Java之类的要小。自身的net/http足够简单，性能也非常不错。框架更像是一些常用函数或者工具的集合。借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。

安装与导入

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

import (
	"net/http" //通常还需要导入 net/http 包，因为代码中一般需要一些常量，比如返回码 http.StatusOK。
	"github.com/gin-gonic/gin"
)

在这里插入图片描述

学学这个排版。

Hello World

demo

package main

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

func main() {
   // 1.创建路由
   engine := gin.Default()
   
   // 2.绑定路由规则，执行的函数，这里写成了匿名函数的形式 也可单独写一个函数
   // gin.Context，封装了request和response
   //指定对什么网址进行相应，响应什么内容
   engine.GET("/", func(c *gin.Context) {
      c.String(http.StatusOK, "Hello World!")
   })
   
   // 3.监听端口，默认在8080
   engine.Run()//相当于 engine.Run(":8080")
}

打开浏览器，输入 http://localhost:8080，就可以看到浏览器输出：

Hello World！

进阶

上面GET方法中的匿名函数可以拆开写：

helloHandler := func(context *gin.Context) {
	 context.String(http.StatusOK, "Hello World!")
}
func main() {
	//···省略
	engine.GET("/",helloHandler）
}

get、post方法也可替换为更底层的Handle

//GET is a shortcut for router.Handle("GET", path, handle)
helloHandler := func(context *gin.Context) {
	fmt.Fprint(context.Writer, "Hello World!")
}
r.Handle("GET", "/hello", helloHandler)

除了默认服务器中router.Run()的方式外，还可以用http.ListenAndServe()，比如

func main() {
    router := gin.Default()
    http.ListenAndServe(":8080", router)
}

或者自定义HTTP服务器的配置：

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

    s := &http.Server{
        Addr:           ":8080",
        Handler:        router,
        ReadTimeout:    10 * time.Second,
        WriteTimeout:   10 * time.Second,
        MaxHeaderBytes: 1 << 20,
    }
    s.ListenAndServe()
}

如果我们不使用gin框架，原生的go也可以很容易实现：

package main

import (
	"fmt"
	"net/http"
)

func sayHello(w http.ResponseWriter, r *http.Request) {
	_, _ = fmt.Fprintln(w, "<h1>Hello Golang!</h1:'")
}

func main() {
	http.HandleFunc("/hello", sayHello)
	err := http.ListenAndServe(":9090", nil)
	if err != nil {
		fmt.Printf("http serve failed, err:%vn", err)
		return
	}
}

New和Default的区别

// 创建带有默认中间件的路由:
// 日志与恢复中间件
router := gin.Default()
//创建不带中间件的路由：
//r := gin.New()

路由处理

什么是路由

在web开发中，“route”是指根据url分配到对应的处理程序。

路由（route）就是根据 HTTP 请求的 URL，设置由哪个函数来处理请求。路由是 Web 框架的核心功能。

路由通常这样实现：根据路由里的字符 “/”，把路由切分成多个字符串数组，然后构造成树状结构；寻址的时候，先把请求的 URL 按照 “/” 进行切分，然后遍历树进行寻址。

比如：定义了两个路由 /user/get，/user/delete，则会构造出拥有三个节点的路由树，根节点是 user，两个子节点分别是 get 和 delete。

gin 框架路由库

gin 框架中采用的路由库是基于 httprouter 开发的。
httprouter 项目地址：https://github.com/julienschmidt/httprouter。

gin 框架路由的范例

package main

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

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

    // 下面是两条路由
    engine.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "编程教程")
    })

    engine.GET("/hello", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello World")
    })
    // 监听端口默认为8080
    engine.Run(":8080")
}

运行程序，然后打开浏览器，输入 http://localhost:8080/，可以看到浏览器输出：编程教程。然后输入 http://localhost:8080/hello，可以看到浏览器输出：Hello World。

r.GET("/a",func(c *gin.Context) {})
r.POST("/b",func(c *gin.Context) {})
//此外，还有一个可以匹配所有请求方法的Any方法如下
r.Any("/c",func(c *gin.Context) {})

gin 框架路由的基本语法

Gin 的api风格是restful
路由支持 HTTP 的 GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS 方法的请求，同时还有一个 Any 函数，可以同时支持以上的所有请求。

Gin 的路由通常的使用方法如下：

// 获取默认的 gin Engine，Engine 中包含了所有路由处理的接口
engine := gin.Default()

// Get 请求路由
engine.GET("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin get method")
})
// Post 请求路由
engine.POST("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin post method")
})
// Put 请求路由 
engine.PUT("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin put method")
})
// Delete 请求路由
engine.DELETE("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin delete method")
})
// Patch 请求路由
engine.PATCH("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin patch method")
})
// Head 请求路由
engine.HEAD("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin head method")
})
// Options 请求路由
engine.OPTIONS("/", func(context *gin.Context) {
    context.String(http.StatusOK, "hello gin options method")
})

gin路由分组

我们在使用 web 框架开发时，经常会根据业务逻辑给一个模块划分一组路由。

把一个模块相关的方法都写在一个路由下，主要好处是业务逻辑清晰，便于管理和查找相关的代码。

例如：goods 为商品模块，我们规划它的操作路由。

/goods/addGoods 添加商品
/goods/delGoods 删除商品

gin 框架支持路由分组（routes group），路由分组的关键词为 group。

engine.Group("/groupname")

写法1

package main

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

func loginEndpoint(c *gin.Context){
    fmt.Println("这是login方法")
}

func submitEndpoint(c *gin.Context){
    fmt.Println("这是submit方法")
}

func readEndpoint(c *gin.Context){
    fmt.Println("这是read方法")
}

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

    //v1组路由     
    // {} 是书写规范  这个语法是咋实现的？  是函数先返回一个结构体 再实例化的意思么？
    v1 := engine.Group("/v1")
    {
        v1.GET("/login", loginEndpoint)
        v1.GET("/submit", submitEndpoint)
        v1.GET("/read", readEndpoint)
    }

    //v2组路由
    v2: = engine.Group("/v2")
    {
        v2.GET("/login", loginEndpoint)
        v2.GET("/submit", submitEndpoint)
        v2.GET("/read", readEndpoint)
    }
    engine.Run()
}

打开浏览器，输入 http://localhost:8080，分别访问：

http://localhost:8080/v1/login
http://localhost:8080/v1/submit
http://localhost:8080/v1/read
http://localhost:8080/v2/login
http://localhost:8080/v2/submit
http://localhost:8080/v2/read

浏览器会输出对应的 API 内容。

写法2

也可以这样：

func main() {
	r := gin.Default()
	user := r.Group("/user")
	user.GET("/index", func(c *gin.Context) {})
	user.POST("/login", func(c *gin.Context) {})
	r.Run()
}

在这里插入图片描述
区别，就在于不用再单独写路由了

路由拆分与注册

1 最简单的路由注册demo

下面最基础的 gin 路由注册方式，适用于路由条目比较少的简单项目或者项目 demo。

package main

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

func helloHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello www.codebaoku.com!",
    })
}

func main() {
    engine := gin.Default()
    engine.GET("/codebaoku", helloHandler)
    if err := engine.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}

2 路由拆分单独文件或包

当项目的规模增大后就不太适合继续在项目的 main.go 文件中去实现路由注册相关逻辑了，我们会倾向于把路由部分的代码都拆分出来，形成一个单独的文件或包：

我们在routers.go文件中定义并注册路由信息：

package main

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

func helloHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello www.codebaoku.com!",
    })
}

func setupRouter() *gin.Engine {
    engine := gin.Default()
    engine.GET("/codebaoku", helloHandler)
    return engine
}

此时 main.go 中调用上面定义好的 setupRouter 函数：

func main() {
    engine := setupRouter()
    if err := engine.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}

此时的目录结构：

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers.go

把路由部分的代码单独拆分成包的话也是可以的，拆分后的目录结构如下：

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go

routers/routers.go 需要注意此时 setupRouter 需要改成首字母大写：

package routers

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

func helloHandler(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{
        "message": "Hello www.codebaoku.com",
    })
}

// SetupRouter 配置路由信息
func SetupRouter() *gin.Engine {
    r := gin.Default()
    r.GET("/codebaoku", helloHandler)
    return r
}

main.go文件内容如下：

package main

import (
    "fmt"
    "gin_demo/routers"
)

func main() {
    engine := routers.SetupRouter()
    if err := engine.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}

3 路由拆分成多个文件

当我们的业务规模继续膨胀，单独的一个 routers 文件或包已经满足不了我们的需求了：

func SetupRouter() *gin.Engine {
    engine := gin.Default()
    engine.GET("/codebaoku", helloHandler)
    engine.GET("/xx1", xxHandler1)
    ...
    engine.GET("/xx30", xxHandler30)
    return engine
}

因为我们把所有的路由注册都写在一个 SetupRouter 函数中的话就会太复杂了。

我们可以分开定义多个路由文件，例如：

gin_demo
├── go.mod
├── go.sum
├── main.go
└── routers
    ├── blog.go
    └── shop.go

routers/shop.go 中添加一个 LoadShop 的函数，将 shop 相关的路由注册到指定的路由器：

func LoadShop(e *gin.Engine)  {
    e.GET("/hello", helloHandler)
    e.GET("/goods", goodsHandler)
    e.GET("/checkout", checkoutHandler)
    ...
}

routers/blog.go 中添加一个 LoadBlog 的函数，将 blog 相关的路由注册到指定的路由器：

func LoadBlog(e *gin.Engine) {
    e.GET("/post", postHandler)
    e.GET("/comment", commentHandler)
    ...
}

在 main 函数中实现最终的注册逻辑如下：

func main() {
    engine := gin.Default()
    routers.LoadBlog(engine)
    routers.LoadShop(engine)
    if err := engine.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}

4. 路由拆分到不同的 APP

有时候项目规模实在太大，那么我们就更倾向于把业务拆分的更详细一些，例如把不同的业务代码拆分成不同的 APP。

因此我们在项目目录下单独定义一个app目录，用来存放我们不同业务线的代码文件，这样就很容易进行横向扩展。大致目录结构如下：

gin_demo
├── app
│   ├── blog
│   │   ├── handler.go
│   │   └── router.go
│   └── shop
│       ├── handler.go
│       └── router.go
├── go.mod
├── go.sum
├── main.go
└── routers
    └── routers.go

其中app/blog/router.go用来定义post相关路由信息，具体内容如下：

func Routers(e *gin.Engine) {
    e.GET("/post", postHandler)
    e.GET("/comment", commentHandler)
}

app/shop/router.go 用来定义 shop 相关路由信息，具体内容如下：

func Routers(e *gin.Engine) {
    e.GET("/goods", goodsHandler)
    e.GET("/checkout", checkoutHandler)
}

routers/routers.go 中根据需要定义 Include 函数用来注册子 app 中定义的路由，Init 函数用来进行路由的初始化操作：

type Option func(*gin.Engine)

var options = []Option{}

// 注册app的路由配置
func Include(opts ...Option) {
    options = append(options, opts...)
}

// 初始化
func Init() *gin.Engine {
    engine := gin.New()
    for _, opt := range options {
        opt(engine)
    }
    return engine
}

main.go 中按如下方式先注册子 app 中的路由，然后再进行路由的初始化：

func main() {
    // 加载多个APP的路由配置
    routers.Include(shop.Routers, blog.Routers)
    // 初始化路由
    engine := routers.Init()
    if err := engine.Run(); err != nil {
        fmt.Println("startup service failed, err:%v\n", err)
    }
}

参数处理

web 程序中经常需要处理各种形式的参数，参数是处理 HTTP 请求中很重要的工作，它是前端向后端提交数据的基本形式。

gin 框架内置了处理 HTTP 各种参数的方法，包括 API 参数，URL 参数以及表单参数的处理。

query参数处理（URL 参数处理）（get）

例如/name=admin&pwd=123456，我们想得到name和pwd的值

URL 参数可以通过 DefaultQuery() 或 Query() 方法获取。
DefaultQuery() 若参数不存在，则返回默认值，Query()若不存在，返回空串。

package main

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

func main() {
	r := gin.Default()
	r.GET("/", func(c *gin.Context) {
		name := c.DefaultQuery("name", "admin")
		pwd := c.Query("pwd")
		// fmt.Printf("name:%s ; pwd:%s",name,pwd)
		c.JSON(http.StatusOK, gin.H{
			"name": name,
			"pwd":  pwd,
		})
	})
	r.Run()
}

表单Form参数处理（post）

表单传输为post请求，http常见的传输格式为四种：

application/json
application/x-www-form-urlencoded
application/xml
multipart/form-data

http的报文体传输数据就比query string稍微复杂一点，常见的格式就有四种。例如application/json，application/x-www-form-urlencoded,application/xml和multipart/form-data。后面一个主要用于图片上传。json格式的很好理解，urlencode其实也不难，无非就是把query string的内容，放到了body体里，同样也需要urlencode。默认情况下，c.PostFROM解析的是x-www-form-urlencoded或from-data的参数。

表单参数可以通过 PostForm() 方法获取，该方法默认解析的是 x-www-form-urlencoded 或 from-data 格式的参数。

package main

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

func main() {
    engine := gin.Default()
    engine.POST("/form", func(c *gin.Context) {
        types := c.DefaultPostForm("type", "post")
        username := c.PostForm("username")
        password := c.PostForm("userpassword")
        c.String(http.StatusOK, fmt.Sprintf("username:%s,password:%s,type:%s", username, password, types))
    })
    engine.Run()
}

从表单中获取了 types、username、password 三个参数。

API 参数处理

gin 框架中，可以通过 Context 的 Param 方法来获取 API 参数。

比如：提取 http://localhost:8080/user/zhangsan 的参数 zhangsan。

package main

import (
    "net/http"
    "strings"

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

func main() {
    engine := gin.Default()
    engine.GET("/user/:name", func(c *gin.Context) {
        name := c.Param("name")
        c.String(http.StatusOK, "name=" + name)
    })

    // 监听8080端口
    engine.Run(":8080")
}

运行程序，浏览器中输入：http://localhost:8080/user/zhangsan，浏览器会输出：name=zhangsan。

/user/:name/*action 这种也是api参数后面会再讲

参数验证

https://juejin.cn/post/7228399267421405243

数据绑定

接收参数绑定

具体例子看 http://www.17bigdata.com/study/programming/gin/gin-data-bind.html

Gin提供了两套绑定方法：https://www.kancloud.cn/jiajunxi/ginweb100/1801438

Must bind
- 方法：Bind,BindJSON,BindXML,BindQuery,BindYAML
- 行为：这些方法使用MustBindWith。如果存在绑定错误，则用c终止请求，使用c.AbortWithError (400) .SetType (ErrorTypeBind)即可。将响应状态代码设置为400，Content-Type header设置为text/plain;charset = utf - 8。请注意，如果在此之后设置响应代码，将会受到警告：[GIN-debug][WARNING] Headers were already written. Wanted to override status code 400 with 422将导致已经编写了警告[GIN-debug][warning]标头。如果想更好地控制行为，可以考虑使用ShouldBind等效方法。
Should bind
- 方法：ShouldBind,ShouldBindJSON,ShouldBindXML,ShouldBindQuery,ShouldBindYAML
- 行为：这些方法使用ShouldBindWith。如果存在绑定错误，则返回错误，开发人员有责任适当地处理请求和错误。
  注意，使用绑定方法时，Gin 会根据请求头中 Content-Type 来自动判断需要解析的类型。如果你明确绑定的类型，你可以不用自动推断，而用 BindWith 方法。你也可以指定某字段是必需的。如果一个字段被binding:"required"修饰而值却是空的，请求会失败并返回错误。

响应格式

gin框架可以提供多种数据格式的响应，包括json、结构体、XML、YAML 以及 ProtoBuf等格式。

package main

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

// 多种响应方式
func main() {
    // 创建路由
    engine := engine.Default()
    
    // 1. 返回json
    engine.GET("/someJSON", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "someJSON", "status": 200})
    })
    // 2. 结构体响应
    engine.GET("/someStruct", func(c *gin.Context) {
        var msg struct {
            Name    string
            Message string
            Number  int
        }
        msg.Name = "root"
        msg.Message = "message"
        msg.Number = 123
        c.JSON(200, msg)
    })

    // 3.XML
    engine.GET("/someXML", func(c *gin.Context) {
        c.XML(200, gin.H{"message": "abc"})
    })

    // 4.YAML响应
    engine.GET("/someYAML", func(c *gin.Context) {
        c.YAML(200, gin.H{"name": "zhangsan"})
    })

    // 5.protobuf格式,谷歌开发的高效存储读取的工具
    engine.GET("/someProtoBuf", func(c *gin.Context) {
        reps := []int64{int64(1), int64(2)}
        // 定义数据
        label := "label"
        // 传protobuf格式数据
        data := &protoexample.Test{
            Label: &label,
            Reps:  reps,
        }
        c.ProtoBuf(200, data)
    })

    engine.Run()
}

模板渲染

gin 支持加载 HTML 模板, 然后根据模板参数进行配置并返回相应的数据，本质上就是字符串替换 LoadHTMLGlob() 方法可以加载模板文件。

正常模式 HTML 模板渲染
例如：main.go 文件如下：

package main

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

func main() {
engine := gin.Default()
engine.LoadHTMLGlob(“tem/*”)
engine.GET(“/index”, func(c *gin.Context) {
c.HTML(http.StatusOK, “index.html”, gin.H{“title”: “我是测试”, “ce”: “123456”})
})
engine.Run()
}
index.html 模板如下：

{{.title}} fgkjdskjdsh{{.ce}} 文件目录结构如下：

test
├── go.mod
├── go.sum
├── main.go
└── tem
    └── index.html

多层目录 HTML 模板渲染
如果你的目录结构是下面的情况：

test
├── go.mod
├── go.sum
├── main.go
└── tem
└── user
└── index.html
go 文件代码如下：

package main

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

func main() {
engine := gin.Default()
engine.LoadHTMLGlob(“tem/**/*”)
engine.GET(“/index”, func(c *gin.Context) {
c.HTML(http.StatusOK, “user/index.html”, gin.H{“title”: “我是测试”, “address”: “www.5lmh.com”})
})
engine.Run()
}
html 文件代码如下：

{{.title}} fgkjdskjdsh{{.address}} {{ end }}

头尾分离模式 HTML 模板渲染
如果你想进行头尾分离就是下面这种写法：

go 文件代码如下：

package main

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

{{ define “user/index.html” }}
{{template “public/header” .}}
fgkjdskjdsh{{.address}}
{{template “public/footer” .}}
{{ end }}
public/header.html文件代码：

{{end}}
public/footer.html文件代码：

{{define "public/footer"}}
</body>
</html>

引入静态文件
如果你需要引入静态文件需要定义一个静态文件目录

engine.Static(“/assets”, “./assets”)

上传文件

简单来说就是

FormFile("文件名")

<input type="file" name="file" >

上传单个文件

gin 框架中，multipart/form-data 格式用于文件上。

文件上传与原生的 net/http 方法类似，不同在于 gin 把原生的 request 封装到 c.Request 中。

前端 html 文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <form action="http://localhost:8080/upload" method="post" enctype="multipart/form-data">
          上传文件:
          <input type="file" name="file" >
          <input type="submit" value="提交">
    </form>
</body>
</html>

文件可以保存为 test.html。

后端 go 文件：

package main

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

func main() {
    engine := gin.Default()
    //限制上传最大尺寸
    engine.MaxMultipartMemory = 8 << 20
    engine.POST("/upload", func(c *gin.Context) {
        file, err := c.FormFile("file")
        if err != nil {
            c.String(500, "上传图片出错")
        }
        // c.JSON(200, gin.H{"message": file.Header.Context})
        c.SaveUploadedFile(file, file.Filename)
        c.String(http.StatusOK, file.Filename)
    })
    engine.Run()
}

运行程序后，浏览器访问 test.html文件，就可以在浏览器中上传文件。

前端页面代码

<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <title>上传文件示例</title>
</head>
<body>
<form action="/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="f1">
    <input type="submit" value="上传">
</form>
</body>
</html>

后端Gin框架部分代码

package main

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

func main() {
	r := gin.Default()
	// 处理multipart forms提交文件时默认的内存限制是32 MiB
	// 可以通过下面的方式修改
	// r.MaxMultipartMemory = 8 << 20  // 8 MiB
	r.POST("/upload", func(c *gin.Context) {
		// 单个文件
		file, err := c.FormFile("f1")
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{
				"message": err.Error(),
			})
			return
		}

		log.Println(file.Filename)
		dst := fmt.Sprintf("C:/tmp/%s", file.Filename)
		// 上传文件到指定的目录
		c.SaveUploadedFile(file, dst)
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("'%s' uploaded!", file.Filename),
		})
	})
	r.Run()
}

上传特定文件

有的用户上传文件需要限制上传文件的类型以及上传文件的大小，但是 gin 框架暂时没有这些函数。因此，我们基于原生的函数写了一个可以限制大小以及文件类型的上传函数。

package main

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

func main() {
    engine := gin.Default()
    engine.POST("/upload", func(c *gin.Context) {
        _, headers, err := c.Request.FormFile("file")
        if err != nil {
            log.Printf("Error when try to get file: %v", err)
        }
        //headers.Size 获取文件大小
        if headers.Size > 1024*1024*2 {
            fmt.Println("文件太大了")
            return
        }
        //headers.Header.Get("Content-Type")获取上传文件的类型
        if headers.Header.Get("Content-Type") != "image/png" {
            fmt.Println("只允许上传png图片")
            return
        }
        c.SaveUploadedFile(headers, "./video/"+headers.Filename)
        c.String(http.StatusOK, headers.Filename)
    })
    engine.Run()
}

上传多个文件

前端 html 文件：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <title>Document</title>
</head>
<body>
    <form action="http://localhost:8080/upload" method="post" enctype="multipart/form-data">
          上传文件:
          <input type="file" name="files" multiple>
          <input type="submit" value="提交">
    </form>
</body>
</html>

文件可以保存为 test.html。

package main

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

func main() {
   engine := gin.Default()
   // 限制表单上传大小 8MB，默认为32MB
   engine.MaxMultipartMemory = 8 << 20
   engine.POST("/upload", func(c *gin.Context) {
      form, err := c.MultipartForm()
      if err != nil {
         c.String(http.StatusBadRequest, fmt.Sprintf("get err %s", err.Error()))
      }
      // 获取所有图片
      files := form.File["files"]
      // 遍历所有图片
      for _, file := range files {
         // 逐个保存
         if err := c.SaveUploadedFile(file, file.Filename); err != nil {
            c.String(http.StatusBadRequest, fmt.Sprintf("upload err %s", err.Error()))
            return
         }
      }
      c.String(200, fmt.Sprintf("upload ok %d files", len(files)))
   })
 
   engine.Run()
}

运行程序后，浏览器访问 test.html文件，就可以在浏览器中上传文件。

package main

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

func main() {
	r := gin.Default()
	// 处理multipart forms提交文件时默认的内存限制是32 MiB
	// 可以通过下面的方式修改
	// r.MaxMultipartMemory = 8 << 20  // 8 MiB
	r.POST("/upload", func(c *gin.Context) {
		// Multipart form
		form, _ := c.MultipartForm()
		files := form.File["file"]

		for index, file := range files {
			log.Println(file.Filename)
			dst := fmt.Sprintf("C:/tmp/%s_%d", file.Filename, index)
			// 上传文件到指定的目录
			c.SaveUploadedFile(file, dst)
		}
		c.JSON(http.StatusOK, gin.H{
			"message": fmt.Sprintf("%d files uploaded!", len(files)),
		})
	})
	r.Run()
}

会话控制

cookie

HTTP 是无状态协议，服务器不能记录浏览器的访问状态，也就是说服务器不能区分两次请求是否由同一个客户端发出。

1. gin 操作 cookie 的命令

gin 框架通过 gin.Context 结构对象操作 cookie，提供了获取 cookie 数据和写入 cookie 的方法。

gin 框架获取 cookie 键值的方法：

func (c *Context) Cookie(key string) (value string, err error)

其中 key 为 cookie 键，value 为返回的对应值。

gin 框架写入 cookie 键值的方法：

func (c *Context) SetCookie(key, value string, maxAge int, path, domain string, secure, httpOnly bool)

其中 key 为 cookie 键，value 为设置的对应值。

2. gin 操作 cookie 的范例

package main

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

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

    // 读取 cookie
    engine.GET("/read_cookie", func(context *gin.Context) {
    val, _ := context.Cookie("name")
      context.String(200, "Cookie:%s", val)
    })

    // 写入 cookie
    engine.GET("/write_cookie", func(context *gin.Context) {
       context.SetCookie("name", "Shimin Li", 24*60*60, "/", "localhost", false, true)
    })

    // 清理 cookie
    engine.GET("/clear_cookie", func(context *gin.Context) {
      context.SetCookie("name", "Shimin Li", -1, "/", "localhost", false, true)
    })

    engine.Run()
}

运行程序，在浏览器端分别执行写入、读取、清除的操作分别是：

http://localhost:8080/write_cookie
http://localhost:8080/read_cookie
http://localhost:8080/clear_cookie

3. cookie 的缺陷

不安全，明文
可以被禁用
增加带宽消耗
cookie 数量有上限
针对 cookie 的缺陷，还有另外的解决方案，比如 jwt。

session

gin 使用 session 的方法

go 语言和 gin 框架都没有单独提供 session 对象或者操作方法。

通常我们使用 gorilla/sessions包，它是由第三方提供的 session 操作包。

官方网址：http://www.gorillatoolkit.org/pkg/sessions

github：https://github.com/gin-gonic/gin

gin 使用 session 的范例

package main

import (
    "fmt"
    "net/http"
    "github.com/gorilla/sessions"
)

// 初始化一个cookie存储对象
// session-secret是密匙
var store = sessions.NewCookieStore([]byte("session-secret"))

func main() {
    http.HandleFunc("/save", SaveSession)
    http.HandleFunc("/get", GetSession)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Println("HTTP server failed,err:", err)
        return
    }
}

// 写入 session
func SaveSession(w http.ResponseWriter, r *http.Request) {
    //　获取一个session对象，session-name是session的名字
    session, err := store.Get(r, "session-name")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 在session中存储值
    session.Values["foo"] = "bar"
    session.Values[42] = 43
    // 保存更改
    session.Save(r, w)
}

// 读取 session
func GetSession(w http.ResponseWriter, r *http.Request) {
    session, err := store.Get(r, "session-name")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    foo := session.Values["foo"]
    fmt.Println(foo)
}

// 删除 session
func RemoveSession(w http.ResponseWriter, r *http.Request) {
    session, err := store.Get(r, "session-name")
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }

    // 设置session的最大存储时间小于零，即删除
    session.Options.MaxAge = -1
    session.Save(r, w)
}

中间件

为什么用中间件的名字？我觉得一个原因是 go是整个程序的运行而不像php那样有点每次都重新解释运行的味道所以一个一直运行的服务就和解释型的不一样

请求日志记录：记录每个请求的详细信息，便于调试和监控。
请求限流：防止过多的请求导致服务器过载。
跨域资源共享（CORS）：允许跨域请求，提高应用的兼容性。
身份验证：确保只有授权用户可以访问特定的资源。
压缩：自动压缩响应数据，减少网络传输量。

golang的net/http设计的一大特点就是特别容易构建中间件。gin也提供了类似的中间件。需要注意的是中间件只对注册过的路由函数起作用。对于分组路由，嵌套使用中间件，可以限定中间件的作用范围。中间件分为全局中间件，单个路由中间件和群组中间件。

Gin框架允许开发者在处理请求的过程中，加入钩子函数，这个钩子函数就叫中间件。中间件适合处理一些公共的业务逻辑，比如登陆认证，权限校验，记录日志等。具体使用方法如下

中间件和我们普通的HandlerFunc没有任何区别对吧, 我们怎么写HandlerFunc就可以怎么写一个中间件.

通过Get函数（单个路由中间件）

如果我们希望中断后续的挂起的请求处理链（HandlersChain）的请求，可以使用gin.Context中的这个Abort()方法。请注意，这不会停止当前处理程序。
因为我们只是想只想中断这一次请求而不想中断整个程序！

package main

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

//定义一个中间键m1统计请求处理函数耗时
func m1(c *gin.Context) {
	fmt.Println("m1 in...")
	start := time.Now()
	// c.Next() //调用后续的处理函数
	c.Abort()//阻止调用后续的处理函数
	cost := time.Since(start)
	fmt.Printf("cost:%v\n", cost)
}

func index(c *gin.Context) {
	c.JSON(http.StatusOK, gin.H{
		"msg": "ok",
	})
}

func main() {
	r := gin.Default()
	r.GET("/", m1, index)  //之前没有中间件的写法r.GET("/", index)
	r.Run()
}

通过Use函数（全局中间件）

介绍

func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes

比如：

engine := gin.Default()
engine.Use(MiddleWare())

还可以同时使用多个中间件，形成中间件链条。

比如：

engine := gin.Default()
engine.Use(MiddleWare1(), MiddleWare2(), MiddleWare3())

use函数的使用范例

这也是全局中间件的写法

package main

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

// 定义中间件
func MiddleWare() gin.HandlerFunc {
	return func(c *gin.Context) {
	  fmt.Println("调用中间件")
	}
}

func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "编程教程 gin框架"})
    })
    engine.Run()
}

运行程序，并在浏览器输入：http://localhost:8080，控制台日志会输出：

[GIN-debug] GET    /   --> main.main.func1 (4 handlers)
[GIN-debug] Listening and serving HTTP on :8080
调用中间件
调用路由处理函数
[GIN] 2021/05/31 - 12:03:13 | 200 |  193.22µs | ::1 | GET "/"

说明中间件被调用，而且是在页面处理函数之前执行的。

也可在use后实例化

router := gin.Default()

router.Use(MiddleWare())
{
    router.GET("/middleware", func(c *gin.Context) {
        //获取gin上下文中的变量
        request := c.MustGet("request").(string)
        req, _ := c.Get("request")
        fmt.Println("request:",request)
        c.JSON(http.StatusOK, gin.H{
            "middile_request": request,
            "request":         req,
        })
    })
}
router.Run(":8080")

gin 多个中间件的使用范例

gin 框架支持同时使用多个中间件，并按照写入顺序依次执行。

package main

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

// 定义中间件1
func MiddleWare1() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件1")
    }
}

// 定义中间件2
func MiddleWare2() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件2")
    }
}

// 定义中间件3
func MiddleWare3() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("调用中间件3")
    }
}
    
func main() {
    // 创建路由
    engine := gin.Default()

    // 注册中间件
    engine.Use(MiddleWare1(), MiddleWare2(), MiddleWare3())

    // 路由规则
    engine.GET("/", func(c *gin.Context) {
        fmt.Println("调用路由处理函数")
        // 页面接收
        c.JSON(200, gin.H{"request": "编程教程 gin框架"})
    })

    engine.Run()
}

运行程序，并在浏览器输入：http://localhost:8080，控制台日志会输出：

[GIN-debug] GET    /   --> main.main.func1 (4 handlers)
[GIN-debug] Listening and serving HTTP on :8080
调用中间件1
调用中间件2
调用中间件3
调用路由处理函数
[GIN] 2021/05/31 - 12:03:13 | 200 |  193.22µs | ::1 | GET "/"

说明三个中间件被依次调用，而且是在页面处理函数之前执行的。

Next和Abort

https://www.cnblogs.com/beatle-go/p/17914401.html

1)Next()
Next 函数会挂起当前所在的函数，然后调用后面的中间件，待后面中间件执行完毕后，再接着执行当前函数。

该方法会跳过当前中间件后续的逻辑，类似defer，最后再执行c.Next后面的逻辑
多个c.Next()谁在前面谁后执行，跟defer很像，类似先进后出的栈

2)Abort()

该方法会阻止业务逻辑以及该中间件后面的中间件执行，但不会阻止该中间件后面的逻辑执行包括c.Next()

案例

权限验证

以前后端最流行的jwt为例，如果用户登录了，前端发来的每一次请求都会在请求头上携带上token

后台拿到这个token进行校验，验证是否过期，是否非法

如果通过就说明这个用户是登录过的

不通过就说明用户没有登录

package main

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

func JwtTokenMiddleware(c *gin.Context) {
  // 获取请求头的token
  token := c.GetHeader("token")
  // 调用jwt的验证函数
  if token == "1234" {
    // 验证通过
    c.Next()
    return
  }
  // 验证不通过
  c.JSON(200, gin.H{"msg": "权限验证失败"})
  c.Abort()
}

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

  api := router.Group("/api")

  apiUser := api.Group("")
  {
    apiUser.POST("login", func(c *gin.Context) {
      c.JSON(200, gin.H{"msg": "登录成功"})
    })
  }
  apiHome := api.Group("system").Use(JwtTokenMiddleware)
  {
    apiHome.GET("/index", func(c *gin.Context) {
      c.String(200, "index")
    })
    apiHome.GET("/home", func(c *gin.Context) {
      c.String(200, "home")
    })
  }

  router.Run(":8080")
}

耗时统计

统计每一个视图函数的执行时间

func TimeMiddleware(c *gin.Context) {
  startTime := time.Now()
  c.Next()
  since := time.Since(startTime)
  // 获取当前请求所对应的函数
  f := c.HandlerName()
  fmt.Printf("函数 %s 耗时 %d\n", f, since)
}

日志系统

为什么要使用日志

记录用户操作，猜测用户行为
记录bug

gin自带日志系统

输出日志到log文件

package main

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

func main() {
  // 输出到文件
  f, _ := os.Create("gin.log")
  //gin.DefaultWriter = io.MultiWriter(f)
  // 如果需要同时将日志写入文件和控制台，请使用以下代码。
  gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
  router := gin.Default()
  router.GET("/", func(c *gin.Context) {
    c.JSON(200, gin.H{"msg": "/"})
  })
  router.Run()
}

定义路由格式
启动gin，它会显示所有的路由，默认格式如下

[GIN-debug] POST   /foo    --> main.main.func1 (3 handlers)
[GIN-debug] GET    /bar    --> main.main.func2 (3 handlers)
[GIN-debug] GET    /status --> main.main.func3 (3 handlers)

gin.DebugPrintRouteFunc = func(
  httpMethod,
  absolutePath,
  handlerName string,
  nuHandlers int) {
  log.Printf(
    "[ feng ] %v %v %v %v\n",
    httpMethod,
    absolutePath,
    handlerName,
    nuHandlers,
  )
}
/*  输出如下
2022/12/11 14:10:28 [ feng ] GET / main.main.func3 3
2022/12/11 14:10:28 [ feng ] POST /index main.main.func4 3
2022/12/11 14:10:28 [ feng ] PUT /haha main.main.func5 3
2022/12/11 14:10:28 [ feng ] DELETE /home main.main.func6 3
*/

查看路由

router.Routes()  // 它会返回已注册的路由列表

环境切换

如果不想看到这些debug日志，那么我们可以改为release模式

gin.SetMode(gin.ReleaseMode)
router := gin.Default()

修改log的显示
默认的是这样的

[GIN] 2022/12/11 - 14:22:00 | 200 |  0s |  127.0.0.1 | GET  "/"

如果觉得不好看，我们可以自定义

package main

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

func LoggerWithFormatter(params gin.LogFormatterParams) string {

  return fmt.Sprintf(
    "[ feng ] %s  | %d | \t %s | %s | %s \t  %s\n",
    params.TimeStamp.Format("2006/01/02 - 15:04:05"),
    params.StatusCode,  // 状态码
    params.ClientIP,  // 客户端ip
    params.Latency,  // 请求耗时
    params.Method,  // 请求方法
    params.Path,  // 路径
  )
}
func main() {
  router := gin.New()
  router.Use(gin.LoggerWithFormatter(LoggerWithFormatter))
  router.Run()

}

也可以这样

func LoggerWithFormatter(params gin.LogFormatterParams) string {
  return fmt.Sprintf(
    "[ feng ] %s  | %d | \t %s | %s | %s \t  %s\n",
    params.TimeStamp.Format("2006/01/02 - 15:04:05"),
    params.StatusCode,
    params.ClientIP,
    params.Latency,
    params.Method,
    params.Path,
  )
}
func main() {
  router := gin.New()
  router.Use(
    gin.LoggerWithConfig(
      gin.LoggerConfig{Formatter: LoggerWithFormatter},
    ),
  )
  router.Run()

}

但是你会发现自己这样输出之后，没有颜色了，不太好看，我们可以输出有颜色的log

func LoggerWithFormatter(params gin.LogFormatterParams) string {
  var statusColor, methodColor, resetColor string
  statusColor = params.StatusCodeColor()
  methodColor = params.MethodColor()
  resetColor = params.ResetColor()
  return fmt.Sprintf(
    "[ feng ] %s  | %s %d  %s | \t %s | %s | %s %-7s %s \t  %s\n",
    params.TimeStamp.Format("2006/01/02 - 15:04:05"),
    statusColor, params.StatusCode, resetColor,
    params.ClientIP,
    params.Latency,
    methodColor, params.Method, resetColor,
    params.Path,
  )
}

还没找到分类

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

	// gin.H 是map[string]interface{}的缩写
	r.GET("/someJSON", func(c *gin.Context) {
		// 方式一：自己拼接JSON
		c.JSON(http.StatusOK, gin.H{"message": "Hello world!"})
	})
	r.GET("/moreJSON", func(c *gin.Context) {
		// 方法二：使用结构体
		var msg struct {
			Name    string `json:"user"`
			Message string
			Age     int
		}
		msg.Name = "小王子"
		msg.Message = "Hello world!"
		msg.Age = 18
		c.JSON(http.StatusOK, msg)
	})
	r.Run(":8080")
}

其中方法一等价
在这里插入图片描述
注意，结构体方法，变量名要大写。所以用tag

template

在一些前后端不分离的Web架构中，我们通常需要在后端将一些数据渲染到HTML文档中，从而实现动态的网页（网页的布局和样式大致一样，但展示的内容并不一样）效果。

我们这里说的模板可以理解为事先定义好的HTML文档文件，模板渲染的作用机制可以简单理解为文本替换操作–使用相应的数据去替换HTML文档中事先准备好的标记。

可以看这个：https://www.liwenzhou.com/posts/Go/go_template/

插件推荐

在这里插入图片描述

优雅的停止或启动

Gin 优雅地重启或停止
你想优雅地重启或停止 web 服务器吗？有一些方法可以做到这一点。

我们可以使用 fvbock/endless 来替换默认的 ListenAndServe

router := gin.Default()
router.GET("/", handler)
// [...]
endless.ListenAndServe(":4242", router)

替代方案:

manners：可以优雅关机的 Go Http 服务器。
graceful：Graceful是一个 Go 扩展包，可以优雅地关闭 http.Handler 服务器。
grace：Go 服务器平滑重启和零停机时间部署。

如果你使用的是 Go 1.8，可以不需要这些库！考虑使用 http.Server 内置的 Shutdown() 方法优雅地关机. 请参阅 gin 完整的 graceful-shutdown 示例。

// +build go1.8

package main

import (
	"context"
	"log"
	"net/http"
	"os"
	"os/signal"
	"time"

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

func main() {
	router := gin.Default()
	router.GET("/", func(c *gin.Context) {
		time.Sleep(5 * time.Second)
		c.String(http.StatusOK, "Welcome Gin Server")
	})

	srv := &http.Server{
		Addr:    ":8080",
		Handler: router,
	}

	go func() {
		// 服务连接
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			log.Fatalf("listen: %s\n", err)
		}
	}()

	// 等待中断信号以优雅地关闭服务器（设置 5 秒的超时时间）
	quit := make(chan os.Signal)
	signal.Notify(quit, os.Interrupt)
	<-quit
	log.Println("Shutdown Server ...")

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	if err := srv.Shutdown(ctx); err != nil {
		log.Fatal("Server Shutdown:", err)
	}
	log.Println("Server exiting")
}