Windows 下安装 Gin 框架

Posted 2023-05-03

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Windows 下安装 Gin 框架相关的知识，希望对你有一定的参考价值。

参考技术A 本文主要讲述一下 Windows 下安装 Gin 框架以及遇到的一些坑。安装前请先确保已安装配置好 go 的语言环境。

官方安装地址如下（请先往下看）：

Gin中文文档

1.添加两个环境变量，否则 go get 命令会很慢，请参考如下网站：

GoProxy 中国

先设置一下代理，添加两个环境变量，如下：

2.配置 Goland ，本人使用的开发工具是 Goland ,以下配置均以 Goland 开发工具为例。

这个操作的目的是让我们可以在任意的位置创建我们的项目，而不用拘泥于 GOPATH 目录下。

创建 go 项目的方式有两种：

方式一：

此时会在项目中生成一个 go.mod 文件。

方式二（建议）：

用 Goland 直接创建新项目，依次点击 File->New->project->Go Modules (vgo) ，创建一个新的 go 项目。Location改成自己想要的位置即可。

后续的步骤跟方式一第三步类似，通过 go get 命令获取 Gin 框架源码。

在项目中创建一个 go 文件，这里我就直接拿 Gin 中文文档中给的示例了。然后执行 go run 文件名，浏览器地址栏输入 localhost:8080/ping ，看到输出信息就说明成功了。

补充几个命令：

import "github.com/gin-gonic/gin" 导入 gin 后可以执行如下命令：

本文结束！

Gin框架介绍及使用

Gin是一个用Go语言编写的web框架。它是一个类似于martini但拥有更好性能的API框架, 由于使用了httprouter，速度提高了近40倍。如果你是性能和高效的追求者, 你会爱上Gin。

Gin框架介绍

Go世界里最流行的Web框架，Github上有24K+star。基于httprouter开发的Web框架。中文文档齐全，简单易用的轻量级框架。

Gin框架安装与使用

安装

下载并安装Gin:

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

第一个Gin示例：

package main

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

func main() 
    // 创建一个默认的路由引擎
    r := gin.Default()
    // GET：请求方式；/hello：请求的路径
    // 当客户端以GET方法请求/hello路径时，会执行后面的匿名函数
    r.GET("/hello", func(c *gin.Context) 
        // c.JSON：返回JSON格式的数据
        c.JSON(200, gin.H
            "message": "Hello world!",
        )
    )
    // 启动HTTP服务，默认在0.0.0.0:8080启动服务
    r.Run()

将上面的代码保存并编译执行，然后使用浏览器打开127.0.0.1:8080/hello就能看到一串JSON字符串。

RESTful API

REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”或“表现层状态转化”。

推荐阅读阮一峰理解RESTful架构

简单来说，REST的含义就是客户端与Web服务器之间进行交互的时候，使用HTTP协议中的4个请求方法代表不同的动作。

GET用来获取资源
POST用来新建资源
PUT用来更新资源
DELETE用来删除资源。

只要API程序遵循了REST风格，那就可以称其为RESTful API。目前在前后端分离的架构中，前后端基本都是通过RESTful API来进行交互。

例如，我们现在要编写一个管理书籍的系统，我们可以查询对一本书进行查询、创建、更新和删除等操作，我们在编写程序的时候就要设计客户端浏览器与我们Web服务端交互的方式和路径。按照经验我们通常会设计成如下模式：

请求方法	URL	含义
GET	/book	查询书籍信息
POST	/create_book	创建书籍记录
POST	/update_book	更新书籍信息
POST	/delete_book	删除书籍信息

同样的需求我们按照RESTful API设计如下：

请求方法	URL	含义
GET	/book	查询书籍信息
POST	/book	创建书籍记录
PUT	/book	更新书籍信息
DELETE	/book	删除书籍信息

Gin框架支持开发RESTful API的开发。

func main() 
    r := gin.Default()
    r.GET("/book", func(c *gin.Context) 
        c.JSON(200, gin.H
            "message": "GET",
        )
    )

    r.POST("/book", func(c *gin.Context) 
        c.JSON(200, gin.H
            "message": "POST",
        )
    )

    r.PUT("/book", func(c *gin.Context) 
        c.JSON(200, gin.H
            "message": "PUT",
        )
    )

    r.DELETE("/book", func(c *gin.Context) 
        c.JSON(200, gin.H
            "message": "DELETE",
        )
    )

开发RESTful API的时候我们通常使用Postman来作为客户端的测试工具。

Gin渲染

HTML渲染

我们首先定义一个存放模板文件的templates文件夹，然后在其内部按照业务分别定义一个posts文件夹和一个users文件夹。 posts/index.html文件的内容如下：

define "posts/index.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>posts/index</title>
</head>
<body>

    .title

</body>
</html>
end

users/index.html文件的内容如下：

define "users/index.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>users/index</title>
</head>

<body>
    .title
</body>
</html>
end

Gin框架中使用LoadHTMLGlob()或者LoadHTMLFiles()方法进行HTML模板渲染。

func main() 
    r := gin.Default()
    r.LoadHTMLGlob("templates/**/*")
    //r.LoadHTMLFiles("templates/posts/index.html", "templates/users/index.html")
    r.GET("/posts/index", func(c *gin.Context) 
        c.HTML(http.StatusOK, "posts/index.html", gin.H
            "title": "posts/index",
        )
    )

    r.GET("users/index", func(c *gin.Context) 
        c.HTML(http.StatusOK, "users/index.html", gin.H
            "title": "users/index",
        )
    )

    r.Run(":8080")

静态文件处理

当我们渲染的HTML文件中引用了静态文件时，我们只需要按照以下方式在渲染页面前调用gin.Static方法即可。

func main() 
    r := gin.Default()
    r.Static("/static", "./static")
    r.LoadHTMLGlob("templates/**/*")
   ...
    r.Run(":8080")

补充文件路径处理

关于模板文件和静态文件的路径，我们需要根据公司/项目的要求进行设置。可以使用下面的函数获取当前执行程序的路径。

func getCurrentPath() string 
    if ex, err := os.Executable(); err == nil 
        return filepath.Dir(ex)
    
    return "./"

JSON渲染

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

XML渲染

注意需要使用具名的结构体类型。

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

YMAL渲染

r.GET("/someYAML", func(c *gin.Context) 
    c.YAML(http.StatusOK, gin.H"message": "ok", "status": http.StatusOK)
)

protobuf渲染

r.GET("/someProtoBuf", func(c *gin.Context) 
    reps := []int64int64(1), int64(2)
    label := "test"
    // protobuf 的具体定义写在 testdata/protoexample 文件中。
    data := &protoexample.Test
        Label: &label,
        Reps:  reps,
    
    // 请注意，数据在响应中变为二进制数据
    // 将输出被 protoexample.Test protobuf 序列化了的数据
    c.ProtoBuf(http.StatusOK, data)
)

获取参数

获取querystring参数

querystring指的是URL中?后面携带的参数，例如：/user/search?username=小王子&address=沙河。获取请求的querystring参数的方法如下：

func main() 
    //Default返回一个默认的路由引擎
    r := gin.Default()
    r.GET("/user/search", func(c *gin.Context) 
        username := c.DefaultQuery("username", "小王子")
        //username := c.Query("username")
        address := c.Query("address")
        //输出json结果给调用方
        c.JSON(http.StatusOK, gin.H
            "message":  "ok",
            "username": username,
            "address":  address,
        )
    )

    r.Run()

获取form参数

请求的数据通过form表单来提交，例如向/user/search发送一个POST请求，获取请求数据的方式如下：

func main() 
    //Default返回一个默认的路由引擎
    r := gin.Default()
    r.POST("/user/search", func(c *gin.Context) 
        // DefaultPostForm取不到值时会返回指定的默认值
        //username := c.DefaultPostForm("username", "小王子")
        username := c.PostForm("username")
        address := c.PostForm("address")
        //输出json结果给调用方
        c.JSON(http.StatusOK, gin.H
            "message":  "ok",
            "username": username,
            "address":  address,
        )
    )
    r.Run(":8080")

获取path参数

请求的参数通过URL路径传递，例如：/user/search/小王子/沙河。获取请求URL路径中的参数的方式如下。

func main() 
    //Default返回一个默认的路由引擎
    r := gin.Default()
    r.GET("/user/search/:username/:address", func(c *gin.Context) 
        username := c.Param("username")
        address := c.Param("address")
        //输出json结果给调用方
        c.JSON(http.StatusOK, gin.H
            "message":  "ok",
            "username": username,
            "address":  address,
        )
    )

    r.Run(":8080")

参数绑定

为了能够更方便的获取请求相关参数，提高开发效率，我们可以基于请求的content-type识别请求数据类型并利用反射机制自动提取请求中querystring、form表单、JSON、XML等参数到结构体中。

// Binding from JSON
type Login struct 
    User     string `form:"user" json:"user" binding:"required"`
    Password string `form:"password" json:"password" binding:"required"`


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

    // 绑定JSON的示例 ("user": "q1mi", "password": "123456")
    router.POST("/loginJSON", func(c *gin.Context) 
        var login Login

        if err := c.ShouldBindJSON(&login); err == nil 
            fmt.Printf("login info:%#v\n", login)
            c.JSON(http.StatusOK, gin.H
                "user":     login.User,
                "password": login.Password,
            )
         else 
            c.JSON(http.StatusBadRequest, gin.H"error": err.Error())
        
    )

    // 绑定form表单示例 (user=q1mi&password=123456)
    router.POST("/loginForm", func(c *gin.Context) 
        var login Login
        // ShouldBind()会根据请求的Content-Type自行选择绑定器
        if err := c.ShouldBind(&login); err == nil 
            c.JSON(http.StatusOK, gin.H
                "user":     login.User,
                "password": login.Password,
            )
         else 
            c.JSON(http.StatusBadRequest, gin.H"error": err.Error())
        
    )

    // 绑定querystring示例 (user=q1mi&password=123456)
    router.GET("/loginForm", func(c *gin.Context) 
        var login Login
        // ShouldBind()会根据请求的Content-Type自行选择绑定器
        if err := c.ShouldBind(&login); err == nil 
            c.JSON(http.StatusOK, gin.H
                "user":     login.User,
                "password": login.Password,
            )
         else 
            c.JSON(http.StatusBadRequest, gin.H"error": err.Error())
        
    )

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

文件上传

单个文件上传

func main() 
    router := gin.Default()
    // 处理multipart forms提交文件时默认的内存限制是32 MiB
    // 可以通过下面的方式修改
    // router.MaxMultipartMemory = 8 << 20  // 8 MiB
    router.POST("/upload", func(c *gin.Context) 
        // 单个文件
        file, err := c.FormFile("file")
        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),
        )
    )
    router.Run()

多个文件上传

func main() 
    router := gin.Default()
    // 处理multipart forms提交文件时默认的内存限制是32 MiB
    // 可以通过下面的方式修改
    // router.MaxMultipartMemory = 8 << 20  // 8 MiB
    router.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)),
        )
    )
    router.Run()

Gin中间件

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录校验、日志打印、耗时统计等。

Gin中的中间件必须是一个gin.HandlerFunc类型。例如我们像下面的代码一样定义一个中间件。

// StatCost 是一个统计耗时请求耗时的中间件
func StatCost() gin.HandlerFunc 
    return func(c *gin.Context) 
        start := time.Now()
        c.Set("name", "小王子")
        // 执行其他中间件
        c.Next()
        // 计算耗时
        cost := time.Since(start)
        log.Println(cost)

然后注册中间件的时候，可以在全局注册。

func main() 
    // 新建一个没有任何默认中间件的路由
    r := gin.New()
    // 注册一个全局中间件
    r.Use(StatCost())
    
    r.GET("/test", func(c *gin.Context) 
        name := c.MustGet("name").(string)
        log.Println(name)
        c.JSON(http.StatusOK, gin.H
            "message": "Hello world!",
        )
    )
    r.Run()

也可以给某个路由单独注册中间件。

// 给/test2路由单独注册中间件（可注册多个）
    r.GET("/test2", StatCost(), func(c *gin.Context) 
        name := c.MustGet("name").(string)
        log.Println(name)
        c.JSON(http.StatusOK, gin.H
            "message": "Hello world!",
        )
    )

重定向

HTTP重定向

HTTP 重定向很容易。内部、外部重定向均支持。

r.GET("/test", func(c *gin.Context) 
    c.Redirect(http.StatusMovedPermanently, "http://www.google.com/")
)

路由重定向

路由重定向，使用HandleContext：

r.GET("/test", func(c *gin.Context) 
    // 指定重定向的URL
    c.Request.URL.Path = "/test2"
    r.HandleContext(c)
)
r.GET("/test2", func(c *gin.Context) 
    c.JSON(http.StatusOK, gin.H"hello": "world")
)

Gin路由

普通路由

r.GET("/index", func(c *gin.Context) ...)
r.GET("/login", func(c *gin.Context) ...)
r.POST("/login", func(c *gin.Context) ...)

此外，还有一个可以匹配所有请求方法的Any方法如下：

r.Any("/test", func(c *gin.Context) ...)

为没有配置处理函数的路由添加处理程序。默认情况下它返回404代码。

r.NoRoute(func(c *gin.Context) 
        c.HTML(http.StatusNotFound, "views/404.html", nil)
    )

路由组

我们可以将拥有共同URL前缀的路由划分为一个路由组。

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

    
    shopGroup := r.Group("/shop")
    
        shopGroup.GET("/index", func(c *gin.Context) ...)
        shopGroup.GET("/cart", func(c *gin.Context) ...)
        shopGroup.POST("/checkout", func(c *gin.Context) ...)
    
    r.Run()

通常我们将路由分组用在划分业务逻辑或划分API版本时。

路由原理

Gin框架中的路由使用的是httprouter这个库。

其基本原理就是构造一个路由地址的前缀树。

以上是关于Windows 下安装 Gin 框架的主要内容，如果未能解决你的问题，请参考以下文章

GoGin从入门到精通—如何理解安装Gin并在本地运行

Mac电脑下搭建go环境和gin框架并成功运行小demo

Go Web 框架 Gin 实践8—为它加上Swagger，帅帅的文档

Gin框架介绍及使用