go语言web开发框架—gin框架入门

快速入门

安装并配置GO工作区
在GOPATH的src目录下新建项目文件夹
使用 go mod init命令初始化项目
使用go get -u github.com/gin-gonic/gin命令安装gin
示例代码：

package main

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

func main() {
    // 创建默认路由
    r := gin.Default()
    // 绑定路由规则和执行函数，当访问/ping接口时就会执行后面的函数
    r.GET("/ping", func(c *gin.Context) {
        // 该函数直接返回JSON字符串
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
    // 启动并监听端口，默认8080，可使用：r.Run(":8000")修改监听端口
    r.Run()
}

浏览器或postman访问：localhost:8080/ping，即可成功返回json字符串

路由

API参数

在路径中使用/:paramName或者/*paramName作为占位符，可在代码中通过*gin.Context的param方法获取到API参数，使用冒号占位符获取到的API参数不包含路径中的/，使用星号占位符则包含/

func main() {
       // 创建路由
       r := gin.Default()   
    r.GET("/user/:name/*action", func(c *gin.Context) {
        name := c.Param("name")
        action := c.Param("action")
        c.JSON(http.StatusOK, gin.H{
            "name":name,
            "action":action,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman请求http://127.0.0.1:8000/user/lee/index.html，返回的json格式如下：

{
    "action": "/index.html",
    "name": "lee"
}

URL参数

使用DefaultQuery或者Query方法可以获取前端传递的URL参数

DefaultQuery：可指定默认值

Query：不可指定默认值

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/add_user", func(c *gin.Context) {
        name := c.Query("name")
        age := c.DefaultQuery("age", "23")
        c.JSON(http.StatusOK, gin.H{
            "name":name,
            "age":age,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

postman访问：http://127.0.0.1:8000/add_user?name=lee&age=18，返回如下：

{
    "age": "18",
    "name": "lee"
}

postma访问：http://127.0.0.1:8000/add_user?name=lee，返回如下：

{
    "age": "23",
    "name": "lee"
}

表单参数

表单传输为post请求，http常见的传输格式为四种：
- application/json
- application/x-www-form-urlencoded
- application/xml
- multipart/form-data

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

func main() {
       // 创建路由
       r := gin.Default()
    r.POST("/form_post", func(c *gin.Context) {
        message := c.DefaultPostForm("message", "default message")
        name := c.PostForm("name")
        c.JSON(http.StatusOK, gin.H{
            "message":message,
            "name":name,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman发送请求如下所示：

postman发送请求

上传单个文件

func main() {
       // 创建路由
       r := gin.Default()
    r.POST("/upload", func(c *gin.Context) {
        file, err := c.FormFile("file")
        if err != nil {
            fmt.Println(err)
        }
        c.SaveUploadedFile(file, file.Filename)
        c.JSON(http.StatusOK, gin.H{
            "message":"ok",
            "fileName":file.Filename,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman发送请求如下：

postman发送请求

上传特定文件

func main() {
       // 创建路由
       r := gin.Default()
    r.POST("/upload", func(c *gin.Context) {
        _, file, err := c.Request.FormFile("file")
        if err != nil {
            fmt.Println(err)
        }
        if file.Size >= 1024 * 1024 * 2 {
            c.JSON(http.StatusOK, gin.H{
                "message":"文件大小不能超过2M",
            })
            return
        }
        if file.Header.Get("Content-Type") != "image/png" {
            c.JSON(http.StatusOK, gin.H{
                "message":"只能上传png格式文件",
            })
            return
        }
        c.SaveUploadedFile(file, file.Filename)
        c.JSON(http.StatusOK, gin.H{
            "message":"ok",
            "fileName":file.Filename,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman发送请求如下：

postman发送请求

上传多个文件

func main() {
       // 创建路由
       r := gin.Default()
    r.POST("/upload", func(c *gin.Context) {
        form, err := c.MultipartForm()
        if err != nil {
            fmt.Println(err)
            return
        }
        files := form.File["files"]
        for _, file := range files {
            err := c.SaveUploadedFile(file, file.Filename)
            if err != nil {
                c.JSON(http.StatusOK, gin.H{
                    "message":"文件上传失败",
                    "err":err,
                })
                return
            }
        }
        c.JSON(http.StatusOK, gin.H{
            "message":"文件上传成功",
            "upload file count":len(files),
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman调用接口如下：

postman发送请求

路由组

路由组（RouterGroup），用于管理一组路由，在不同路由组中的路由可重名

func main() {
       // 创建路由
       r := gin.Default()
    v1 := r.Group("/v1")
    v1.GET("/hello", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message":"/v1/hello",
        })
    })

    v2 := r.Group("/v2")
    v2.GET("/hello", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message":"/v2/hello",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

postman分别访问http://127.0.0.1:8000/v1/hello和http://127.0.0.1:8000/v2/hello，返回不同的消息

自定义404

定义NoRoute之后，如果访问的地址不在已经存在的路由中，就会默认执行这个配置的方法，可用于配置404返回信息

func main() {
       // 创建路由
       r := gin.Default()
    r.NoRoute(func(c *gin.Context) {
        c.JSON(http.StatusNotFound, gin.H{
            "message":"页面丢了！",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

使用postman调用结果如下：

postman发送请求

数据绑定

JSON

将前端发送的json数据绑定到结构体上，在结构体中除了定义结构体的参数之外，在参数后面需要定义json的参数名，表示将json中的哪个参数与结构体中的参数进行绑定，binding:"required"表示该字段为必传，如果为空则报错

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/loginJSON", func(c *gin.Context) {
        var login LoginForm
        err := c.ShouldBindJSON(&login)
        if err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        // 判断用户名密码是否正确
        if login.User != "root" || login.Password != "admin" {
            c.JSON(http.StatusBadRequest, gin.H{
                "status": "304",
                "message":"登录失败",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "status": "200",
            "message":"登录成功",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}


type LoginForm struct {
    // 表明该属性与传递的json的user属性进行绑定
    User     string `json:"user" binding:"required"`
    Password string `json:"password" binding:"required"`
}

使用postman调用接口结果如下：

postman发送请求

表单

func main() {
       // 创建路由
       r := gin.Default()
    r.POST("/loginForm", func(c *gin.Context) {
        // 声明接收的变量
        var form LoginForm
        // Bind()默认解析并绑定form格式
        // 根据请求头中content-type自动推断
        if err := c.Bind(&form); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        if form.User != "root" || form.Password != "admin" {
            c.JSON(http.StatusBadRequest, gin.H{
                "status": "304",
                "message":"登录失败",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "status": "200",
            "message":"登录成功",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

type LoginForm struct {
    User     string `form:"user" json:"user" binding:"required"`
    Password string `form:"password" json:"password" binding:"required"`
}

使用postman调用接口结果如下：

postman发送请求

URI

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/login/:user/:password", func(c *gin.Context) {
        // 声明接收的变量
        var login LoginForm
        // Bind()默认解析并绑定form格式
        // 根据请求头中content-type自动推断
        if err := c.ShouldBindUri(&login); err != nil {
            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
            return
        }
        if login.User != "root" || login.Password != "admin" {
            c.JSON(http.StatusBadRequest, gin.H{
                "status": "304",
                "message":"登录失败",
            })
            return
        }
        c.JSON(http.StatusOK, gin.H{
            "status": "200",
            "message":"登录成功",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

type LoginForm struct {
    User     string `form:"user" json:"user" uri:"user" binding:"required"`
    Password string `form:"password" json:"password" uri:"password" binding:"required"`
}

使用postman调用结果如下：

postman发送请求

数据响应

JSON、Struct、XML、YAML

func main() {
       // 创建路由
       r := gin.Default()
    // JSON响应
    r.GET("/someJSON", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{
            "message":"JSON OK",
        })
    })

    // 结构体响应
    r.GET("/someStruct", func(c *gin.Context) {
        type Msg struct {
            Message string
        }
        msg := Msg{
            Message: "Struct OK",
        }
        c.JSON(http.StatusOK, msg)
    })

    // XML响应
    r.GET("/someXML", func(c *gin.Context) {
        c.XML(http.StatusOK, gin.H{
            "message":"XML OK",
        })
    })

    // YAML响应
    r.GET("/someYAML", func(c *gin.Context) {
        c.YAML(http.StatusOK, gin.H{
            "message":"YAML OK",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

不同响应方式返回示例：

// JSON返回
{
    "message": "JSON OK"
}

// Struct返回
{
    "Message": "Struct OK"
}

<!-- XML返回 -->
<map>
    <message>XML OK</message>
</map>

# YAML返回
message: YAML OK

重定向

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/redirect", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "https://www.baidu.com")
    })
    // 默认端口号是8080
    r.Run(":8000")
}

重定向之后当使用浏览器访问http://127.0.0.1:8000/redirect链接则会自动跳转到百度首页

同步异步

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/async", func(c *gin.Context) {
        copyContext := c.Copy()
        go func() {
            time.Sleep(time.Second * 3)
            log.Println("异步执行：" + copyContext.Request.URL.Path)
        }()
        c.JSON(http.StatusOK, gin.H{
            "message":"OK",
        })
    })

    r.GET("/sync", func(c *gin.Context) {
        time.Sleep(3 * time.Second)
        log.Println("同步执行：" + c.Request.URL.Path)
        c.JSON(http.StatusOK, gin.H{
            "message":"OK",
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

在异步中，访问接口，会直接返回message:OK响应，然后后台在3秒之后打印异步执行提示消息

在同步中，访问接口，需要等待3秒之后才会打印并响应

中间件

全局中间件

定义全局中间件之后，所有的请求都会经过该中间件

func main() {
       // 创建路由
       r := gin.Default()
    // 注册中间件
    r.Use(MiddleWare())
    // 大括号只是为了代码规范，没有大括号也不会有问题
    {
        r.GET("/middle", func(c *gin.Context) {
            fmt.Println("接口执行了..")
            value, _ := c.Get("middleParam")
            c.JSON(http.StatusOK, gin.H{
                "middleParam":value,
            })
        })
    }
    // 默认端口号是8080
    r.Run(":8000")
}

// 定义中间件
func MiddleWare() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        fmt.Println("中间件执行了..")
        // 将变量到Context中，可以通过Get(key)取
        c.Set("middleParam", "middle")
        // 执行函数
        c.Next()
        // 中间件执行完后续操作
        duration := time.Since(start)
        fmt.Println("执行中间件耗时:", duration)
    }
}

在代码中定义了一个中间件，并在中间件中放入了middleParam参数，然后在接口中可以将该参数取出，并且中间件总是会在接口执行之前执行。

使用postman调用接口如下：

postman发送请求

日志输出如下：

局部中间件

局部中间件仅在当前接口有用。

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/middle_local", MiddleWare(), func(c *gin.Context) {
        value, _ := c.Get("middleParam")
        c.JSON(http.StatusOK, gin.H{
            "middleParam":value,
        })
    })
    // 默认端口号是8080
    r.Run(":8000")
}

Cookie

Cookie介绍

HTTP是无状态协议，服务器不能记录浏览器的访问状态，也就是说服务器不能区分两次请求是否由同一个客户端发出，Cookie就是解决HTTP协议无状态的方案之一
Cookie实际上就是服务器保存在浏览器上的一段信息。浏览器有了Cookie之后，每次向服务器发送请求时都会同时将该信息发送给服务器，服务器收到请求后，就可以根据该信息处理请求。
Cookie由服务器创建，并发送给浏览器，最终由浏览器保存。

Cookie使用

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/cookie", func(c *gin.Context) {
        // 获取客户端是否携带cookie
          cookie, err := c.Cookie("cookie_key")
        if err != nil {
            cookie = "NotSet"
            // 给客户端设置cookie
            // maxAge：有效期，单位为秒
            // path：cookie所在目录
            // domain：域名
            // secure：是否只能通过https访问
            // httpOnly：是否允许别人通过js获取自己的cookie
            c.SetCookie("cookie_key", "cookie_value", 60, "/", "localhost", false, true)
        }
        fmt.Printf("cookie的值是： %s\n", cookie)
    })
    // 默认端口号是8080
    r.Run(":8000")
}

参数校验

Struct结构体校验

type Person struct {
    // name必填
    Name string `form:"name" binding:"required"`
    // age必填并且大于10
    Age int `form:"age" binding:"required,gt=10"`
    // birthday格式化"2006-01-02"
    Birthday time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
}

func main() {
       // 创建路由
       r := gin.Default()
    r.GET("/struct_verify", func(c *gin.Context) {
        var person Person
        err := c.ShouldBind(&person)
        if err != nil {
            fmt.Println("Error:", err)
            c.String(http.StatusBadRequest, fmt.Sprint(err))
            return
        }
        c.String(http.StatusOK, fmt.Sprint(person))
    })
    // 3.监听端口，默认在8080
    // Run("里面不指定端口号默认为8080")
    r.Run(":8000")
}

当name不传，age小于10时返回结果如下：

Key: 'Person.Name' Error:Field validation for 'Name' failed on the 'required' tag
Key: 'Person.Age' Error:Field validation for 'Age' failed on the 'gt' tag

日志

func main() {
    // 禁用颜色显示
    gin.DisableConsoleColor()

    // 新建日志文件
    f, _ := os.Create("gin.log")
    // 将日志写入到文件中
    //gin.DefaultWriter = io.MultiWriter(f)

    // 同时将日志写入文件和控制台
    gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
    // Run("里面不指定端口号默认为8080")
    r.Run(":8000")
}

本文参与了思否技术征文，欢迎正在阅读的你也加入。

go语言web开发框架—gin框架入门

快速入门

路由

API参数

URL参数

表单参数

上传单个文件

上传特定文件

上传多个文件

路由组

自定义404

数据绑定

JSON

表单

URI

数据响应

JSON、Struct、XML、YAML

重定向

同步异步

中间件

全局中间件

局部中间件

Cookie

Cookie介绍

Cookie使用

参数校验

Struct结构体校验

日志

CodeJR

引用和评论

浅谈Java虚拟机（JVM）

Go 语言-计算密集型服务性能优化

IO 密集型服务耗时优化

Go 语言 JSON 与 Cache 库调研与选型

告别ELK，APO提供基于ClickHouse开箱即用的高效日志方案——APO 0.6.0发布

Go 语言-内存泄漏排查两例

Golang GC 从原理到优化

go语言web开发框架—gin框架入门

快速入门

路由

API参数

URL参数

表单参数

上传单个文件

上传特定文件

上传多个文件

路由组

自定义404

数据绑定

JSON

表单

URI

数据响应

JSON、Struct、XML、YAML

重定向

同步异步

中间件

全局中间件

局部中间件

Cookie

Cookie介绍

Cookie使用

参数校验

Struct结构体校验

日志

CodeJR

引用和评论

浅谈Java虚拟机（JVM）

Go 语言-计算密集型服务 性能优化

IO 密集型服务 耗时优化

Go 语言 JSON 与 Cache 库 调研与选型

告别ELK，APO提供基于ClickHouse开箱即用的高效日志方案——APO 0.6.0发布

Go 语言-内存泄漏排查两例

Golang GC 从原理到优化

Go 语言-计算密集型服务性能优化

IO 密集型服务耗时优化

Go 语言 JSON 与 Cache 库调研与选型