gin 学习

gin 介绍

Gin 是一个用 Go (Golang) 编写的 Web 框架。它具有类似 martini 的 API，性能要好得多，多亏了 httprouter，速度提高了 40 倍。如果您需要性能和良好的生产力，您一定会喜欢 Gin。

在本节中，我们将介绍 Gin 是什么，它解决了哪些问题，以及它如何帮助你的项目。

Radix 树

Radix 树设计思想来自于 DonaldR.Morrison 于 1968 年提出的 Patricia 树（Practical Algorithm To Retrieve Information Coded In Alphanumeric），这是一种基于二进制表示的键值的查找树，尤其适合处理非常长的、可变长度的键值。 Patricia 的基本思想是构建一个二叉树，在每个节点中都存储有在进行下一次 bit 测试之前需要跳过的 bit 数目，以此来避免单路分支。Patricia 树一般由内部节点和外部节点组成，内部节点指示需要进行 bit 测试的位置，并根据 bit 测试结果决定查找操作前进的方向；外部节点用于存储键值，查找操作将于外部节点处终结。

Patricia 查找，终结于某个叶子节点，判断该叶子节点是否与查找键相同
如果找到的叶子节点无法与查找键匹配，则在这个叶子节点的重复键链表中寻找网络匹配的可能。
如果找到的叶子节点及其重复键与查找键不满足网络匹配条件，则向树顶回溯，继续寻找网络匹配的可能

特性

快速

基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能。

支持中间件

传入的 HTTP 请求可以由一系列中间件和最终操作来处理。例如：Logger，Authorization，GZIP，最终操作 DB。

Crash 处理

Gin 可以 catch 一个发生在 HTTP 请求中的 panic 并 recover 它。这样，你的服务器将始终可用。例如，你可以向 Sentry 报告这个 panic！

JSON 验证

Gin 可以解析并验证请求的 JSON，例如检查所需值的存在。

路由组

更好地组织路由。是否需要授权，不同的 API 版本…… 此外，这些组可以无限制地嵌套而不会降低性能。

错误管理

Gin 提供了一种方便的方法来收集 HTTP 请求期间发生的所有错误。最终，中间件可以将它们写入日志文件，数据库并通过网络发送。

内置渲染

Gin 为 JSON，XML 和 HTML 渲染提供了易于使用的 API。

安装

1.下载并安装 gin：

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

2.将 gin 引入到代码中：

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

3.（可选）如果使用诸如 http.StatusOK 之类的常量，则需要引入 net/http 包：

使用Jsoniter 编译

  go build -tags=jsoniter .

AsciiJson

使用 AsciiJson 生成具有转义的非ASCII字符串的ASCII-only json

  func main(){
    r := gin.Default()
    r.GET("/json",func (c *gin.Context){
        data := map[string]interface{}{
          "lang":"GO语言",
          "tag":"<br>",
        }
        // 输出{"lang":"GO\u8bed\u8a00","tag":"\u003cbr\u003e"}
        c.AsciiJSON(http.StatusOK,data)
    })
  }

HTML 渲染

使用 LoadHTMLGlob() 或者 LoadHTMLFiles()

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

templates/index.tmpl

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

使用不同目录下名称相同的模板

func main() {
 router := gin.Default()
 router.LoadHTMLGlob("templates/**/*")
 router.GET("/posts/index", func(c *gin.Context) {
  c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
   "title": "Posts",
  })
 })
 router.GET("/users/index", func(c *gin.Context) {
  c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
   "title": "Users",
  })
 })
 router.Run(":8080")
}

templates/posts/index.tmpl

{{ define "posts/index.tmpl" }}
<html><h1>
 {{ .title }}
</h1>
<p>Using posts/index.tmpl</p>
</html>
{{ end }}

templates/users/index.tmpl

{{ define "users/index.tmpl" }}
<html><h1>
 {{ .title }}
</h1>
<p>Using users/index.tmpl</p>
</html>
{{ end }}

自定义模板渲染器

你可以使用自定义的 html 模板渲染

import "html/template"

func main() {
 router := gin.Default()
 html := template.Must(template.ParseFiles("file1", "file2"))
 router.SetHTMLTemplate(html)
 router.Run(":8080")
}

自定义分隔符

可以使用自定义分隔

 r := gin.Default()
 r.Delims("{[{", "}]}")
 r.LoadHTMLGlob("/path/to/templates")

自定义模板功能

import (
    "fmt"
    "html/template"
    "net/http"
    "time"

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

func formatAsDate(t time.Time) string {
    year, month, day := t.Date()
    return fmt.Sprintf("%d/%02d/%02d", year, month, day)
}

func main() {
    router := gin.Default()
    router.Delims("{[{", "}]}")
    router.SetFuncMap(template.FuncMap{
        "formatAsDate": formatAsDate,
    })
    router.LoadHTMLFiles("./testdata/template/raw.tmpl")

    router.GET("/raw", func(c *gin.Context) {
        c.HTML(http.StatusOK, "raw.tmpl", map[string]interface{}{
            "now": time.Date(2017, 07, 01, 0, 0, 0, 0, time.UTC),
        })
    })

    router.Run(":8080")
}

Multipart/Urlencoded 绑定

package main

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

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

func main() {
 router := gin.Default()
 router.POST("/login", func(c *gin.Context) {
  // 你可以使用显式绑定声明绑定 multipart form：
  // c.ShouldBindWith(&form, binding.Form)
  // 或者简单地使用 ShouldBind 方法自动绑定：
  var form LoginForm
  // 在这种情况下，将自动选择合适的绑定
  if c.ShouldBind(&form) == nil {
   if form.User == "user" && form.Password == "password" {
    c.JSON(200, gin.H{"status": "you are logged in"})
   } else {
    c.JSON(401, gin.H{"status": "unauthorized"})
   }
  }
 })
 router.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。Go 1.6 及更低版本无法使用此功能。

func main() {
 r := gin.Default()
 
 // 提供 unicode 实体
 r.GET("/json", func(c *gin.Context) {
  c.JSON(200, gin.H{
   "html": "<b>Hello, world!</b>",
  })
 })
 
 // 提供字面字符
 r.GET("/purejson", func(c *gin.Context) {
  c.PureJSON(200, gin.H{
   "html": "<b>Hello, world!</b>",
  })
 })
 
 // 监听并在 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")
}

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)

  dst := "./" + 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")
}

默认的中间件

// Default 使用 Logger 和 Recovery 中间件
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")
}

优雅地重启或停止

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

使用中间件

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

只绑定 url 查询字符串

ShouldBindQuery 函数只绑定 url 查询参数而忽略 post 数据。参阅详细信息.

package main

import (
 "log"

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

type Person struct {
 Name    string `form:"name"`
 Address string `form:"address"`
}

func main() {
 route := gin.Default()
 route.Any("/testing", startPage)
 route.Run(":8085")
}

func startPage(c *gin.Context) {
 var person Person
 if c.ShouldBindQuery(&person) == nil {
  log.Println("====== Only Bind By Query String ======")
  log.Println(person.Name)
  log.Println(person.Address)
 }
 c.String(200, "Success")
}

在中间件中使用 Goroutine

当在中间件或 handler 中启动新的 Goroutine 时，不能使用原始的上下文，必须使用只读副本。

之间想通过中间件记录请求日志发现不能使用

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

 r.GET("/long_async", func(c *gin.Context) {
  // 创建在 goroutine 中使用的副本
  cCp := c.Copy()
  go func() {
   // 用 time.Sleep() 模拟一个长任务。
   time.Sleep(5 * time.Second)

   // 请注意您使用的是复制的上下文 "cCp"，这一点很重要
   log.Println("Done! in path " + cCp.Request.URL.Path)
  }()
 })

 r.GET("/long_sync", func(c *gin.Context) {
  // 用 time.Sleep() 模拟一个长任务。
  time.Sleep(5 * time.Second)

  // 因为没有使用 goroutine，不需要拷贝上下文
  log.Println("Done! in path " + c.Request.URL.Path)
 })

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

支持 Let's Encrypt

一行代码支持 LetsEncrypt HTTPS servers 示例。

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

映射查询字符串或表单参数

POST /post?ids[a]=1234&ids[b]=hello HTTP/1.1
Content-Type: application/x-www-form-urlencoded

names[first]=thinkerou&names[second]=tianou

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

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

  ids := c.QueryMap("ids")
  names := c.PostFormMap("names")

  fmt.Printf("ids: %v; names: %v", ids, names)
 })
 router.Run(":8080")
}

ids: map[b:hello a:1234], names: map[second:tianou first:thinkerou]

查询字符串参数

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

模型绑定和验证

要将请求体绑定到结构体中，使用模型绑定。 Gin目前支持JSON、XML、YAML和标准表单值的绑定（foo=bar＆boo=baz）。

Gin使用 go-playground/validator/v10 进行验证。查看标签用法的全部文档.

Gin提供了两类绑定方法：

Type - Must bind
- Methods - Bind, BindJSON, BindXML, BindQuery, BindYAML
- Behavior - 这些方法属于 MustBindWith 的具体调用。如果发生绑定错误，则请求终止，并触发 c.AbortWithError(400, err).SetType(ErrorTypeBind)。响应状态码被设置为 400 并且 Content-Type 被设置为 text/plain; charset=utf-8。如果您在此之后尝试设置响应状态码，Gin会输出日志 [GIN-debug] [WARNING] Headers were already written. Wanted to override status code 400 with 422。如果您希望更好地控制绑定，考虑使用 ShouldBind 等效方法。
Type - Should bind
- Methods - ShouldBind, ShouldBindJSON, ShouldBindXML, ShouldBindQuery, ShouldBindYAML
- Behavior - 这些方法属于 ShouldBindWith 的具体调用。如果发生绑定错误，Gin 会返回错误并由开发者处理错误和请求。

使用 Bind 方法时，Gin 会尝试根据 Content-Type 推断如何绑定。如果你明确知道要绑定什么，可以使用 MustBindWith 或 ShouldBindWith。

// 绑定 JSON
type Login struct {
 User     string `form:"user" json:"user" xml:"user"  binding:"required"`
 Password string `form:"password" json:"password" xml:"password" binding:"required"`
}

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

 // 绑定 JSON ({"user": "manu", "password": "123"})
 router.POST("/loginJSON", func(c *gin.Context) {
  var json Login
  if err := c.ShouldBindJSON(&json); err != nil {
   c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
   return
  }
  
  if json.User != "manu" || json.Password != "123" {
   c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
   return
  } 
  
  c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 })

 // 绑定 XML (
 // <?xml version="1.0" encoding="UTF-8"?>
 // <root>
 //  <user>manu</user>
 //  <password>123</password>
 // </root>)
 router.POST("/loginXML", func(c *gin.Context) {
  var xml Login
  if err := c.ShouldBindXML(&xml); err != nil {
   c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
   return
  }
  
  if xml.User != "manu" || xml.Password != "123" {
   c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
   return
  } 
  
  c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 })

 // 绑定 HTML 表单 (user=manu&password=123)
 router.POST("/loginForm", func(c *gin.Context) {
  var form Login
  // 根据 Content-Type Header 推断使用哪个绑定器。
  if err := c.ShouldBind(&form); err != nil {
   c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
   return
  }
  
  if form.User != "manu" || form.Password != "123" {
   c.JSON(http.StatusUnauthorized, gin.H{"status": "unauthorized"})
   return
  } 
  
  c.JSON(http.StatusOK, gin.H{"status": "you are logged in"})
 })

 // 监听并在 0.0.0.0:8080 上启动服务
 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

package main

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

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.Error()})
   return
  }
  c.JSON(200, gin.H{"name": person.Name, "uuid": person.ID})
 })
 route.Run(":8088")
}

绑定查询字符串或表单数据

package main

import (
 "log"
 "time"

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

type Person struct {
 Name     string    `form:"name"`
 Address  string    `form:"address"`
 Birthday time.Time `form:"birthday" time_format:"2006-01-02" time_utc:"1"`
}

func main() {
 route := gin.Default()
 route.GET("/testing", startPage)
 route.Run(":8085")
}

func startPage(c *gin.Context) {
 var person Person
 // 如果是 `GET` 请求，只使用 `Form` 绑定引擎（`query`）。
 // 如果是 `POST` 请求，首先检查 `content-type` 是否为 `JSON` 或 `XML`，然后再使用 `Form`（`form-data`）。
 // 查看更多：https://github.com/gin-gonic/gin/blob/master/binding/binding.go#L88
 if c.ShouldBind(&person) == nil {
  log.Println(person.Name)
  log.Println(person.Address)
  log.Println(person.Birthday)
 }

 c.String(200, "Success")
}

运行多个服务

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

静态文件服务

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

静态资源嵌入

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
}

gin 学习

gin 介绍​

Radix 树​

特性​

快速​

支持中间件​

Crash 处理​

JSON 验证​

路由组​

错误管理​

内置渲染​

安装​

使用Jsoniter 编译​

AsciiJson​

HTML 渲染​

自定义模板渲染器​

自定义分隔符​

自定义模板功能​

Multipart/Urlencoded 绑定​

Multipart/Urlencoded 表单​

PureJSON​

Query 和 post form​

XML/JSON/YAML/ProtoBuf 渲染​

单文件​

多文件​

默认的中间件​

从 reader 读取数据​

优雅地重启或停止​

使用中间件​

只绑定 url 查询字符串​

在中间件中使用 Goroutine​

支持 Let's Encrypt​

映射查询字符串或表单参数​

查询字符串参数​

模型绑定和验证​

绑定 HTML 复选框​

绑定 Uri​

绑定查询字符串或表单数据​

运行多个服务​

静态文件服务​

静态资源嵌入​