11.1 Go gin

框架一直是敏捷开发中的利器，能让开发者很快的上手并做出应用。

成长总不会一蹴而就，从写出程序获取成就感，再到精通框架，快速构造应用。

Gin是一个golang的微框架，封装比较优雅，API友好，源码注释比较明确。

具有快速灵活，容错方便等特点。

其实对于golang而言，web框架的依赖要远比Python，Java之类的要小。

自身的net/http足够简单，性能也非常不错。

框架更像是一些常用函数或者工具的集合。

借助框架开发，不仅可以省去很多常用的封装带来的时间，也有助于团队的编码风格和形成规范。

1.1. 使用gin

安装gin

go get github.com/gin-gonic/gin

gin与hello world

package main

import (

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    //gin.Default方法创建路由handler

    router := gin.Default()

    //绑定路由规则和路由函数,gin支持restful方法

    //gin把request和response都封装到了gin.Context的上下文环境中

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

        //返回字符串

        c.String(http.StatusOK, "Hello World")

    })

    //监听端口

    router.Run(":8000")

}

运行代码，即可访问http://0.0.0.0:8000/寻找hello world页面

1.2. restful api

借助于postman测试restful api

GET（SELECT）：从服务器取出资源（一项或多项）。
POST（CREATE）：在服务器新建一个资源。
PUT（UPDATE）：在服务器更新资源（客户端提供改变后的完整资源）。
PATCH（UPDATE）：在服务器更新资源（客户端提供改变的属性）。
DELETE（DELETE）：从服务器删除资源。
HEAD：获取资源的元数据。
OPTIONS：获取信息，关于资源的哪些属性是客户端可以改变的。

restful案例

GET /zoos：列出所有动物园
POST /zoos：新建一个动物园
GET /zoos/ID：获取某个指定动物园的信息
PUT /zoos/ID：更新某个指定动物园的信息（提供该动物园的全部信息）
PATCH /zoos/ID：更新某个指定动物园的信息（提供该动物园的部分信息）
DELETE /zoos/ID：删除某个动物园
GET /zoos/ID/animals：列出某个指定动物园的所有动物
DELETE /zoos/ID/animals/ID：删除某个指定动物园的指定动物

状态码

200 OK - [GET]：服务器成功返回用户请求的数据，该操作是幂等的（Idempotent）。
201 CREATED - [POST/PUT/PATCH]：用户新建或修改数据成功。
202 Accepted - [*]：表示一个请求已经进入后台排队（异步任务）
204 NO CONTENT - [DELETE]：用户删除数据成功。
400 INVALID REQUEST - [POST/PUT/PATCH]：用户发出的请求有错误，服务器没有进行新建或修改数据的操作，该操作是幂等的。
401 Unauthorized - [*]：表示用户没有权限（令牌、用户名、密码错误）。
403 Forbidden - [*] 表示用户得到授权（与401错误相对），但是访问是被禁止的。
404 NOT FOUND - [*]：用户发出的请求针对的是不存在的记录，服务器没有进行操作，该操作是幂等的。
406 Not Acceptable - [GET]：用户请求的格式不可得（比如用户请求JSON格式，但是只有XML格式）。
410 Gone -[GET]：用户请求的资源被永久删除，且不会再得到的。
422 Unprocesable entity - [POST/PUT/PATCH] 当创建一个对象时，发生一个验证错误。
500 INTERNAL SERVER ERROR - [*]：服务器发生错误，用户将无法判断发出的请求是否成功。

gin代码示例

用户信息接口设计 restful风格

package main

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

func main() {

    //Default返回一个默认的路由引擎

    r := gin.Default()

    //匿名函数可以用有名函数，也可以匿名函数

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

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message": "get user info succ",

        })

    })

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

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message": "create user info succ",

        })

    })

    r.PUT("/user/info", func(c *gin.Context) {

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message": "update user info succ",

        })

    })

    r.DELETE("/user/info", func(c *gin.Context) {

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message": "delete user info succ ",

        })

    })

    r.Run() // listen and serve on 0.0.0.0:8080

}

非restful风格的API

/user/info

/user/create

/user/delete

/user/update

1.3. Gin框架参数传递

实例代码，传入2个get参数

querystring传递参数

package main

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

func main() {

    //Default返回一个默认的路由引擎

    r := gin.Default()

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

        //username := c.DefaultQuery("username", "少林")

        username := c.Query("username")

        address := c.Query("address")

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message":  "pong",

            "username": username,

            "address":  address,

        })

    })

    r.Run() // listen and serve on 0.0.0.0:8080

}

通过postman发送请求，携带参数

127.0.0.1:8080/user/search?username=超哥&address=沙河

DefaultQuery返回URL参数

package main

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

func main() {

    //Default返回一个默认的路由引擎

    r := gin.Default()

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

        //使用默认值参数

        username := c.DefaultQuery("username", "超老板")

        //username := c.Query("username")

        address := c.Query("address")

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message":  "pong",

            "username": username,

            "address":  address,

        })

    })

    r.Run() // listen and serve on 0.0.0.0:8080

}

访问结果

127.0.0.1:8080/user/search?address=沙河

1.4. 获取路径中的参数

不建议使用，使用表单或者querystring方式获取参数

package main

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

func main() {

    //Default返回一个默认的路由引擎

    r := gin.Default()

    r.GET("/user/search/:username/:address", func(c *gin.Context) {

        username := c.Param("username")

        address := c.Param("address")

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message":  "pong",

            "username": username,

            "address":  address,

        })

    })

    r.Run(":8080") // listen and serve on 0.0.0.0:8080

}

访问方式

127.0.0.1:8080/user/search/chao/beijing/

1.5. 获取表单的参数

package main

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

func main() {

    //Default返回一个默认的路由引擎

    r := gin.Default()

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

        //username := c.DefaultPostForm("username", "少林")

        username := c.PostForm("username")

        address := c.PostForm("address")

        //输出json结果给调用方

        c.JSON(200, gin.H{

            "message":  "pong",

            "username": username,

            "address":  address,

        })

    })

    r.Run(":8080") // listen and serve on 0.0.0.0:8080

}

运行方式，使用post方式提交form

1.6. Gin文件上传

上传文件的名字应该由服务端统一文件名规则，防止非法字符

package main

import (

    "fmt"

    "log"

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    router := gin.Default()

    // Set a lower memory limit for multipart forms (default is 32 MiB)

    // router.MaxMultipartMemory = 8 << 20  // 8 MiB

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

        // single file

        file, err := c.FormFile("file")

        if err != nil {

            c.JSON(http.StatusInternalServerError, gin.H{

                "message": err.Error(),

            })

            return

        }

        //

        log.Println(file.Filename)

        dst := fmt.Sprintf("文件夹路径/%s", file.Filename)

        // Upload the file to specific dst.

        c.SaveUploadedFile(file, dst)

        c.JSON(http.StatusOK, gin.H{

            "message": fmt.Sprintf("'%s' uploaded!", file.Filename),

        })

    })

    router.Run(":8080")

}

上传单个文件

上传多个文件

package main

import (

    "fmt"

    "log"

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    router := gin.Default()

    //文件比较大，默认文件存在内中占32M，大于32M就写入到磁盘

    // Set a lower memory limit for multipart forms (default is 32 MiB)

    //设置上传文件的内存大小

    // router.MaxMultipartMemory = 8 << 20  // 8 MiB

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

        // Multipart form

        form, _ := c.MultipartForm()

        files := form.File["file"]

        for index, file := range files {

            log.Println(file.Filename)

            dst := fmt.Sprintf("/Users/yuchao/go/src/gostudy/gobook/%s_%d", file.Filename, index)

            // Upload the file to specific dst.

            c.SaveUploadedFile(file, dst)

        }

        c.JSON(http.StatusOK, gin.H{

            "message": fmt.Sprintf("%d files uploaded!", len(files)),

        })

    })

    router.Run(":8080")

}

上传方式

1.7. 路由分组

把前缀一样的url，放入一个组

package main

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

func login(ctx *gin.Context) {

    ctx.JSON(200, gin.H{

        "message": "success",

    })

}

func read(ctx *gin.Context) {

    ctx.JSON(200, gin.H{

        "message": "success",

    })

}

func submit(ctx *gin.Context) {

    ctx.JSON(200, gin.H{

        "message": "success",

    })

}

func main() {

    //Default返回一个默认的路由引擎

    router := gin.Default()

    // Simple group: v1

    //   /v1/login

    //   /v1/submit

    //   /v1/read

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

    {

        v1.POST("/login", login)

        v1.POST("/submit", submit)

        v1.POST("/read", read)

    }

    // Simple group: v2

    //   /v2/login

    //   /v2/submit

    //   /v2/read

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

    {

        v2.POST("/login", login)

        v2.POST("/submit", submit)

        v2.POST("/read", read)

    }

    router.Run(":8080")

}

运行方式

1.8. Gin参数绑定

使用方便，提高开发效率

通过反射机制，自动提取querystring，from表单，json，xml等参数到struct中

通过http协议中的context type，识别json、xml或是表单

package main

import (

    "fmt"

    "net/http"

    "github.com/gin-gonic/gin"

)

// Binding from JSON

type Login struct {

    User     string `form:"user" json:"user" binding:"required"`

    Password string `form:"password" json:"password" binding:"required"`

}

func main() {

    router := gin.Default()

    // Example for binding JSON ({"user": "manu", "password": "123"})

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

        var login Login

        if err := c.ShouldBindJSON(&login); err == nil {

            fmt.Printf("login info:%#v\n", login)

            c.JSON(http.StatusOK, gin.H{

                "user":     login.User,

                "password": login.Password,

            })

        } else {

            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})

        }

    })

    // Example for binding a HTML form (user=manu&password=123)

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

        var login Login

        // This will infer what binder to use depending on the content-type header.

        if err := c.ShouldBind(&login); err == nil {

            c.JSON(http.StatusOK, gin.H{

                "user":     login.User,

                "password": login.Password,

            })

        } else {

            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})

        }

    })

    // Example for binding a HTML querystring (user=manu&password=123)

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

        var login Login

        // This will infer what binder to use depending on the content-type header.

        if err := c.ShouldBind(&login); err == nil {

            c.JSON(http.StatusOK, gin.H{

                "user":     login.User,

                "password": login.Password,

            })

        } else {

            c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})

        }

    })

    // Listen and serve on 0.0.0.0:8080

    router.Run(":8080")

}

json方式提交数据

form方式提交

1.9. gin框架渲染

json渲染

package main

import (

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    r := gin.Default()

    // gin.H is a shortcut for map[string]interface{}

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

        //第一种方式,自己拼json

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

    })

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

        // You also can use a struct

        var msg struct {

            Name    string `json:"user"`

            Message string

            Number  int

        }

        msg.Name = "大王"

        msg.Message = "大王，唐僧给你捉来了"

        msg.Number = 123

        // Note that msg.Name becomes "user" in the JSON

        c.JSON(http.StatusOK, msg)

    })

    // Listen and serve on 0.0.0.0:8080

    r.Run(":8080")

}

xml渲染

package main

import (

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    r := gin.Default()

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

        // You also can use a struct

        type MessageRecord struct {

            Name    string

            Message string

            Number  int

        }

        var msg MessageRecord

        msg.Name = "二王"

        msg.Message = "你大爷"

        msg.Number = 123

        c.XML(http.StatusOK, msg)

    })

    // Listen and serve on 0.0.0.0:8080

    r.Run(":8080")

}

HTML 模板渲染

package main

import (

    "net/http"

    "github.com/gin-gonic/gin"

)

func main() {

    router := gin.Default()

    //模板路径，一层就是templates/*

    //两层就是templates/**/*

    router.LoadHTMLGlob("templates/**/*")

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

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

            "title": "我是标题",

        })

    })

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

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

            "title": "我是标题",

        })

    })

    router.Run(":8080")

}

访问路径

注意先go build main.go 再运行

http://127.0.0.1:8080/users/index

http://127.0.0.1:8080/posts/index

1.10. Gin 静态文件服务器

package main

import (

    "github.com/gin-gonic/gin"

)

func main() {

    r := gin.Default()

    //在main.go同级准备static文件夹，内含图片

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

    // Listen and serve on 0.0.0.0:8080

    r.Run(":8080")

}

注意先go build main.go 再运行

go build main.go

./main.go

http://127.0.0.1:8080/static/1.png

1.11. Go中间件

golang的net/http设计的一大特点就是特别容易构建中间件。

gin也提供了类似的中间件。需要注意的是中间件只对注册过的路由函数起作用。

对于分组路由，嵌套使用中间件，可以限定中间件的作用范围。

中间件分为全局中间件，单个路由中间件和群组中间件。

Gin框架允许请求处理过程中，加入用户自己的钩子函数。这个函数就是中间件

利用中间件可以处理例如耗时统计，日志打印，登录校验等

计算耗时的中间件

package main

import (

    "log"

    "time"

    "net/http"

    "github.com/gin-gonic/gin"

)

func StatCost() gin.HandlerFunc {

    return func(c *gin.Context) {

        t := time.Now()

        //可以设置一些公共参数，

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

        //等其他中间件先执行

        c.Next()

        //获取耗时

        latency := time.Since(t)

        //打印花费的时间 319微秒

        log.Printf("total cost time:%d us", latency/1000)

    }

}

func main() {

    //新建一个路由 gin.New()，没有中间件

    // gin.Default()最常用，包含了中间件

    //r := gin.New()

    r := gin.Default()

    //Use是全局中间件,传入一个

    r.Use(StatCost())

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

        example := c.MustGet("example").(string)

        // it would print: "12345"

        log.Println(example) //

        c.JSON(http.StatusOK, gin.H{

            "message": "success",

        })

    })

    // Listen and serve on 0.0.0.0:8080

    r.Run(":8080")

}

1.12. Gin框架路由原理

gin路由部分用的是

https://github.com/julienschmidt/httprouter

package main

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

func index(ctx *gin.Context) {

    ctx.JSON(200, gin.H{

        "message": "index",

    })

}

func main() {

    //Defatult返回一个默认的路由引擎

    router := gin.Default()

    router.POST("/", index)

    router.POST("/search", index)

    router.POST("/support", index)

    router.POST("/blog/:post", index)

    router.POST("/about", index)

    router.POST("/contact", index)

    router.POST(":8080", index)

}

共用url前缀

巴特西

11.2Go gin