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

    Gin是Go语言写的一个web框架，API性能超强，运行速度号称较httprouter要快40x。开源网址：

    下载安装gin包：

    一个简单的例子：

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

    编译运行程序，打开浏览器，访问 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是动态站点的模板。当然这个目录结构是一种约定，你可以根据情况来修改。整个项目已经开源，你可以访问来详细了解：

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

    一：静态资源站点

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

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

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

    首先需要是生成一个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是图片上传后存放的目录。

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

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

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

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

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

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

    比如v.GET(“/index.html”, handler.IndexHandler) ，通过访问 这个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>
    8. <!--导航-->
    9. <div class="feeds">
    10.     <div class="top-nav">
    11.         <a href="/index.tml" class="active">欣赏</a>
    12.         <a href="/add.html" class="add-btn">
    13.             <svg class="icon" aria-hidden="true">
    14.                 <use  xlink:href="#icon-add"></use>
    15.             </svg>
    16.             发布
    17.         </a>
    18.     </div>
    19.     <input type="hidden" id="showmore" value="{$showmore}">
    20.     <input type="hidden" id="page" value="{$page}">
    21.     <!--</div>-->
    22. <script type="text/javascript">
    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模板：

    {{ 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语言实现哦，可以关注并了解。

    三：中间件的使用，在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刷新刷新 页面时，浏览器会显示：服务繁忙，请稍后再试…

    限流策略也可以为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", "*")

    完整mian.go代码：

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