响应

  • 响应头

  • 附加Cookie

  • 字符串响应
  1. c.String(http.StatusOK, "some string")

  • JSON/XML/YAML响应
  1. r.GET("/moreJSON", func(c *gin.Context) {
  2.     // You also can use a struct
  3.     var msg struct {
  4.         Name    string `json:"user" xml:"user"`
  5.         Message string
  6.         Number  int
  7.     }
  8.     msg.Name = "Lena"
  9.     msg.Message = "hey"
  10.     msg.Number = 123
  11.     // 注意 msg.Name 变成了 "user" 字段
  12.     // 以下方式都会输出 :   {"user": "Lena", "Message": "hey", "Number": 123}
  13.     c.JSON(http.StatusOK, gin.H{"user": "Lena", "Message": "hey", "Number": 123})
  14.     c.XML(http.StatusOK, gin.H{"user": "Lena", "Message": "hey", "Number": 123})
  15.     c.YAML(http.StatusOK, gin.H{"user": "Lena", "Message": "hey", "Number": 123})
  16.     c.JSON(http.StatusOK, msg)
  17.     c.XML(http.StatusOK, msg)
  18.     c.YAML(http.StatusOK, msg)
  19. })

  • 视图响应

先要使用 LoadHTMLTemplates() 方法来加载模板文件

  1. func main() {
  2.     router := gin.Default()
  3.     //加载模板
  4.     router.LoadHTMLGlob("templates/*")
  5.     //router.LoadHTMLFiles("templates/template1.html", "templates/template2.html")
  6.     //定义路由
  7.     router.GET("/index", func(c *gin.Context) {
  8.         //根据完整文件名渲染模板，并传递参数
  9.         c.HTML(http.StatusOK, "index.tmpl", gin.H{
  10.             "title": "Main website",
  11.         })
  12.     })
  13.     router.Run(":8080")
  14. }

模板结构定义

  1. <html>
  2.     <h1>
  3.         {{ .title }}
  4.     </h1>
  5. </html>

不同文件夹下模板名字可以相同，此时需要 LoadHTMLGlob() 加载两层模板路径

  1. router.LoadHTMLGlob("templates/**/*")
  2. router.GET("/posts/index", func(c *gin.Context) {
  3.     c.HTML(http.StatusOK, "posts/index.tmpl", gin.H{
  4.         "title": "Posts",
  5.     })
  6.     c.HTML(http.StatusOK, "users/index.tmpl", gin.H{
  7.         "title": "Users",
  8.     })
  10. }

templates/posts/index.tmpl

  1. <!-- 注意开头 define 与结尾 end 不可少 -->
  2. {{ define "posts/index.tmpl" }}
  3. <html><h1>
  4.     {{ .title }}
  5. </h1>
  6. </html>
  7. {{ end }}
  9. gin也可以使用自定义的模板引擎，如下
  11. ```go
  12. import "html/template"
  14. func main() {
  15.     router := gin.Default()
  16.     html := template.Must(template.ParseFiles("file1", "file2"))
  17.     router.SetHTMLTemplate(html)
  18.     router.Run(":8080")
  19. }

  • 文件响应
  1. //获取当前文件的相对路径
  2. router.Static("/assets", "./assets")
  3. //
  4. router.StaticFS("/more_static", http.Dir("my_file_system"))
  5. //获取相对路径下的文件
  6. router.StaticFile("/favicon.ico", "./resources/favicon.ico")

  • 重定向
  1. r.GET("/redirect", func(c *gin.Context) {
  2.     //支持内部和外部的重定向
  3.     c.Redirect(http.StatusMovedPermanently, "http://www.baidu.com/")
  4. })

  • 同步异步

goroutine 机制可以方便地实现异步处理

  1. func main() {
  2.     r := gin.Default()
  3.     //1. 异步
  4.     r.GET("/long_async", func(c *gin.Context) {
  5.         // goroutine 中只能使用只读的上下文 c.Copy()
  6.         cCp := c.Copy()
  7.         go func() {
  8.             time.Sleep(5 * time.Second)
  10.             // 注意使用只读上下文
  11.             log.Println("Done! in path " + cCp.Request.URL.Path)
  12.         }()
  13.     })
  14.     //2. 同步
  15.     r.GET("/long_sync", func(c *gin.Context) {
  16.         time.Sleep(5 * time.Second)
  18.         // 注意可以使用原始上下文
  19.         log.Println("Done! in path " + c.Request.URL.Path)
  20.     })
  22.     // Listen and serve on 0.0.0.0:8080
  23.     r.Run(":8080")
  24. }