一. 快速启动

下载gin的包：go get github.com/gin-gonic/gin

编写gin的hello world如下：

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default() router.GET("/hello", func(context *gin.Context) { // 注册一个路径的处理函数context.Writer.WriteString("你好!")})router.Run(":80") // 启动端口设置为80
}

访问一下：

go的原生http启动方法是通过net/http包来启动的，通过http.ListenAndServer(addr, handler)来启动服务，在这个包种有一个结构体叫Server，http服务要通过它的各种方法来做，http.ListenAndServe也是调用了server.ListenAndServe，上面的router其实是一个引擎，也可以说是一个处理器，Run方法实际也调用了http.ListenAndServe()这个方法，不过第二个参数传的是router本身，用原生的方法的话不传就是一个默认的defaultServeMux，http.handleFunc其实就是在这个mux中注册一些东西。

---

二. 不同种类的Http请求方法

gin支持Get Post Put Delete 一系列的Restful风格的请求方式，使用的方式如下：

package mainimport ("github.com/gin-gonic/gin"
)func main() {router := gin.Default()router.GET("/", func(context *gin.Context) {context.Writer.WriteString("GET方法")})router.POST("/", func(context *gin.Context) {context.Writer.WriteString("POST方法")})router.PUT("/", func(context *gin.Context) {context.Writer.WriteString("PUT方法")})router.DELETE("/", func(context *gin.Context) {context.Writer.WriteString("DELETE方法")})router.Run(":80")
}

---

三. 获取不同位置的参数

3.1 获取query参数

query参数即为url中问号后面的键值对：

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default()router.GET("/", func(context *gin.Context) {// 如果没有这个参数想给个默认值的话可以用DefaultQuery("name", "默认值")name := context.Query("name") // 获取参数，URL：http://localhost?name=jerrycontext.Writer.WriteString("hello " + name) //  输出hello jerry})router.Run(":80")
}

3.2 获取Post的表单参数

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default()router.POST("/", func(context *gin.Context) {name := context.PostForm("name")context.Writer.WriteString("hello " + name)})router.Run(":80")
}

3.3 获取path路径参数

是url路径上的一部分，比如路径可以写成这样：http://localhost/jerry
jerry就是请求的参数，获取方法如下：

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default()router.GET("/:name", func(context *gin.Context) { // 这种属于精准匹配，用*是模糊匹配，精准匹配此处必须有值，模糊匹配这个可以没有，后面也随便填name := context.Param("name")context.Writer.WriteString("hello " + name)})router.Run(":80")
}

3.4 获取json数据

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default()router.POST("/:name", func(context *gin.Context) {nameBytes, _ := context.GetRawData() // 获取json的字符串，如果想用需要用json.Unmarshal(nameBytes, &obj)解析出来context.Writer.WriteString("hello " + string(nameBytes))})router.Run(":80")
}

3.5 参数绑定

上面的调用方法在实际使用过程中其实是比较麻烦的，尤其是json的绑定方法，可以使用context.ShouldBind(&obj)方法自动绑定到一个对象上去使用，也有对应的context.ShouldBindQuery()和context.ShouldBindJSON()方法可以使用

---

四. 路由

4.1 普通的路由

就像上面的写法即可

如果想要让所有的请求方法（get、post、delete等）在该路径下都处理的话可以用any方法：

func main() {router := gin.Default()router.Any("/hello", func(context *gin.Context) { // 这样所有的hello请求不管是什么方式都会匹配context.Writer.WriteString("hello")})router.Run(":80")
}

404处理的方法可以用NoRoute解决，参数就是一个func(context *gin.Context)即可

4.2 路由分组

可以将一个拥有共同前缀的路由划分成一个路由组，如下：

package mainimport "github.com/gin-gonic/gin"func main() {router := gin.Default()group := router.Group("/groups"){group.GET("/hello", func(context *gin.Context) {context.Writer.WriteString("hi")})}router.Run(":80")
}

访问http://localhost/groups/hello即可，group.GET默认已经填上了groups前缀，group也同样拥有Get Post等请求方法，并且可以嵌套使用。这里router是没有默认前缀的

---

五. 中间件middleware

需要实现一个HandlerFunc类型的函数，就是上面处理函数的样子，然后使用router.Use(func)即可实现

func timeDurationMiddleware(context *gin.Context) {now := time.Now().Unix()context.Next() // tagtimeCost := time.Now().Unix() - nowcontext.Writer.WriteString(strconv.Itoa(int(timeCost)))
}
func main() {router := gin.Default()router.Use(timeDurationMiddleware)group := router.Group("/groups"){group.GET("/hello", func(context *gin.Context) {time.Sleep(time.Second + 1)context.Writer.WriteString("hi ")})}router.Run(":80")
}

这样就实现了一个记录调用时间的中间件，这里面的Next()函数表示先执行后面的handlerFunc，按照定义的顺序在访问http://localhost/groups/hello时会先走全局注册的timeDurationMiddleware中间件，然后走hello请求的那个处理函数，那么调用了context.Next就会在那个位置tag注释的那个位置停下，去执行下面处理函数，走完之后再回去执行tag下面的代码，类似于一个栈的过程。还有一个函数是context.Abort()，表示当前这个函数执行完就不走下面的中间件和处理函数了。

gin的Default默认了两个中间件，可以使用gin.New()来获取一个没有中间件的引擎handler

---

六. 自定义Log

较为麻烦，还没整理清原理，后续补充~

---

七. 参数校验

gin自带了validation的验证，使用的时候需要加tag并且用ShouldBind的方式：

type People struct {Name string `json:"name" binding:"required"`
}func main() {router := gin.Default()group := router.Group("/groups"){group.POST("/hello", func(context *gin.Context) {p := new(People)if err := context.ShouldBindJSON(p); err != nil {fmt.Println("出错了", err.Error())} else {fmt.Println(p)}})}router.Run(":80")
}

这是一个例子，要求name字段必填，如果不填就会出现第一行的错误。

还有一些常见的验证如下（多种验证用逗号分隔，不要乱加空格）：

eqfield= // 需要和该struct的哪个属性相同
oneof=a b c // 需要是abc其中的一个
email // 需要符合邮箱格式
gt=3 // 大于3
gte=3 // 大于等于3
eq=3 // 等于3
len=5 // slice或者string的长度等于5

---

八. 权限中间件

可以使用第三方库jwt-go来实现jwt的认证，jwt的三部分分别是头部，负载，签名，代码如下：

package jwtimport ("github.com/dgrijalva/jwt-go""time"
)const (TokenExpireDuration = time.Hour * 2 // token的过期时间
)
var jwtSecret = []byte("密钥")type MyClaims struct {UserID int64 `json:"user_id"` // 自定义的一些信息，属于负载的内容Username string `json:"username"`jwt.StandardClaims // 这里有一些认证机构，过期时间等常见的负载信息
}func GenToken(userId int64, username string) (string, error) {c := MyClaims{ // 构造一个负载UserID: userId,Username: username,StandardClaims: jwt.StandardClaims{ExpiresAt: time.Now().Add(TokenExpireDuration).Unix(), // 过期时间Issuer: "bluebell",},}token := jwt.NewWithClaims(jwt.SigningMethodHS256, c) // 用HS256签名return token.SignedString(jwtSecret) // jwtSecret是盐值，用HS256盐值加密
}func ParseToken(tokenString string) (*MyClaims, error) { // 解析一个token，这里过期等也会返回一个错误var claims = new(MyClaims)_, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {return jwtSecret, nil})if err != nil {return nil, err}return claims, nil
}

然后实现一个认证的中间件：

// JWTAuthMiddleware 基于JWT的认证中间件
func JWTAuthMiddleware() func(c *gin.Context) {return func(c *gin.Context) {// 客户端携带Token有三种方式 1.放在请求头 2.放在请求体 3.放在URI// 这里假设Token放在Header的Authorization中，并使用Bearer开头// 这里的具体实现方式要依据你的实际业务情况决定authHeader := c.Request.Header.Get("Authorization")// 获取token之后做一些合法的校验// valid code ... mc, err := jwt.ParseToken(parts[1])if err != nil {response.ResponseError(c, response.CodeInvalidToken)c.Abort() // 如果不合法要中断这次请求return}c.Next() // 后续的处理函数可以用过c.Get("userID")来获取当前请求的用户信息}
}

九. Https支持

首先需要有证书，然后将ListenAndServe修改为ListenAndServeTLS()即可（或者调用gin引擎的RunTLS）：

func main() {gin.SetMode(gin.ReleaseMode)router := gin.Default()group := router.Group("/groups"){group.POST("/hello", func(context *gin.Context) {p := new(People)if err := context.ShouldBindJSON(p); err != nil {fmt.Println("出错了", err.Error())} else {fmt.Println(p)}})}router.RunTLS(":443", "server.pem", "server.key")
}

十. 优雅关闭

可以通过第三方的endless实现，但是可以手写一个，不用引入第三方包：

// +build go1.8package mainimport ("context""log""net/http""os""os/signal""syscall""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,}// ListenAndServe会阻塞，所以要异步启动// 这里没有用http.ListenAndServe和router.Run启动，因为这样我们拿不到server对象，无法优雅的shutdowngo func() {if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {log.Fatalf("listen: %s\n", err)}}()// 一个信号通道，大小一定要开1，不然限免无法阻塞了quit := make(chan os.Signal, 1)// kill (no param) default send syscall.SIGTERM// kill -2 is syscall.SIGINT// kill -9 is syscall.SIGKILL but can't be catch, so don't need add it// 将两种停止方式注册到quit通道中signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)// 阻塞<-quitlog.Println("Shutting down server...")// The context is used to inform the server it has 5 seconds to finish// the request it is currently handlingctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)defer cancel()// shutdown中如果5s还没结束，那么会有个select接收到上面的超时错误并且返回回来// 如果正常优雅的结束掉了，那么会调用cancel函数发出一个正常的结束if err := srv.Shutdown(ctx); err != nil {log.Fatal("Server forced to shutdown:", err)}log.Println("Server exiting")
}

十一. 一个进程启动多个服务

启动两个协程分别去启动server即可，大概的写法如下：

func main() {r1 := gin.New()r2 := gin.New()var g errgroup.Group // 因为防止阻塞，所以要有一个协程启动，防止主线程G了，用它阻塞一下g.Go(func() error {return r1.Run(":8080") // server.ListenAndServe也可，本质都一样})g.Go(func() error {return r2.Run(":8081")})if err := g.Wait(); err != nil {log.Fatal(err)}
}