【gin】 快速的web框架【golang】

安装

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

最简示例

package main

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

func main() {

    r := gin.Default()

    r.GET("/ping", func(c *gin.Context) {

        c.JSON(200, gin.H{

            "message": "pong",

        })

    })

    r.Run() 监听并在 0.0.0.0:8080 上启动服务

}

使用 AsciiJSON 生成具有转义的非 ASCII 字符的 ASCII-only JSON

func main() {

    r := gin.Default()

    r.GET("/someJSON", func(c *gin.Context) {

        data := map[string]interface{}{

            "lang": "GO语言",

            "tag": "
",

        }

         输出 : {"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}

        c.AsciiJSON(http.StatusOK, data)

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

HTML 渲染

func main() {

    router := gin.Default()

    router.LoadHTMLGlob("templates/*")

    router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")

    router.GET("/index", func(c *gin.Context) {

        c.HTML(http.StatusOK, "index.tmpl", gin.H{

            "title": "Main website",

        })

    })

    router.Run(":8080")

}

        {{ .title }}

    

HTTP2 server 推送

package main

import (

    "html/template"

    "log"

    "github.com/gin-gonic/gin"

)

var html = template.Must(template.New("https").Parse(

  

Welcome, Ginner!

))

func main() {

    r := gin.Default()

    r.Static("/assets", "./assets")

    r.SetHTMLTemplate(html)

    r.GET("/", func(c *gin.Context) {

        if pusher := c.Writer.Pusher(); pusher != nil {

             使用 pusher.Push() 做服务器推送

            if err := pusher.Push("/assets/app.js", nil); err != nil {

                log.Printf("Failed to push: %v", err)

            }

        }

        c.HTML(200, "https", gin.H{

            "status": "success",

        })

    })

     监听并在 https:127.0.0.1:8080 上启动服务

    r.RunTLS(":8080", "./testdata/server.pem", "./testdata/server.key")

}

JSONP

func main() {

    r := gin.Default()

    r.GET("/JSONP", func(c *gin.Context) {

        data := map[string]interface{}{

            "foo": "bar",

        }

         /JSONP?callback=x

         将输出：x({\"foo\":\"bar\"})

        c.JSONP(http.StatusOK, data)

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

Multipart/Urlencoded 表单

func main() {

    router := gin.Default()

    router.POST("/form_post", func(c *gin.Context) {

        message := c.PostForm("message")

        nick := c.DefaultPostForm("nick", "anonymous")

        c.JSON(200, gin.H{

            "status": "posted",

            "message": message,

            "nick": nick,

        })

    })

    router.Run(":8080")

}

PureJSON

通常，JSON 使用 unicode 替换特殊 HTML 字符，例如 < 变为 \ u003c。如果要按字面对这些字符进行编码，则可以使用 PureJSON

func main() {

    r := gin.Default()

     提供 unicode 实体

    r.GET("/json", func(c *gin.Context) {

        c.JSON(200, gin.H{

            "html": "Hello, world!",

        })

    })

     提供字面字符

    r.GET("/purejson", func(c *gin.Context) {

        c.PureJSON(200, gin.H{

            "html": "Hello, world!",

        })

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

Query 和 post form

POST /post?id=1234&page=1 HTTP/1.1

Content-Type: application/x-www-form-urlencoded

name=manu&message=this_is_great

func main() {

    router := gin.Default()

    router.POST("/post", func(c *gin.Context) {

        id := c.Query("id")

        page := c.DefaultQuery("page", "0")

        name := c.PostForm("name")

        message := c.PostForm("message")

        fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)

    })

    router.Run(":8080")

}

SecureJSON

func main() {

    r := gin.Default()

     你也可以使用自己的 SecureJSON 前缀

     r.SecureJsonPrefix(")]}',\n")

    r.GET("/someJSON", func(c *gin.Context) {

        names := []string{"lena", "austin", "foo"}

         将输出：while(1);["lena","austin","foo"]

        c.SecureJSON(http.StatusOK, names)

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

XML/JSON/YAML/ProtoBuf 渲染

func main() {

    r := gin.Default()

     gin.H 是 map[string]interface{} 的一种快捷方式

    r.GET("/someJSON", func(c *gin.Context) {

        c.JSON(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})

    })

    r.GET("/moreJSON", func(c *gin.Context) {

         你也可以使用一个结构体

        var msg struct {

            Name string json:"user"

            Message string

            Number int

        }

        msg.Name = "Lena"

        msg.Message = "hey"

        msg.Number = 123

         注意 msg.Name 在 JSON 中变成了 "user"

         将输出：{"user": "Lena", "Message": "hey", "Number": 123}

        c.JSON(http.StatusOK, msg)

    })

    r.GET("/someXML", func(c *gin.Context) {

        c.XML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})

    })

    r.GET("/someYAML", func(c *gin.Context) {

        c.YAML(http.StatusOK, gin.H{"message": "hey", "status": http.StatusOK})

    })

    r.GET("/someProtoBuf", func(c *gin.Context) {

        reps := []int64{int64(1), int64(2)}

        label := "test"

         protobuf 的具体定义写在 testdata/protoexample 文件中。

        data := &protoexample.Test{

            Label: &label,

            Reps: reps,

        }

         请注意，数据在响应中变为二进制数据

         将输出被 protoexample.Test protobuf 序列化了的数据

        c.ProtoBuf(http.StatusOK, data)

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.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, _ := c.FormFile("file")

        log.Println(file.Filename)

         上传文件至指定目录

        c.SaveUploadedFile(file, dst)

        c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))

    })

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

         Multipart form

        form, _ := c.MultipartForm()

        files := form.File["upload[]"]

        for _, file := range files {

            log.Println(file.Filename)

             上传文件至指定目录

            c.SaveUploadedFile(file, dst)

        }

        c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))

    })

    router.Run(":8080")

}

不使用默认的中间件

r := gin.New()

代替 r := gin.Default()

从 reader 读取数据

func main() {

    router := gin.Default()

    router.GET("/someDataFromReader", func(c *gin.Context) {

        response, err := http.Get("https:raw.githubusercontent.com/gin-gonic/logo/master/color.png")

        if err != nil || response.StatusCode != http.StatusOK {

            c.Status(http.StatusServiceUnavailable)

            return

        }

        reader := response.Body

        contentLength := response.ContentLength

        contentType := response.Header.Get("Content-Type")

        extraHeaders := map[string]string{

            "Content-Disposition": attachment; filename="gopher.png",

        }

        c.DataFromReader(http.StatusOK, contentLength, contentType, reader, extraHeaders)

    })

    router.Run(":8080")

}

使用 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"},

}

func main() {

    r := gin.Default()

     路由组使用 gin.BasicAuth() 中间件

     gin.Accounts 是 map[string]string 的一种快捷方式

    authorized := r.Group("/admin", gin.BasicAuth(gin.Accounts{

        "foo": "bar",

        "austin": "1234",

        "lena": "hello2",

        "manu": "4321",

    }))

     /admin/secrets 端点

     触发 "localhost:8080/admin/secrets

    authorized.GET("/secrets", func(c *gin.Context) {

         获取用户，它是由 BasicAuth 中间件设置的

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

        }

    })

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

使用 HTTP 方法

func main() {

     禁用控制台颜色

     gin.DisableConsoleColor()

     使用默认中间件（logger 和 recovery 中间件）创建 gin 路由

    router := gin.Default()

    router.GET("/someGet", getting)

    router.POST("/somePost", posting)

    router.PUT("/somePut", putting)

    router.DELETE("/someDelete", deleting)

    router.PATCH("/somePatch", patching)

    router.HEAD("/someHead", head)

    router.OPTIONS("/someOptions", options)

     默认在 8080 端口启动服务，除非定义了一个 PORT 的环境变量。

    router.Run()

     router.Run(":3000") hardcode 端口号

}

使用中间件

func main() {

     新建一个没有任何默认中间件的路由

    r := gin.New()

     全局中间件

     Logger 中间件将日志写入 gin.DefaultWriter，即使你将 GIN_MODE 设置为 release。

     By default gin.DefaultWriter = os.Stdout

    r.Use(gin.Logger())

     Recovery 中间件会 recover 任何 panic。如果有 panic 的话，会写入 500。

    r.Use(gin.Recovery())

     你可以为每个路由添加任意数量的中间件。

    r.GET("/benchmark", MyBenchLogger(), benchEndpoint)

     认证路由组

     authorized := r.Group("/", AuthRequired())

     和使用以下两行代码的效果完全一样:

    authorized := r.Group("/")

     路由组中间件! 在此例中，我们在 "authorized" 路由组中使用自定义创建的

     AuthRequired() 中间件

    authorized.Use(AuthRequired())

    {

        authorized.POST("/login", loginEndpoint)

        authorized.POST("/submit", submitEndpoint)

        authorized.POST("/read", readEndpoint)

         嵌套路由组

        testing := authorized.Group("testing")

        testing.GET("/analytics", analyticsEndpoint)

    }

     监听并在 0.0.0.0:8080 上启动服务

    r.Run(":8080")

}

记录日志

func main() {

     禁用控制台颜色，将日志写入文件时不需要控制台颜色。

    gin.DisableConsoleColor()

     记录到文件。

    f, _ := os.Create("gin.log")

    gin.DefaultWriter = io.MultiWriter(f)

     如果需要同时将日志写入文件和控制台，请使用以下代码。

     gin.DefaultWriter = io.MultiWriter(f, os.Stdout)

    router := gin.Default()

    router.GET("/ping", func(c *gin.Context) {

        c.String(200, "pong")

    })

    router.Run(":8080")

}

定义路由日志的格式

gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {

        log.Printf("endpoint %v %v %v %v\n", httpMethod, absolutePath, handlerName, nuHandlers)

}

将 request body 绑定到不同的结构体中

一般通过调用 c.Request.Body 方法绑定数据，但不能多次调用这个方法。

type formA struct {

  Foo string json:"foo" xml:"foo" binding:"required"

}

type formB struct {

  Bar string json:"bar" xml:"bar" binding:"required"

}

func SomeHandler(c *gin.Context) {

  objA := formA{}

  objB := formB{}

   c.ShouldBind 使用了 c.Request.Body，不可重用。

  if errA := c.ShouldBind(&objA); errA == nil {

    c.String(http.StatusOK, the body should be formA)

   因为现在 c.Request.Body 是 EOF，所以这里会报错。

  } else if errB := c.ShouldBind(&objB); errB == nil {

    c.String(http.StatusOK, the body should be formB)

  } else {

    ...

  }

}

日志颜色

gin.DisableConsoleColor()

gin.ForceConsoleColor()

支持 Let's Encrypt

package main

import (

    "log"

    "github.com/gin-gonic/autotls"

    "github.com/gin-gonic/gin"

)

func main() {

    r := gin.Default()

     Ping handler

    r.GET("/ping", func(c *gin.Context) {

        c.String(200, "pong")

    })

    log.Fatal(autotls.Run(r, "example1.com", "example2.com"))

}

查询字符串参数

func main() {

    router := gin.Default()

     使用现有的基础请求对象解析查询字符串参数。

     示例 URL： /welcome?firstname=Jane&lastname=Doe

    router.GET("/welcome", func(c *gin.Context) {

        firstname := c.DefaultQuery("firstname", "Guest")

        lastname := c.Query("lastname") c.Request.URL.Query().Get("lastname") 的一种快捷方式

        c.String(http.StatusOK, "Hello %s %s", firstname, lastname)

    })

    router.Run(":8080")

}

绑定 HTML 复选框

...

type myForm struct {

    Colors []string form:"colors[]"

}

...

func formHandler(c *gin.Context) {

    var fakeForm myForm

    c.ShouldBind(&fakeForm)

    c.JSON(200, gin.H{"color": fakeForm.Colors})

}

...

绑定 Uri

type Person struct {

    ID string uri:"id" binding:"required,uuid"

    Name string uri:"name" binding:"required"

}

func main() {

    route := gin.Default()

    route.GET("/:name/:id", func(c *gin.Context) {

        var person Person

        if err := c.ShouldBindUri(&person); err != nil {

            c.JSON(400, gin.H{"msg": err})

            return

        }

        c.JSON(200, gin.H{"name": person.Name, "uuid": person.ID})

    })

    route.Run(":8088")

}

自定义中间件

func Logger() gin.HandlerFunc {

    return func(c *gin.Context) {

        t := time.Now()

         设置 example 变量

        c.Set("example", "12345")

         请求前

        c.Next()

         请求后

        latency := time.Since(t)

        log.Print(latency)

         获取发送的 status

        status := c.Writer.Status()

        log.Println(status)

    }

}

func main() {

    r := gin.New()

    r.Use(Logger())

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

        example := c.MustGet("example").(string) 从中间件中获取变量

        log.Println(example) 打印："12345"

    })

    r.Run(":8080") 监听并在 0.0.0.0:8080 上启动服务

}

设置和获取 Cookie

func main() {

    router := gin.Default()

    router.GET("/cookie", func(c *gin.Context) {

        cookie, err := c.Cookie("gin_cookie")

        if err != nil {

            cookie = "NotSet"

            c.SetCookie("gin_cookie", "test", 3600, "/", "localhost", false, true)

        }

        fmt.Printf("Cookie value: %s \n", cookie)

    })

    router.Run()

}

路由参数

func main() {

    router := gin.Default()

     此 handler 将匹配 /user/john 但不会匹配 /user/ 或者 /user

    router.GET("/user/:name", func(c *gin.Context) {

        name := c.Param("name")

        c.String(http.StatusOK, "Hello %s", name)

    })

     此 handler 将匹配 /user/john/ 和 /user/john/send

     如果没有其他路由匹配 /user/john，它将重定向到 /user/john/

    router.GET("/user/:name/*action", func(c *gin.Context) {

        name := c.Param("name")

        action := c.Param("action")

        message := name + " is " + action

        c.String(http.StatusOK, message)

    })

    router.Run(":8080")

}

路由组

func main() {

    router := gin.Default()

     简单的路由组: v1

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

    {

        v1.POST("/login", loginEndpoint)

        v1.POST("/submit", submitEndpoint)

        v1.POST("/read", readEndpoint)

    }

     简单的路由组: v2

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

    {

        v2.POST("/login", loginEndpoint)

        v2.POST("/submit", submitEndpoint)

        v2.POST("/read", readEndpoint)

    }

    router.Run(":8080")

}

运行多个服务

package main

import (

    "log"

    "net/http"

    "time"

    "github.com/gin-gonic/gin"

    "golang.org/x/sync/errgroup"

)

var (

    g errgroup.Group

)

func router01() http.Handler {

    e := gin.New()

    e.Use(gin.Recovery())

    e.GET("/", func(c *gin.Context) {

        c.JSON(

            http.StatusOK,

            gin.H{

                "code": http.StatusOK,

                "error": "Welcome server 01",

            },

        )

    })

    return e

}

func router02() http.Handler {

    e := gin.New()

    e.Use(gin.Recovery())

    e.GET("/", func(c *gin.Context) {

        c.JSON(

            http.StatusOK,

            gin.H{

                "code": http.StatusOK,

                "error": "Welcome server 02",

            },

        )

    })

    return e

}

func main() {

    server01 := &http.Server{

        Addr: ":8080",

        Handler: router01(),

        ReadTimeout: 5 * time.Second,

        WriteTimeout: 10 * time.Second,

    }

    server02 := &http.Server{

        Addr: ":8081",

        Handler: router02(),

        ReadTimeout: 5 * time.Second,

        WriteTimeout: 10 * time.Second,

    }

    g.Go(func() error {

        return server01.ListenAndServe()

    })

    g.Go(func() error {

        return server02.ListenAndServe()

    })

    if err := g.Wait(); err != nil {

        log.Fatal(err)

    }

}

重定向

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

    c.Redirect(http.StatusMovedPermanently, "http:www.google.com/")

})

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

    c.Redirect(http.StatusFound, "/foo")

})

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

    c.Request.URL.Path = "/test2"

    r.HandleContext(c)

})

r.GET("/test2", func(c *gin.Context) {

    c.JSON(200, gin.H{"hello": "world"})

})

静态文件服务

func main() {

    router := gin.Default()

    router.Static("/assets", "./assets")

    router.StaticFS("/more_static", http.Dir("my_file_system"))

    router.StaticFile("/favicon.ico", "./resources/favicon.ico")

     监听并在 0.0.0.0:8080 上启动服务

    router.Run(":8080")

}

静态资源嵌入

可以使用 go-assets 将静态资源打包到可执行文件中。

func main() {

    r := gin.New()

    t, err := loadTemplate()

    if err != nil {

        panic(err)

    }

    r.SetHTMLTemplate(t)

    r.GET("/", func(c *gin.Context) {

        c.HTML(http.StatusOK, "/html/index.tmpl", nil)

    })

    r.Run(":8080")

}

loadTemplate 加载由 go-assets-builder 嵌入的模板

func loadTemplate() (*template.Template, error) {

    t := template.New("")

    for name, file := range Assets.Files {

        if file.IsDir() || !strings.HasSuffix(name, ".tmpl") {

            continue

        }

        h, err := ioutil.ReadAll(file)

        if err != nil {

            return nil, err

        }

        t, err = t.New(name).Parse(string(h))

        if err != nil {

            return nil, err

        }

    }

    return t, nil

}

腾图小抄 SCWY.net v0.03 小抄561条 自2022-01-02访问366178次