• 《Go语言四十二章经》第四十二章 WEB框架(Gin)
    • 42.1 有关于Gin
    • 42.2 Gin实际应用

    《Go语言四十二章经》第四十二章 WEB框架(Gin)

    作者:李骁

    42.1 有关于Gin

    Gin是Go语言写的一个web框架,API性能超强,运行速度号称较httprouter要快40x。开源网址:https://github.com/gin-gonic/gin

    下载安装gin包:

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

    一个简单的例子:

    1. package main
    2. import "github.com/gin-gonic/gin"
    3. func main() {
    4. r := gin.Default()
    5. r.GET("/ping", func(c *gin.Context) {
    6. c.Json(200, gin.H{
    7. "message": "pong",
    8. })
    9. })
    10. r.Run() // listen and serve on 0.0.0.0:8080
    11. }

    编译运行程序,打开浏览器,访问 http://localhost:8080/ping
    页面显示:

    1. {"message":"pong"}

    以Json格式输出了数据。

    gin的功能不只是简单输出Json数据。它是一个轻量级的WEB框架,支持RestFull风格API,支持GET,POST,PUT,PATCH,DELETE,OPTIONS 等http方法,支持文件上传,分组路由,Multipart/Urlencoded FORM,以及支持JsonP,参数处理等等功能,这些都和WEB紧密相关,通过提供这些功能,使开发人员更方便地处理WEB业务。

    42.2 Gin实际应用

    接下来使用Gin作为框架来搭建一个拥有静态资源站点,动态WEB站点,以及RESTFull API接口站点(可专门作为手机APP应用提供服务使用)组成的,亦可根据情况分拆这套系统,每种功能独立出来单独提供服务。

    下面按照一套系统但采用分站点来说明,首先是整个系统的目录结构,website目录下面static是资源类文件,为静态资源站点专用;photo目录是UGC上传图片目录,tpl是动态站点的模板。当然这个目录结构是一种约定,你可以根据情况来修改。整个项目已经开源,你可以访问来详细了解:https://github.com/ffhelicopter/tmm

    具体每个站点的功能怎么实现呢?请看下面有关每个功能的讲述:

    一:静态资源站点

    一般网站开发中,我们会考虑把js,css,以及资源图片放在一起,作为静态站点部署在CDN,提升响应速度。采用Gin实现起来非常简单,当然也可以使用net/http包轻松实现,但使用Gin会更方便。

    不管怎么样,使用Go开发,我们可以不用花太多时间在WEB服务环境搭建上,程序启动就直接可以提供WEB服务了。

    1. package main
    2. import (
    3. "net/http"
    4. "github.com/gin-gonic/gin"
    5. )
    6. func main() {
    7. router := gin.Default()
    8. // 静态资源加载,本例为css,js以及资源图片
    9. router.StaticFS("/public", http.Dir("D:/goproject/src/github.com/ffhelicopter/tmm/website/static"))
    10. router.StaticFile("/favicon.ico", "./resources/favicon.ico")
    11. // Listen and serve on 0.0.0.0:80
    12. router.Run(":80")
    13. }

    首先需要是生成一个Engine ,这是gin的核心,默认带有Logger 和 Recovery 两个中间件。

    1. router := gin.Default()

    StaticFile 是加载单个文件,而StaticFS 是加载一个完整的目录资源:

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

    这些目录下资源是可以随时更新,而不用重新启动程序。现在编译运行程序,静态站点就可以正常访问了。

    访问http://localhost/public/images/logo.jpg 图片加载正常。每次请求响应都会在服务端有日志产生,包括响应时间,加载资源名称,响应状态值等等。

    二:动态站点

    如果需要动态交互的功能,比如发一段文字+图片上传。由于这些功能出来前端页面外,还需要服务端程序一起来实现,而且迭代需要经常需要修改代码和模板,所以把这些统一放在一个大目录下,姑且称动态站点。

    tpl是动态站点所有模板的根目录,这些模板可调用静态资源站点的css,图片等;photo是图片上传后存放的目录。

    1. package main
    2. import (
    3. "context"
    4. "log"
    5. "net/http"
    6. "os"
    7. "os/signal"
    8. "time"
    9. "github.com/ffhelicopter/tmm/handler"
    10. "github.com/gin-gonic/gin"
    11. )
    12. func main() {
    13. router := gin.Default()
    14. // 静态资源加载,本例为css,js以及资源图片
    15. router.StaticFS("/public", http.Dir("D:/goproject/src/github.com/ffhelicopter/tmm/website/static"))
    16. router.StaticFile("/favicon.ico", "./resources/favicon.ico")
    17. // 导入所有模板,多级目录结构需要这样写
    18. router.LoadHTMLGlob("website/tpl/*/*")
    19. // website分组
    20. v := router.Group("/")
    21. {
    22. v.GET("/index.html", handler.IndexHandler)
    23. v.GET("/add.html", handler.AddHandler)
    24. v.POST("/postme.html", handler.PostmeHandler)
    25. }
    26. // router.Run(":80")
    27. // 这样写就可以了,下面所有代码(go1.8+)是为了优雅处理重启等动作。
    28. srv := &http.Server{
    29. Addr: ":80",
    30. Handler: router,
    31. ReadTimeout: 30 * time.Second,
    32. WriteTimeout: 30 * time.Second,
    33. }
    34. go func() {
    35. // 监听请求
    36. if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
    37. log.Fatalf("listen: %s\n", err)
    38. }
    39. }()
    40. // 优雅Shutdown(或重启)服务
    41. quit := make(chan os.Signal)
    42. signal.Notify(quit, os.Interrupt) // syscall.SIGKILL
    43. <-quit
    44. log.Println("Shutdown Server ...")
    45. ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    46. defer cancel()
    47. if err := srv.Shutdown(ctx); err != nil {
    48. log.Fatal("Server Shutdown:", err)
    49. }
    50. select {
    51. case <-ctx.Done():
    52. }
    53. log.Println("Server exiting")
    54. }

    在动态站点实现中,引入WEB分组以及优雅重启这两个功能。WEB分组功能可以通过不同的入口根路径来区别不同的模块,这里我们可以访问:http://localhost/index.html 。如果新增一个分组,比如:

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

    我们可以访问:http://localhost/login/xxxx,xxx是我们在v.GET方法或v.POST方法中的路径。

    1. // 导入所有模板,多级目录结构需要这样写
    2. router.LoadHTMLGlob("website/tpl/*/*")
    3. // website分组
    4. v := router.Group("/")
    5. {
    6. v.GET("/index.html", handler.IndexHandler)
    7. v.GET("/add.html", handler.AddHandler)
    8. v.POST("/postme.html", handler.PostmeHandler)
    9. }

    通过router.LoadHTMLGlob(“website/tpl//“) 导入模板根目录下所有的文件。在前面有讲过html/template 包的使用,这里模板文件中的语法和前面一致。

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

    比如v.GET(“/index.html”, handler.IndexHandler) ,通过访问http://localhost/index.html 这个URL,实际由handler.IndexHandler来处理。而在tmm目录下的handler存放了package handler 文件。在包里定义了IndexHandler函数,它使用了index.html模板。

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

    index.html模板:

    1. <!DOCTYPE html>
    2. <html>
    3. <head>
    4. {{template "header" .}}
    5. </head>
    6. <body>
    7. <!--导航-->
    8. <div class="feeds">
    9. <div class="top-nav">
    10. <a href="/index.tml" class="active">欣赏</a>
    11. <a href="/add.html" class="add-btn">
    12. <svg class="icon" aria-hidden="true">
    13. <use xlink:href="#icon-add"></use>
    14. </svg>
    15. 发布
    16. </a>
    17. </div>
    18. <input type="hidden" id="showmore" value="{$showmore}">
    19. <input type="hidden" id="page" value="{$page}">
    20. <!--</div>-->
    21. </div>
    22. <script type="text/javascript">
    23. var done = true;
    24. $(window).scroll(function(){
    25. var scrollTop = $(window).scrollTop();
    26. var scrollHeight = $(document).height();
    27. var windowHeight = $(window).height();
    28. var showmore = $("#showmore").val();
    29. if(scrollTop + windowHeight + 300 >= scrollHeight && showmore == 1 && done){
    30. var page = $("#page").val();
    31. done = false;
    32. $.get("{:U('Product/listsAjax')}", { page : page }, function(json) {
    33. if (json.rs != "") {
    34. $(".feeds").append(json.rs);
    35. $("#showmore").val(json.showmore);
    36. $("#page").val(json.page);
    37. done = true;
    38. }
    39. },'json');
    40. }
    41. });
    42. </script>
    43. <script src="//at.alicdn.com/t/font_ttszo9rnm0wwmi.js"></script>
    44. </body>
    45. </html>

    在index.html模板中,通过{{template “header” .}}语句,嵌套了header.html模板。

    header.html模板:

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

    {{ define “header” }} 让我们在模板嵌套时直接使用header名字,而在index.html中的{{template “header” .}} 注意“.”,可以使参数嵌套传递,否则不能传递,比如这里的Title。

    现在我们访问 http://localhost/index.html ,可以看到浏览器显示Title 是“作品欣赏”,这个Title是通过IndexHandler来指定的。

    接下来点击“发布”按钮,我们进入发布页面,上传图片,点击“完成”提交,会提示我们成功上传图片。可以在photo目录中看到刚才上传的图片。

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

    有关IPFS:
    IPFS本质上是一种内容可寻址、版本化、点对点超媒体的分布式存储、传输协议,目标是补充甚至取代过去20年里使用的超文本媒体传输协议(HTTP),希望构建更快、更安全、更自由的互联网时代。

    IPFS 不算严格意义上区块链项目,是一个去中心化存储解决方案,但有些区块链项目通过它来做存储。

    IPFS项目有在github上开源,Go语言实现哦,可以关注并了解。

    优雅重启在迭代中有较好的实际意义,每次版本发布,如果直接停服务在部署重启,对业务还是有蛮大的影响,而通过优雅重启,这方面的体验可以做得更好些。这里ctrl + c 后过5秒服务停止。

    三:中间件的使用,在API中可能使用限流,身份验证等

    Go 语言中net/http设计的一大特点就是特别容易构建中间件。 gin也提供了类似的中间件。需要注意的是在gin里面中间件只对注册过的路由函数起作用。

    而对于分组路由,嵌套使用中间件,可以限定中间件的作用范围。大致分为全局中间件,单个路由中间件和分组中间件。

    即使是全局中间件,其使用前的代码不受影响。 也可在handler中局部使用,具体见api.GetUser 。

    在高并发场景中,有时候需要用到限流降速的功能,这里引入一个限流中间件。有关限流方法常见有两种,具体可自行研究,这里只讲使用。

    导入 import “github.com/didip/tollbooth/limiter” 包,在上面代码基础上增加如下语句:

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

    并修改

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

    当F5刷新刷新http://localhost/index.html 页面时,浏览器会显示:服务繁忙,请稍后再试…

    限流策略也可以为IP:

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

    更多限流策略的配置,可以进一步github.com/didip/tollbooth/limiter 了解。

    四:RestFull API接口

    前面说了在gin里面可以采用分组来组织访问URL,这里RestFull API需要给出不同的访问URL来和动态站点区分,所以新建了一个分组v1。

    在浏览器中访问http://localhost/v1/user/1100000/

    这里对v1.GET(“/user/:id/*action”, LimitHandler(lmt), api.GetUser) 进行了限流控制,所以如果频繁访问上面地址也将会有限制,这在API接口中非常有作用。

    通过 api这个包,来实现所有有关API的代码。在GetUser函数中,通过读取mysql数据库,查找到对应userid的用户信息,并通过Json格式返回给client。

    在api.GetUser中,设置了一个局部中间件:

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

    gin关于参数的处理,api包中api.go文件中有简单说明,限于篇幅原因,就不在此展开。这个项目的详细情况,请访问 https://github.com/ffhelicopter/tmm 了解。有关gin的更多信息,请访问https://github.com/gin-gonic/gin,该开源项目比较活跃,可以关注。

    完整mian.go代码:

    1. package main
    2. import (
    3. "context"
    4. "log"
    5. "net/http"
    6. "os"
    7. "os/signal"
    8. "time"
    9. "github.com/didip/tollbooth"
    10. "github.com/didip/tollbooth/limiter"
    11. "github.com/ffhelicopter/tmm/api"
    12. "github.com/ffhelicopter/tmm/handler"
    13. "github.com/gin-gonic/gin"
    14. )
    15. // 定义全局的CORS中间件
    16. func Cors() gin.HandlerFunc {
    17. return func(c *gin.Context) {
    18. c.Writer.Header().Add("Access-Control-Allow-Origin", "*")
    19. c.Next()
    20. }
    21. }
    22. func LimitHandler(lmt *limiter.Limiter) gin.HandlerFunc {
    23. return func(c *gin.Context) {
    24. httpError := tollbooth.LimitByRequest(lmt, c.Writer, c.Request)
    25. if httpError != nil {
    26. c.Data(httpError.StatusCode, lmt.GetMessageContentType(), []byte(httpError.Message))
    27. c.Abort()
    28. } else {
    29. c.Next()
    30. }
    31. }
    32. }
    33. func main() {
    34. gin.SetMode(gin.ReleaseMode)
    35. router := gin.Default()
    36. // 静态资源加载,本例为css,js以及资源图片
    37. router.StaticFS("/public", http.Dir("D:/goproject/src/github.com/ffhelicopter/tmm/website/static"))
    38. router.StaticFile("/favicon.ico", "./resources/favicon.ico")
    39. // 导入所有模板,多级目录结构需要这样写
    40. router.LoadHTMLGlob("website/tpl/*/*")
    41. // 也可以根据handler,实时导入模板。
    42. // website分组
    43. v := router.Group("/")
    44. {
    45. v.GET("/index.html", handler.IndexHandler)
    46. v.GET("/add.html", handler.AddHandler)
    47. v.POST("/postme.html", handler.PostmeHandler)
    48. }
    49. // 中间件 golang的net/http设计的一大特点就是特别容易构建中间件。
    50. // gin也提供了类似的中间件。需要注意的是中间件只对注册过的路由函数起作用。
    51. // 对于分组路由,嵌套使用中间件,可以限定中间件的作用范围。
    52. // 大致分为全局中间件,单个路由中间件和群组中间件。
    53. // 使用全局CORS中间件。
    54. // router.Use(Cors())
    55. // 即使是全局中间件,在use前的代码不受影响
    56. // 也可在handler中局部使用,见api.GetUser
    57. //rate-limit 中间件
    58. lmt := tollbooth.NewLimiter(1, nil)
    59. lmt.SetMessage("服务繁忙,请稍后再试...")
    60. // API分组(RESTFULL)以及版本控制
    61. v1 := router.Group("/v1")
    62. {
    63. // 下面是群组中间的用法
    64. // v1.Use(Cors())
    65. // 单个中间件的用法
    66. // v1.GET("/user/:id/*action",Cors(), api.GetUser)
    67. // rate-limit
    68. v1.GET("/user/:id/*action", LimitHandler(lmt), api.GetUser)
    69. //v1.GET("/user/:id/*action", Cors(), api.GetUser)
    70. // AJAX OPTIONS ,下面是有关OPTIONS用法的示例
    71. // v1.OPTIONS("/users", OptionsUser) // POST
    72. // v1.OPTIONS("/users/:id", OptionsUser) // PUT, DELETE
    73. }
    74. srv := &http.Server{
    75. Addr: ":80",
    76. Handler: router,
    77. ReadTimeout: 30 * time.Second,
    78. WriteTimeout: 30 * time.Second,
    79. }
    80. go func() {
    81. if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
    82. log.Fatalf("listen: %s\n", err)
    83. }
    84. }()
    85. // 优雅Shutdown(或重启)服务
    86. // 5秒后优雅Shutdown服务
    87. quit := make(chan os.Signal)
    88. signal.Notify(quit, os.Interrupt) //syscall.SIGKILL
    89. <-quit
    90. log.Println("Shutdown Server ...")
    91. ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    92. defer cancel()
    93. if err := srv.Shutdown(ctx); err != nil {
    94. log.Fatal("Server Shutdown:", err)
    95. }
    96. select {
    97. case <-ctx.Done():
    98. }
    99. log.Println("Server exiting")
    100. }