"/user/{username}" matches to "/user/me", "/user/speedwheel" etc

"/user/{path *wildcard}" matches to
"/user/some/path/here",
"/user/this/is/a/dynamic/multi/level/path" etc

"/user/{id ^[0-9]$}" matches to "/user/42" but not to "/user/somestring"

myGroup := Group("/user", userAuthenticationMiddleware)
myGroup.Handle("GET", "/", userHandler)
myGroup.Handle("GET", "/profile", userProfileHandler)
myGroup.Handle("GET", "/signup", getUserSignupForm)

myGroup.Group("/messages", optionalUserMessagesMiddleware)
myGroup.Handle("GET'', "/{id}", getMessageByID)

OnErrorCode(404, myNotFoundHandler)

.Get or GET("/path", gethandler)
.Post or POST("/path", postHandler)
.Put or PUT("/path", putHandler) and etc.

func setValue(context http_context){
    s := Sessions.New(http_context)
    s.Set("key", "my value")
}

func getValue(context http_context){
    s := Sessions.New(http_context)
    myValue := s.Get("key")
}

func logoutHandler(context http_context){
    Sessions.Destroy(http_context)
}

func TestAPI(t *testing.T) {
    app := myIrisApp() 
    tt := httptest.New(t, app)
    tt.GET("/admin").WithBasicAuth("name", "pass").Expect().
    Status(httptest.StatusOK).Body().Equal("welcome")
}

本文分享自微信公众号 - 我的小碗汤（mysmallsoup）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

C语言WEB框架小进展-静态文件返回

最近又将这个项目拿出来玩，中间已经搁置很久很久了。

这方面的经验还是严重缺失，一直在重构代码，改着改着就又重构调整。

难

最近新进展是修复了之前线程管理的BUG，加上能简单返回静态资源了

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

快速入门

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

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()
}

6. 浏览器或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发送请求如下所示：

上传单个文件

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发送请求如下：

上传特定文件

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发送请求如下：

上传多个文件

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调用接口如下：

路由组

路由组（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调用结果如下：

数据绑定

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调用接口结果如下：

表单

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调用接口结果如下：

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调用结果如下：

数据响应

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调用接口如下：

日志输出如下：

局部中间件

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

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

gin是go语言环境下的一个web框架, 它类似于Martini, 官方声称它比Martini有更好的性能, 比Martini快40倍, Ohhhh….看着不错的样子, 所以就想记录一下gin的学习. gin的github代码在这里: gin源码. gin的效率获得如此突飞猛进, 得益于另一个开源项目httprouter, 项目地址: httprouter源码. 下面主要记录一下gin的使用.

###1. 安装gin 使用命令go get github.com/gin-gonic/gin就可以. 我们使用gin的时候引入相应的包就OKimport "github.com/gin-gonic/gin".

###2. 使用方法

<1> 一种最简单的使用GET/POST方法

gin服务端代码是:

// func1: 处理最基本的GET
func func1 (c *gin.Context)  {
    // 回复一个200OK,在client的http-get的resp的body中获取数据
    c.String(http.StatusOK, "test1 OK")
}
// func2: 处理最基本的POST
func func2 (c *gin.Context) {
    // 回复一个200 OK, 在client的http-post的resp的body中获取数据
    c.String(http.StatusOK, "test2 OK")
}
func main(){
    // 注册一个默认的路由器
    router := gin.Default()
    // 最基本的用法
    router.GET("/test1", func1)
    router.POST("/test2", func2)
    // 绑定端口是8888
    router.Run(":8888")
}

客户端代码是:

func main(){
    // 调用最基本的GET,并获得返回值
    resp,_ := http.Get("http://0.0.0.0:8888/test1")
    helpRead(resp)

    // 调用最基本的POST,并获得返回值
    resp,_ = http.Post("http://0.0.0.0:8888/test2", "",strings.NewReader(""))
    helpRead(resp)
}

在服务端, 实例化了一个router, 然后使用GET和POST方法分别注册了两个服务, 当我们使用HTTP GET方法的时候会使用GET注册的函数, 如果使用HTTP POST的方法, 那么会使用POST注册的函数. gin支持所有的HTTP的方法例如: GET, POST, PUT, PATCH, DELETE 和 OPTIONS等. 看客户端中的代码, 当调用http.Get("http://0.0.0.0:8888/test1")的时候, 服务端接收到请求, 并根据/test1将请求路由到func1函数进行 处理. 同理, 调用http.Post("http://0.0.0.0:8888/test2", "",strings.NewReader(""))时候, 会使用func2函数处理. 在func1和func2中, 使用gin.Context填充了一个String的回复. 当然也支持JSON, XML, HTML等其他一些格式数据. 当执行c.String或者c.JSON时, 相当于向http的回复缓冲区写入了 一些数据. 最后调用router.Run(“:8888”)开始进行监听,Run的核心代码是:

func (engine *Engine) Run(addr string) (err error) {
	debugPrint("Listening and serving HTTP on %s\n", addr)
	defer func() { debugPrintError(err) }()
	// 核心代码
	err = http.ListenAndServe(addr, engine)
	return
}

其本质就是http.ListenAndServe(addr, engine). 
注意: helpRead函数是用于读取response的Body的函数, 你可以自己定义, 本文中此函数定义为:

// 用于读取resp的body
func helpRead(resp *http.Response)  {
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("ERROR2!: ", err)
    }
    fmt.Println(string(body))
}

<2> 传递参数

传递参数有几种方法, 对应到gin使用几种不同的方式来解析.

**第一种:** 使用gin.Context中的Param方法解析

对应的服务端代码为:

// func3: 处理带参数的path-GET
func func3(c *gin.Context)  {
    // 回复一个200 OK
    // 获取传入的参数
    name := c.Param("name")
    passwd := c.Param("passwd")
    c.String(http.StatusOK, "参数:%s %s  test3 OK", name, passwd)
}
// func4: 处理带参数的path-POST
func func4(c *gin.Context)  {
    // 回复一个200 OK
    // 获取传入的参数
    name := c.Param("name")
    passwd := c.Param("passwd")
    c.String(http.StatusOK, "参数:%s %s  test4 OK", name, passwd)
}
// func5: 注意'':''和''*''的区别
func func5(c *gin.Context)  {
    // 回复一个200 OK
    // 获取传入的参数
    name := c.Param("name")
    passwd := c.Param("passwd")
    c.String(http.StatusOK, "参数:%s %s  test5 OK", name, passwd)
}

func main(){
    router := gin.Default()
    // TODO:注意'':''必须要匹配,''*''选择匹配,即存在就匹配,否则可以不考虑
    router.GET("/test3/:name/:passwd", func3)
    router.POST("/test4/:name/:passwd", func4)
    router.GET("/test5/:name/*passwd", func5)

    router.Run(":8888")
}

客户端测试代码是:

func main() {
    // GET传参数,使用gin的Param解析格式: /test3/:name/:passwd
    resp,_ = http.Get("http://0.0.0.0:8888/test3/name=TAO/passwd=123")
    helpRead(resp)

    // POST传参数,使用gin的Param解析格式: /test3/:name/:passwd
    resp,_ = http.Post("http://0.0.0.0:8888/test4/name=PT/passwd=456", "",strings.NewReader(""))
    helpRead(resp)

    // 注意Param中'':''和''*''的区别
    resp,_ = http.Get("http://0.0.0.0:8888/test5/name=TAO/passwd=789")
    helpRead(resp)
    resp,_ = http.Get("http://0.0.0.0:8888/test5/name=TAO/")
    helpRead(resp)
}

注意上面定义参数的方法有两个辅助符号: ‘:’和’*’. 如果使用’:’参数方法, 那么这个参数是必须要匹配的, 例如上面的router.GET(“/test3/:name/:passwd”, func3), 当请求URL是 类似于http://0.0.0.0:8888/test3/name=TAO/passwd=123这样的参会被匹配, 如果是http://0.0.0.0:8888/test3/name=TAO 或者http://0.0.0.0:8888/test3/passwd=123是不能匹配的. 但是如果使用’*‘参数, 那么这个参数是可选的. router.GET(“/test5/:name/*passwd”, func5) 可以匹配http://0.0.0.0:8888/test5/name=TAO/passwd=789, 也可以匹配http://0.0.0.0:8888/test5/name=TAO/. 需要注意的一点是, 下面这个URL是不是能够 匹配呢? http://0.0.0.0:8888/test5/name=TAO, 注意TAO后面没有’/’, 这个其实就要看有没有一个路由是到http://0.0.0.0:8888/test5/name=TAO路径的, 如果有, 那么指定的那个函数进行处理, 如果没有http://0.0.0.0:8888/test5/name=TAO会被重定向到http://0.0.0.0:8888/test5/name=TAO/, 然后被当前注册的函数进行处理.

**第二种:** 使用gin.Context中的Query方法解析

这个类似于正常的URL中的参数传递, 先看服务端代码:

// 使用Query获取参数
func func6(c *gin.Context)  {
    // 回复一个200 OK
    // 获取传入的参数
    name := c.Query("name")
    passwd := c.Query("passwd")
    c.String(http.StatusOK, "参数:%s %s  test6 OK", name, passwd)
}
// 使用Query获取参数
func func7(c *gin.Context)  {
    // 回复一个200 OK
    // 获取传入的参数
    name := c.Query("name")
    passwd := c.Query("passwd")
    c.String(http.StatusOK, "参数:%s %s  test7 OK", name, passwd)
}

func main(){
    router := gin.Default()
    // 使用gin的Query参数形式,/test6?firstname=Jane&lastname=Doe
    router.GET("/test6", func6)
    router.POST("/test7", func7)

    router.Run(":8888")
}

客户端测试代码是:

func main() {
    // 使用Query获取参数形式/test6?firstname=Jane&lastname=Doe
    resp,_ = http.Get("http://0.0.0.0:8888/test6?name=BBB&passwd=CCC")
    helpRead(resp)
    resp,_ = http.Post("http://0.0.0.0:8888/test7?name=DDD&passwd=EEE", "",strings.NewReader(""))
    helpRead(resp)
}

这种方法的参数也是接在URL后面, 形如http://0.0.0.0:8888/test6?name=BBB&passwd=CCC. 服务器可以使用name := c.Query(“name”)这种 方法来解析参数.

**第三种:** 使用gin.Context中的PostForm方法解析

我们需要将参数放在请求的Body中传递, 而不是URL中. 先看服务端代码:

// 参数是form中获得,即从Body中获得,忽略URL中的参数
func func8(c *gin.Context)  {
    message := c.PostForm("message")
    extra := c.PostForm("extra")
    nick := c.DefaultPostForm("nick", "anonymous")

    c.JSON(200, gin.H{
        "status":  "test8:posted",
        "message": message,
        "nick":    nick,
        "extra": extra,
    })
}

func main(){
    router := gin.Default()
    // 使用post_form形式,注意必须要设置Post的type,
    // 同时此方法中忽略URL中带的参数,所有的参数需要从Body中获得
    router.POST("/test8", func8)

    router.Run(":8888")
}

客户端代码是:

func main() {
    // 使用post_form形式,注意必须要设置Post的type,同时此方法中忽略URL中带的参数,所有的参数需要从Body中获得
    resp,_ = http.Post("http://0.0.0.0:8888/test8", "application/x-www-form-urlencoded",strings.NewReader("message=8888888&extra=999999"))
    helpRead(resp)
}

由于我们使用了request Body, 那么就需要指定Body中数据的形式, 此处是form格式, 即application/x-www-form-urlencoded. 常见的几种http提交数据方式有: application/x-www-form-urlencoded; multipart/form-data; application/json; text/xml. 具体使用请google.
在服务端, 使用message := c.PostForm(“message”)方法解析参数, 然后进行处理.

<3> 传输文件

下面测试从client传输文件到server. 传输文件需要使用multipart/form-data格式的数据, 所有需要设定Post的类型是multipart/form-data. 
首先看服务端代码:

// 接收client上传的文件
// 从FormFile中获取相关的文件data!
// 然后写入本地文件
func func9(c *gin.Context) {
    // 注意此处的文件名和client处的应该是一样的
    file, header , err := c.Request.FormFile("uploadFile")
    filename := header.Filename
    fmt.Println(header.Filename)
    // 创建临时接收文件
    out, err := os.Create("copy_"+filename)
    if err != nil {
        log.Fatal(err)
    }
    defer out.Close()
    // Copy数据
    _, err = io.Copy(out, file)
    if err != nil {
        log.Fatal(err)
    }
    c.String(http.StatusOK, "upload file success")
}

func main(){
    router := gin.Default()
    // 接收上传的文件,需要使用
    router.POST("/upload", func9)

    router.Run(":8888")
}

客户端代码是:

func main() {
    // 上传文件POST
    // 下面构造一个文件buf作为POST的BODY
    buf := new(bytes.Buffer)
    w := multipart.NewWriter(buf)
    fw,_ := w.CreateFormFile("uploadFile", "images.png") //这里的uploadFile必须和服务器端的FormFile-name一致
    fd,_ := os.Open("images.png")
    defer fd.Close()
    io.Copy(fw, fd)
    w.Close()
    resp,_ = http.Post("http://0.0.0.0:8888/upload", w.FormDataContentType(), buf)
    helpRead(resp)
}

首先客户端本地需要有一张”images.png”图片, 同时需要创建一个Form, 并将field-name命名为”uploadFile”, file-name命名为”images.png”. 在服务端, 通过”uploadFile”可以得到文件信息. 客户端继续将图片数据copy到创建好的Form中, 将数据数据Post出去, 注意数据的类型指定! 在服务端, 通过file, header , err := c.Request.FormFile(“uploadFile”)获得文件信息, file中就是文件数据, 将其拷贝到本地文件, 完成文件传输.

<4> binding数据

gin内置了几种数据的绑定例如JSON, XML等. 简单来说, 即根据Body数据类型, 将数据赋值到指定的结构体变量中. (类似于序列化和反序列化) 
看服务端代码:

// Binding数据
// 注意:后面的form:user表示在form中这个字段是user,不是User, 同样json:user也是
// 注意:binding:"required"要求这个字段在client端发送的时候必须存在,否则报错!
type Login struct {
    User     string `form:"user" json:"user" binding:"required"`
    Password string `form:"password" json:"password" binding:"required"`
}
// bind JSON数据
func funcBindJSON(c *gin.Context) {
    var json Login
    // binding JSON,本质是将request中的Body中的数据按照JSON格式解析到json变量中
    if c.BindJSON(&json) == nil {
        if json.User == "TAO" && json.Password == "123" {
            c.JSON(http.StatusOK, gin.H{"JSON=== status": "you are logged in"})
        } else {
            c.JSON(http.StatusUnauthorized, gin.H{"JSON=== status": "unauthorized"})
        }
    } else {
        c.JSON(404, gin.H{"JSON=== status": "binding JSON error!"})
    }
}

// 下面测试bind FORM数据
func funcBindForm(c *gin.Context) {
    var form Login
    // 本质是将c中的request中的BODY数据解析到form中

    // 方法一: 对于FORM数据直接使用Bind函数, 默认使用使用form格式解析,if c.Bind(&form) == nil
    // 方法二: 使用BindWith函数,如果你明确知道数据的类型
    if c.BindWith(&form, binding.Form) == nil{
        if form.User == "TAO" && form.Password == "123" {
            c.JSON(http.StatusOK, gin.H{"FORM=== status": "you are logged in"})
        } else {
            c.JSON(http.StatusUnauthorized, gin.H{"FORM=== status": "unauthorized"})
        }
    } else {
        c.JSON(404, gin.H{"FORM=== status": "binding FORM error!"})
    }
}

func main(){
    router := gin.Default()
    // 下面测试bind JSON数据
    router.POST("/bindJSON", funcBindJSON)

    // 下面测试bind FORM数据
    router.POST("/bindForm", funcBindForm)

    // 下面测试JSON,XML等格式的rendering
    router.GET("/someJSON", func(c *gin.Context) {
        c.JSON(http.StatusOK, gin.H{"message": "hey, budy", "status": http.StatusOK})
    })

    router.GET("/moreJSON", func(c *gin.Context) {
        // 注意:这里定义了tag指示在json中显示的是user不是User
        var msg struct {
            Name    string `json:"user"`
            Message string
            Number  int
        }
        msg.Name = "TAO"
        msg.Message = "hey, budy"
        msg.Number = 123
        // 下面的在client的显示是"user": "TAO",不是"User": "TAO"
        // 所以总体的显示是:{"user": "TAO", "Message": "hey, budy", "Number": 123
        c.JSON(http.StatusOK, msg)
    })

    //  测试发送XML数据
    router.GET("/someXML", func(c *gin.Context) {
        c.XML(http.StatusOK, gin.H{"name":"TAO", "message": "hey, budy", "status": http.StatusOK})
    })

    router.Run(":8888")
}

客户端代码:

func main() {
    // 下面测试binding数据
    // 首先测试binding-JSON,
    // 注意Body中的数据必须是JSON格式
    resp,_ = http.Post("http://0.0.0.0:8888/bindJSON", "application/json", strings.NewReader("{\"user\":\"TAO\", \"password\": \"123\"}"))
    helpRead(resp)

    // 下面测试bind FORM数据
    resp,_ = http.Post("http://0.0.0.0:8888/bindForm", "application/x-www-form-urlencoded", strings.NewReader("user=TAO&password=123"))
    helpRead(resp)

    // 下面测试接收JSON和XML数据
    resp,_ = http.Get("http://0.0.0.0:8888/someJSON")
    helpRead(resp)
    resp,_ = http.Get("http://0.0.0.0:8888/moreJSON")
    helpRead(resp)
    resp,_ = http.Get("http://0.0.0.0:8888/someXML")
    helpRead(resp)
}

客户端发送请求, 在服务端可以直接使用c.BindJSON绑定到Json结构体上. 或者使用BindWith函数也可以, 但是需要指定绑定的数据类型, 例如JSON, XML, HTML等. Bind*函数的本质是读取request中的body数据, 拿BindJSON为例, 其核心代码是:

func (_ jsonBinding) Bind(req *http.Request, obj interface{}) error {
	// 核心代码: decode请求的body到obj中
	decoder := json.NewDecoder(req.Body)
	if err := decoder.Decode(obj); err != nil {
		return err
	}
	return validate(obj)
}

<5> router group

router group是为了方便前缀相同的URL的管理, 其基本用法如下. 
首先看服务端代码:

// router GROUP - GET测试
func func10(c *gin.Context)  {
    c.String(http.StatusOK, "test10 OK")
}
func func11(c *gin.Context)  {
    c.String(http.StatusOK, "test11 OK")
}

// router GROUP - POST测试
func func12(c *gin.Context)  {
    c.String(http.StatusOK, "test12 OK")
}
func func13(c *gin.Context)  {
    c.String(http.StatusOK, "test13 OK")
}

func main(){
    router := gin.Default()
    // router Group是为了将一些前缀相同的URL请求放在一起管理
    group1 := router.Group("/g1")
    group1.GET("/read1", func10)
    group1.GET("/read2", func11)

    group2 := router.Group("/g2")
    group2.POST("/write1", func12)
    group2.POST("/write2", func13)

    router.Run(":8888")
}

客户端测试代码:

func main() {
    // 下面测试router 的GROUP
    resp,_ = http.Get("http://0.0.0.0:8888/g1/read1")
    helpRead(resp)
    resp,_ = http.Get("http://0.0.0.0:8888/g1/read2")
    helpRead(resp)
    resp,_ = http.Post("http://0.0.0.0:8888/g2/write1", "", strings.NewReader(""))
    helpRead(resp)
    resp,_ = http.Post("http://0.0.0.0:8888/g2/write2", "", strings.NewReader(""))
    helpRead(resp)
}

在服务端代码中, 首先创建了一个组group1 := router.Group(“/g1”), 并在这个组下注册了两个服务, group1.GET(“/read1”, func10) 和group1.GET(“/read2”, func11), 那么当使用http://0.0.0.0:8888/g1/read1和http://0.0.0.0:8888/g1/read2访问时, 是可以路由 到上面注册的位置的. 同理对于group2 := router.Group(“/g2”)也是一样的.

<6> 静态文件服务

可以向客户端展示本地的一些文件信息, 例如显示某路径下地文件. 服务端代码是:

func main(){
    router := gin.Default()
    // 下面测试静态文件服务
    // 显示当前文件夹下的所有文件/或者指定文件
    router.StaticFS("/showDir", http.Dir("."))
    router.Static("/files", "/bin")
    router.StaticFile("/image", "./assets/1.png")

    router.Run(":8888")
}

首先你需要在服务器的路径下创建一个assert文件夹, 并且放入1.png文件. 如果已经存在, 请忽略. 
测试代码: 请在浏览器中输入0.0.0.0:8888/showDir, 显示的是服务器当前路径下地文件信息:

输入0.0.0.0:8888/files, 显示的是/bin目录下地文件信息:

输入0.0.0.0:8888/image, 显示的是服务器下地./assets/1.png图片:

<7> 加载模板templates

gin支持加载HTML模板, 然后根据模板参数进行配置并返回相应的数据. 
看服务端代码

func main(){
    router := gin.Default()
    // 下面测试加载HTML: LoadHTMLTemplates
    // 加载templates文件夹下所有的文件
    router.LoadHTMLGlob("templates/*")
    // 或者使用这种方法加载也是OK的: router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
    router.GET("/index", func(c *gin.Context) {
        // 注意下面将gin.H参数传入index.tmpl中!也就是使用的是index.tmpl模板
        c.HTML(http.StatusOK, "index.tmpl", gin.H{
            "title": "GIN: 测试加载HTML模板",
        })
    })

    router.Run(":8888")
}

客户端测试代码是:

func main() {
    // 测试加载HTML模板
    resp,_ = http.Get("http://0.0.0.0:8888/index")
    helpRead(resp)
}

在服务端, 我们需要加载需要的templates, 这里有两种方法: 第一种使用LoadHTMLGlob加载所有的正则匹配的模板, 本例中使用的是*, 即匹配所有文件, 所以加载的是 templates文件夹下所有的模板. 第二种使用LoadHTMLFiles加载指定文件. 在本例服务器路径下有一个templates目录, 下面有一个index.tmpl模板, 模板的 内容是:

<html>
    <h1>
       { { .title } }
    </h1>
</html>

当客户端请求/index时, 服务器使用这个模板, 并填充相应的参数, 此处参数只有title, 然后将HTML数据返回给客户端. 
你也可以在浏览器请求0.0.0.0:8888/index, 效果如下图所示:

<8> 重定向

重定向相对比较简单, 服务端代码是:

func main(){
    router := gin.Default()
    // 下面测试重定向
    router.GET("/redirect", func(c *gin.Context) {
        c.Redirect(http.StatusMovedPermanently, "http://shanshanpt.github.io/")
    })

    router.Run(":8888")
}

客户端测试代码是:

func main() {
    // 下面测试重定向
    resp,_ = http.Get("http://0.0.0.0:8888/redirect")
    helpRead(resp)
}

当我们请求http://0.0.0.0:8888/redirect的时候, 会重定向到http://shanshanpt.github.io/这个站点.

<9> 使用middleware

这里使用了两个例子, 一个是logger, 另一个是BasiAuth, 具体看服务器代码:

func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        t := time.Now()
        // 设置example变量到Context的Key中,通过Get等函数可以取得
        c.Set("example", "12345")
        // 发送request之前
        c.Next()
        // 发送request之后
        latency := time.Since(t)
        log.Print(latency)

        // 这个c.Write是ResponseWriter,我们可以获得状态等信息
        status := c.Writer.Status()
        log.Println(status)
    }
}


func main(){
    router := gin.Default()
    // 1
    router.Use(Logger())
    router.GET("/logger", func(c *gin.Context) {
        example := c.MustGet("example").(string)
        log.Println(example)
    })

    // 2
    // 下面测试BasicAuth()中间件登录认证
    //
    var secrets = gin.H{
        "foo":    gin.H{"email": "foo@bar.com", "phone": "123433"},
        "austin": gin.H{"email": "austin@example.com", "phone": "666"},
        "lena":   gin.H{"email": "lena@guapa.com", "phone": "523443"},
    }
    // Group using gin.BasicAuth() middleware
    // gin.Accounts is a shortcut for map[string]string
    authorized := router.Group("/admin", gin.BasicAuth(gin.Accounts{
        "foo":    "bar",
        "austin": "1234",
        "lena":   "hello2",
        "manu":   "4321",
    }))
    // 请求URL: 0.0.0.0:8888/admin/secrets
    authorized.GET("/secrets", func(c *gin.Context) {
        // get user, it was set by the BasicAuth middleware
        user := c.MustGet(gin.AuthUserKey).(string)
        if secret, ok := secrets[user]; ok {
            c.JSON(http.StatusOK, gin.H{"user": user, "secret": secret})
        } else {
            c.JSON(http.StatusOK, gin.H{"user": user, "secret": "NO SECRET :("})
        }
    })

    router.Run(":8888")
}

客户端测试代码是:

func main() {
    // 下面测试使用中间件
    resp,_ = http.Get("http://0.0.0.0:8888/logger")
    helpRead(resp)

    // 测试验证权限中间件BasicAuth
    resp,_ = http.Get("http://0.0.0.0:8888/admin/secrets")
    helpRead(resp)
}

服务端使用Use方法导入middleware, 当请求/logger来到的时候, 会执行Logger(), 并且我们知道在GET注册的时候, 同时注册了匿名函数, 所有请看Logger函数中存在一个c.Next()的用法, 它是取出所有的注册的函数都执行一遍, 然后再回到本函数中, 所以, 本例中相当于是先执行了 c.Next()即注册的匿名函数, 然后回到本函数继续执行. 所以本例的Print的输出顺序是: 
log.Println(example) 
log.Print(latency) 
log.Println(status) 
如果将c.Next()放在log.Print(latency)后面, 那么log.Println(example)和log.Print(latency)执行的顺序就调换了. 所以一切都取决于c.Next()执行的位置. c.Next()的核心代码如下:

// Next should be used only in the middlewares.
// It executes the pending handlers in the chain inside the calling handler.
// See example in github.
func (c *Context) Next() {
	c.index++
	s := int8(len(c.handlers))
	for ; c.index < s; c.index++ {
		c.handlers[c.index](c)
	}
}

它其实是执行了后面所有的handlers. 
关于使用gin.BasicAuth() middleware, 可以直接使用一个router group进行处理, 本质和logger一样.

<10> 绑定http server

之前所有的测试中, 我们都是使用router.Run(":8888")开始执行监听, 其实还有两种方法:

// 方法二
http.ListenAndServe(":8888", router)

// 方法三:
server := &http.Server{
    Addr:           ":8888",
    Handler:        router,
    ReadTimeout:    10 * time.Second,
    WriteTimeout:   10 * time.Second,
    MaxHeaderBytes: 1 << 20,
}
server.ListenAndServe()

至此, gin最基本的一些应用都整理完了

Go语言WEB框架(Gin)详解

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

package main

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

func main() {
    //Default返回一个默认的路由引擎
    r := gin.Default()
    r.GET("/ping",func(c *gin.Context) {
        //输出json结果给调用方
        c.JSON(200,gin.H{
            "message": "pong",})
    })
    r.Run() // listen and serve on 0.0.0.0:8080
}

{"message":"pong"}

Gin 实际应用

静态资源站点

package main

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

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

    // 静态资源加载，本例为css,js以及资源图片
    router.StaticFS("/public",http.Dir("D:/goproject/src/github.com/ffhelicopter/tmm/website/static"))
    router.StaticFile("/favicon.ico","./resources/favicon.ico")

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

router := gin.Default()

func (group *RouterGroup) StaticFile(relativePath,filepath string) IRoutes
func (group *RouterGroup) StaticFS(relativePath string,fs http.FileSystem) IRoutes

动态站点

package main

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

    "github.com/ffhelicopter/tmm/handler"

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

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

    // 静态资源加载，本例为css,"./resources/favicon.ico")

    // 导入所有模板，多级目录结构需要这样写
    router.LoadHTMLGlob("website/tpl/*/*")

    // website分组
    v := router.Group("/")
    {

        v.GET("/index.html",handler.IndexHandler)
        v.GET("/add.html",handler.AddHandler)
        v.POST("/postme.html",handler.PostmeHandler)
    }

    // router.Run(":80")
    // 这样写就可以了，下面所有代码（go1.8+）是为了优雅处理重启等动作。
    srv := &http.Server{
        Addr:         ":80",Handler:      router,ReadTimeout:  30 * time.Second,WriteTimeout: 30 * time.Second,}

    go func() {
        // 监听请求
        if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("listen: %s\n",err)
        }
    }()

    // 优雅Shutdown（或重启）服务
    quit := make(chan os.Signal)
    signal.Notify(quit,os.Interrupt) // syscall.SIGKILL
    <-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)
    }
    select {
    case <-ctx.Done():
    }   
    log.Println("Server exiting")
}

v := router.Group("/login")

// 导入所有模板，多级目录结构需要这样写
router.LoadHTMLGlob("website/tpl/*/*")

// website分组
v := router.Group("/")
{

    v.GET("/index.html",handler.IndexHandler)
    v.GET("/add.html",handler.AddHandler)
    v.POST("/postme.html",handler.PostmeHandler)
}

router.LoadHTMLGlob("website/tpl/*/*")

func IndexHandler(c *gin.Context) {
    c.HTML(http.StatusOK,"index.html",gin.H{
        "Title": "作品欣赏",
    })
}

<!DOCTYPE html>
<html>
<head>
{{template "header" .}}
</head>
<body>

<!--导航-->
<divhttps://www.jb51.cc/tag/Feed/" target="_blank">Feeds">
    <div>
        <a href="https://www.jb51.cc/index.tml">欣赏</a>
        <a href="https://www.jb51.cc/add.html">
            <svgaria-hidden="true">
                <use  xlink:href="https://www.jb51.cc#icon-add"></use>
            </svg>
            发布
        </a>
    </div>
    <input type="hidden" id="showmore" value="{$showmore}">
    <input type="hidden" id="page" value="{$page}">
    <!--</div>-->
</div>
<script type="text/javascript">
    var done = true;
    $(window).scroll(function(){
        var scrollTop = $(window).scrollTop();
        var scrollHeight = $(document).height();
        var windowHeight = $(window).height();
        var showmore = $("#showmore").val();
        if(scrollTop + windowHeight + 300 >= scrollHeight && showmore == 1 && done){
            var page = $("#page").val();
            done = false;
            $.get("{:U('Product/listsAjax')}",{ page : page },function(json) {
                if (json.rs != "") {
                    $(".Feeds").append(json.rs);
                    $("#showmore").val(json.showmore);
                    $("#page").val(json.page);
                    done = true;
                }
            },'json');
        }
    });
</script>
    <script src="//at.alicdn.com/t/font_ttszo9rnm0wwmi.js"></script>
</body>
</html>

{{ define "header" }}
    <Meta charset="UTF-8">   
    <Meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,minimum-scale=1,user-scalable=no,minimal-ui">
    <Meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <Meta name="format-detection" content="telephone=no,email=no">
    <title>{{ .Title }}</title>
    <link rel="stylesheet" href="https://www.jb51.cc/public/css/common.css">
    <script src="/public/lib/jquery-3.1.1.min.js"></script>
    <script src="/public/lib/jquery.cookie.js"></script>
    <link href="https://www.jb51.cc/public/css/font-awesome.css?v=4.4.0" rel="stylesheet">
{{ end }}

注意：由于在本人在发布到 github 的代码中，在处理图片上传的代码中，除了服务器存储外，还实现了 IPFS 发布存储，如果不需要 IPFS，请注释相关代码。

//rate-limit 限流中间件
lmt := tollbooth.NewLimiter(1,nil)
lmt.SetMessage("服务繁忙，请稍后再试...")

v.GET("/index.html",LimitHandler(lmt),handler.IndexHandler)

tollbooth.LimitByKeys(lmt,[]string{"127.0.0.1","/"})

RestFull API 接口

//CORS 局部CORS，可在路由中设置全局的CORS
c.Writer.Header().Add("Access-Control-Allow-Origin","*")

package main

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

    "github.com/didip/tollbooth"
    "github.com/didip/tollbooth/limiter"
    "github.com/ffhelicopter/tmm/api"
    "github.com/ffhelicopter/tmm/handler"

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

// 定义全局的CORS中间件
func Cors() gin.HandlerFunc {
    return func(c *gin.Context) {
        c.Writer.Header().Add("Access-Control-Allow-Origin","*")
        c.Next()
    }
}

func LimitHandler(lmt *limiter.Limiter) gin.HandlerFunc {
    return func(c *gin.Context) {
        httpError := tollbooth.LimitByRequest(lmt,c.Writer,c.Request)
        if httpError != nil {
            c.Data(httpError.StatusCode,lmt.GetMessageContentType(),[]byte(httpError.Message))
            c.Abort()
        } else {
            c.Next()
        }
    }
}

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

    // 静态资源加载，本例为css,"./resources/favicon.ico")

    // 导入所有模板，多级目录结构需要这样写
    router.LoadHTMLGlob("website/tpl/*/*")
    // 也可以根据handler，实时导入模板。

    // website分组
    v := router.Group("/")
    {
        v.GET("/index.html",handler.PostmeHandler)
    }

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

    // 使用全局CORS中间件。
    // router.Use(Cors())
    // 即使是全局中间件，在use前的代码不受影响
    // 也可在handler中局部使用，见api.GetUser

    //rate-limit 中间件
    lmt := tollbooth.NewLimiter(1,nil)
    lmt.SetMessage("服务繁忙，请稍后再试...")

    // API分组(RESTFULL)以及版本控制
    v1 := router.Group("/v1")
    {
        // 下面是群组中间的用法
        // v1.Use(Cors())

        // 单个中间件的用法
        // v1.GET("/user/:id/*action",Cors(),api.GetUser)

        // rate-limit
        v1.GET("/user/:id/*action",api.GetUser)

        //v1.GET("/user/:id/*action",api.GetUser)
        // AJAX OPTIONS ，下面是有关OPTIONS用法的示例
        // v1.OPTIONS("/users",OptionsUser)      // POST
        // v1.OPTIONS("/users/:id",OptionsUser)  // PUT,DELETE
    }

    srv := &http.Server{
        Addr:         ":80",}

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

    // 优雅Shutdown（或重启）服务
    // 5秒后优雅Shutdown服务
    quit := make(chan os.Signal)
    signal.Notify(quit,os.Interrupt) //syscall.SIGKILL
    <-quit
    log.Println("Shutdown Server ...")

    ctx,err)
    }
    select {
    case <-ctx.Done():
    }
    log.Println("Server exiting")
}

关于6个最好的Go语言Web框架和go语言web框架推荐的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于C语言WEB框架小进展-静态文件返回、go语言web开发框架—gin框架入门、Go语言web框架 gin、Go语言WEB框架(Gin)详解等相关知识的信息别忘了在本站进行查找喔。