Gin框架(2)
Gin 中使用 go-ini 加载.ini 配置文件
go-ini 介绍
go-ini 官方介绍，go-ini 是地表 最强大、最方便 和 最流行 的 Go 语言 INI 文件操作库。
Github 地址：https://github.com/go-ini/ini
官方文档:https://ini.unknwon.io/
go-ini 使用
1、新建 conf/app.ini
现在，我们编辑 my.ini 文件并输入以下内容
app_name = itying gin
# possible values: DEBUG, INFO, WARNING, ERROR, FATAL
log_level = DEBUG
[mysql]
ip = 192.168.0.6
port = 3306
user = root
password = 123456
database = gin
[redis]
ip = 127.0.0.1
port = 6379
很好，接下来我们需要编写 main.go 文件来操作刚才创建的配置文件。
package main
import (
"fmt"
"os"
"gopkg.in/ini.v1"
)
func main() {
cfg, err := ini.Load("./conf/app.ini")
if err != nil {
fmt.Printf("Fail to read file: %v", err)
os.Exit(1)
}
// 典型读取操作，默认分区可以使用空字符串表示
fmt.Println("App Mode:", cfg.Section("").Key("app_name").String())
fmt.Println("Data Path:", cfg.Section("mysql").Key("ip").String())
// 差不多了，修改某个值然后进行保存
cfg.Section("").Key("app_name").SetValue("itying gin")
cfg.SaveTo("./conf/app.ini")
}
从.ini 中读取 mysql 配置
package models
//https://gorm.io/zh_CN/docs/connecting_to_the_database.html
import (
"fmt"
"os"
"gopkg.in/ini.v1"
"gorm.io/driver/mysql"
"gorm.io/gorm"
)
var DB *gorm.DB
var err error
func init() {
cfg, err := ini.Load("./conf/app.ini")
if err != nil {
fmt.Printf("Fail to read file: %v", err)
os.Exit(1)
}
ip := cfg.Section("mysql").Key("ip").String()
port := cfg.Section("mysql").Key("port").String()
user := cfg.Section("mysql").Key("user").String()
password := cfg.Section("mysql").Key("password").String()
database := cfg.Section("mysql").Key("database").String()
dsn := fmt.Sprintf("%v:%v@tcp(%v:%v)/%v?charset=utf8mb4&parseTime=True&loc=Local", user, password, ip, port, database)
fmt.Println(dsn)
DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
QueryFields: true, //打印 sql
//SkipDefaultTransaction: true, //禁用事务
})
if err != nil {
fmt.Println(err)
}
}
validator库参数校验
使用validator库做参数校验的一些十分实用的使用技巧，包括翻译校验错误提示信息、自定义提示信息的字段名称、自定义校验方法等。
在web开发中一个不可避免的环节就是对请求参数进行校验，通常我们会在代码中定义与请求参数相对应的模型（结构体），借助模型绑定快捷地解析请求中的参数，例如 gin 框架中的Bind和ShouldBind系列方法。本文就以 gin 框架的请求参数校验为例，介绍一些validator库的实用技巧。
gin框架使用github.com/go-playground/validator进行参数校验，目前已经支持github.com/go-playground/validator/v10了，我们需要在定义结构体时使用 binding tag标识相关校验规则，可以查看validator文档查看支持的所有 tag。或者这里gin-binding参数效验_小男孩tom的博客-CSDN博客
基本示例
首先来看gin框架内置使用validator做参数校验的基本示例。
package main
import (
"net/http"
"github.com/gin-gonic/gin"
)
type SignUpParam struct {
Age uint8 `json:"age" binding:"gte=1,lte=130"`
Name string `json:"name" binding:"required"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required"`
RePassword string `json:"re_password" binding:"required,eqfield=Password"`
}
func main() {
r := gin.Default()
r.POST("/signup", func(c *gin.Context) {
var u SignUpParam
if err := c.ShouldBind(&u); err != nil {
c.JSON(http.StatusOK, gin.H{
"msg": err.Error(),
})
return
}
// 保存入库等业务逻辑代码...
c.JSON(http.StatusOK, "success")
})
_ = r.Run(":8999")
}
使用postman测试
输出结果：
{"msg":"Key: 'SignUpParam.Email' Error:Field validation for 'Email' failed on the 'email' tag\nKey: 'SignUpParam.Password' Error:Field validation for 'Password' failed on the 'required' tag\nKey: 'SignUpParam.RePassword' Error:Field validation for 'RePassword' failed on the 'required' tag"}
从最终的输出结果可以看到 validator 的检验生效了，但是错误提示的字段不是特别友好，我们可能需要将它翻译成中文。
翻译校验错误提示信息
validator库本身是支持国际化的，借助相应的语言包可以实现校验错误提示信息的自动翻译。下面的示例代码演示了如何将错误提示信息翻译成中文，翻译成其他语言的方法类似。
package main
import (
"fmt"
"net/http"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
"github.com/go-playground/locales/en"
"github.com/go-playground/locales/zh"
ut "github.com/go-playground/universal-translator"
"github.com/go-playground/validator/v10"
enTranslations "github.com/go-playground/validator/v10/translations/en"
zhTranslations "github.com/go-playground/validator/v10/translations/zh"
)
// 定义一个全局翻译器T
var trans ut.Translator
// InitTrans 初始化翻译器
func InitTrans(locale string) (err error) {
// 修改gin框架中的Validator引擎属性，实现自定制
if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
zhT := zh.New() // 中文翻译器
enT := en.New() // 英文翻译器
// 第一个参数是备用（fallback）的语言环境
// 后面的参数是应该支持的语言环境（支持多个）
// uni := ut.New(zhT, zhT) 也是可以的
uni := ut.New(enT, zhT, enT)
// locale 通常取决于 http 请求头的 'Accept-Language'
var ok bool
// 也可以使用 uni.FindTranslator(...) 传入多个locale进行查找
trans, ok = uni.GetTranslator(locale)
if !ok {
return fmt.Errorf("uni.GetTranslator(%s) failed", locale)
}
// 注册翻译器
switch locale {
case "en":
err = enTranslations.RegisterDefaultTranslations(v, trans)
case "zh":
err = zhTranslations.RegisterDefaultTranslations(v, trans)
default:
err = enTranslations.RegisterDefaultTranslations(v, trans)
}
return
}
return
}
type SignUpParam struct {
Age uint8 `json:"age" binding:"gte=1,lte=130"`
Name string `json:"name" binding:"required"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required"`
RePassword string `json:"re_password" binding:"required,eqfield=Password"`
}
func main() {
if err := InitTrans("zh"); err != nil {
fmt.Printf("init trans failed, err:%v\n", err)
return
}
r := gin.Default()
r.POST("/signup", func(c *gin.Context) {
var u SignUpParam
if err := c.ShouldBind(&u); err != nil {
// 获取validator.ValidationErrors类型的errors
errs, ok := err.(validator.ValidationErrors)
if !ok {
// 非validator.ValidationErrors类型错误直接返回
c.JSON(http.StatusOK, gin.H{
"msg": err.Error(),
})
return
}
// validator.ValidationErrors类型错误则进行翻译
c.JSON(http.StatusOK, gin.H{
"msg":errs.Translate(trans),
})
return
}
// 保存入库等具体业务逻辑代码...
c.JSON(http.StatusOK, "success")
})
_ = r.Run(":8999")
}
同样的请求再来一次：
这一次的输出结果如下：
{
"msg": {
"SignUpParam.Password": "Password为必填字段",
"SignUpParam.RePassword": "RePassword为必填字段"
}
}
自定义错误提示信息的字段名
上面的错误提示看起来是可以了，但是还是差点意思，首先是错误提示中的字段并不是请求中使用的字段，例如：RePassword是我们后端定义的结构体中的字段名，而请求中使用的是re_password字段。如何是错误提示中的字段使用自定义的名称，例如jsontag指定的值呢？
只需要在初始化翻译器的时候像下面一样添加一个获取json tag的自定义方法即可。
// InitTrans 初始化翻译器
func InitTrans(locale string) (err error) {
// 修改gin框架中的Validator引擎属性，实现自定制
if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
// 注册一个获取json tag的自定义方法
v.RegisterTagNameFunc(func(fld reflect.StructField) string {
name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
if name == "-" {
return ""
}
return name
})
zhT := zh.New() // 中文翻译器
enT := en.New() // 英文翻译器
// 第一个参数是备用（fallback）的语言环境
// 后面的参数是应该支持的语言环境（支持多个）
// uni := ut.New(zhT, zhT) 也是可以的
uni := ut.New(enT, zhT, enT)
// ... liwenzhou.com ...
}
再尝试发请求，看一下效果：
{
"msg": {
"SignUpParam.password": "password为必填字段",
"SignUpParam.re_password": "re_password为必填字段"
}
}
可以看到现在错误提示信息中使用的就是我们结构体中jsontag设置的名称了。
但是还是有点瑕疵，那就是最终的错误提示信息中心还是有我们后端定义的结构体名称——SignUpParam，这个名称其实是不需要随错误提示返回给前端的，前端并不需要这个值。我们需要想办法把它去掉。
这里参考https://github.com/go-playground/validator/issues/633#issuecomment-654382345提供的方法，定义一个去掉结构体名称前缀的自定义方法：
func removeTopStruct(fields map[string]string) map[string]string {
res := map[string]string{}
for field, err := range fields {
res[field[strings.Index(field, ".")+1:]] = err
}
return res
}
我们在代码中使用上述函数将翻译后的errors做一下处理即可：
if err := c.ShouldBind(&u); err != nil {
// 获取validator.ValidationErrors类型的errors
errs, ok := err.(validator.ValidationErrors)
if !ok {
// 非validator.ValidationErrors类型错误直接返回
c.JSON(http.StatusOK, gin.H{
"msg": err.Error(),
})
return
}
// validator.ValidationErrors类型错误则进行翻译
// 并使用removeTopStruct函数去除字段名中的结构体名称标识
c.JSON(http.StatusOK, gin.H{
"msg": removeTopStruct(errs.Translate(trans)),
})
return
}
看一下最终的效果：
{
"msg": {
"password": "password为必填字段",
"re_password": "re_password为必填字段"
}
}
这一次看起来就比较符合我们预期的标准了。
自定义结构体校验方法
上面的校验还是有点小问题，就是当涉及到一些复杂的校验规则，比如re_password字段需要与password字段的值相等这样的校验规则，我们的自定义错误提示字段名称方法就不能很好解决错误提示信息中的其他字段名称了。
可以看到re_password字段的提示信息中还是出现了Password这个结构体字段名称。这有点小小的遗憾，毕竟自定义字段名称的方法不能影响被当成param传入的值。
此时如果想要追求更好的提示效果，将上面的Password字段也改为和json tag一致的名称，就需要我们自定义结构体校验的方法。
例如，我们为SignUpParam自定义一个校验方法如下：
// SignUpParamStructLevelValidation 自定义SignUpParam结构体校验函数
func SignUpParamStructLevelValidation(sl validator.StructLevel) {
su := sl.Current().Interface().(SignUpParam)
if su.Password != su.RePassword {
// 输出错误提示信息，最后一个参数就是传递的param
sl.ReportError(su.RePassword, "re_password", "RePassword", "eqfield", "password")
}
}
然后在初始化校验器的函数中注册该自定义校验方法即可：
func InitTrans(locale string) (err error) {
// 修改gin框架中的Validator引擎属性，实现自定制
if v, ok := binding.Validator.Engine().(*validator.Validate); ok {
// ... liwenzhou.com ...
// 为SignUpParam注册自定义校验方法
v.RegisterStructValidation(SignUpParamStructLevelValidation, SignUpParam{})
zhT := zh.New() // 中文翻译器
enT := en.New() // 英文翻译器
// ... liwenzhou.com ...
}
最终再请求一次，看一下效果：
{
"msg": {
"email": "email必须是一个有效的邮箱",
"re_password": "re_password必须等于password"
}
}
自定义字段校验方法
除了上面介绍到的自定义结构体校验方法，validator还支持为某个字段自定义校验方法，并使用RegisterValidation()注册到校验器实例中。
接下来我们来为SignUpParam添加一个需要使用自定义校验方法checkDate做参数校验的字段Date。
type SignUpParam struct {
Age uint8 `json:"age" binding:"gte=1,lte=130"`
Name string `json:"name" binding:"required"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required"`
RePassword string `json:"re_password" binding:"required,eqfield=Password"`
// 需要使用自定义校验方法checkDate做参数校验的字段Date
Date string `json:"date" binding:"required,datetime=2006-01-02,checkDate"`
}
其中datetime=2006-01-02是内置的用于校验日期类参数是否满足指定格式要求的tag。 如果传入的date参数不满足2006-01-02这种格式就会提示如下错误：
{"msg":{"date":"date的格式必须是2006-01-02"}}
针对date字段除了内置的datetime=2006-01-02提供的格式要求外，假设我们还要求该字段的时间必须是一个未来的时间（晚于当前时间），像这样针对某个字段的特殊校验需求就需要我们使用自定义字段校验方法了。
首先我们要在需要执行自定义校验的字段后面添加自定义tag，这里使用的是checkDate，注意使用英文分号分隔开。
// customFunc 自定义字段级别校验方法
func customFunc(fl validator.FieldLevel) bool {
date, err := time.Parse("2006-01-02", fl.Field().String())
if err != nil {
return false
}
if date.Before(time.Now()) {
return false
}
return true
}
定义好了字段及其自定义校验方法后，就需要将它们联系起来并注册到我们的校验器实例中。
// 在校验器注册自定义的校验方法
if err := v.RegisterValidation("checkDate", customFunc); err != nil {
return err
}
这样，我们就可以对请求参数中date字段执行自定义的checkDate进行校验了。 我们发送如下请求测试一下：
此时得到的响应结果是：
{
"msg": {
"date": "Key: 'SignUpParam.date' Error:Field validation for 'date' failed on the 'checkDate' tag"
}
}
这…自定义字段级别的校验方法的错误提示信息很“简单粗暴”，和我们上面的中文提示风格有出入，必须想办法搞定它呀！
自定义翻译方法
我们现在需要为自定义字段校验方法提供一个自定义的翻译方法，从而实现该字段错误提示信息的自定义显示。
// registerTranslator 为自定义字段添加翻译功能
func registerTranslator(tag string, msg string) validator.RegisterTranslationsFunc {
return func(trans ut.Translator) error {
if err := trans.Add(tag, msg, false); err != nil {
return err
}
return nil
}
}
// translate 自定义字段的翻译方法
func translate(trans ut.Translator, fe validator.FieldError) string {
msg, err := trans.T(fe.Tag(), fe.Field())
if err != nil {
panic(fe.(error).Error())
}
return msg
}
定义好了相关翻译方法之后，我们在InitTrans函数中通过调用RegisterTranslation()方法来注册我们自定义的翻译方法。
// InitTrans 初始化翻译器
func InitTrans(locale string) (err error) {
// ...liwenzhou.com...
// 注册翻译器
switch locale {
case "en":
err = enTranslations.RegisterDefaultTranslations(v, trans)
case "zh":
err = zhTranslations.RegisterDefaultTranslations(v, trans)
default:
err = enTranslations.RegisterDefaultTranslations(v, trans)
}
if err != nil {
return err
}
// 注意！因为这里会使用到trans实例
// 所以这一步注册要放到trans初始化的后面
if err := v.RegisterTranslation(
"checkDate",
trans,
registerTranslator("checkDate", "{0}必须要晚于当前日期"),
translate,
); err != nil {
return err
}
return
}
return
}
这样再次尝试发送请求，就能得到想要的错误提示信息了。
{
"msg": {
"date": "date必须要晚于当前日期"
}
}
运行多个服务
我们可以在多个端口启动服务，例如：
package main
import (
"log"
"net/http"
"time"
"github.com/gin-gonic/gin"
"golang.org/x/sync/errgroup"
)
var (
g errgroup.Group
)
func router01() http.Handler {
e := gin.New()
e.Use(gin.Recovery())
e.GET("/", func(c *gin.Context) {
c.JSON(
http.StatusOK,
gin.H{
"code": http.StatusOK,
"error": "Welcome server 01",
},
)
})
return e
}
func router02() http.Handler {
e := gin.New()
e.Use(gin.Recovery())
e.GET("/", func(c *gin.Context) {
c.JSON(
http.StatusOK,
gin.H{
"code": http.StatusOK,
"error": "Welcome server 02",
},
)
})
return e
}
func main() {
server01 := &http.Server{
Addr: ":8080",
Handler: router01(),
ReadTimeout: 5 * time.Second,
WriteTimeout: 10 * time.Second,
}
server02 := &http.Server{
Addr: ":8081",
Handler: router02(),
ReadTimeout: 5 * time.Second,
WriteTimeout: 10 * time.Second,
}
// 借助errgroup.Group或者自行开启两个goroutine分别启动两个服务
g.Go(func() error {
return server01.ListenAndServe()
})
g.Go(func() error {
return server02.ListenAndServe()
})
if err := g.Wait(); err != nil {
log.Fatal(err)
}
}
测试
net/http/httptest包是http测试的首选方式
package main
func setupRouter() *gin.Engine {
r := gin.Default()
r.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
return r
}
func main() {
r := setupRouter()
r.Run(":8080")
}
测试上面的示例代码
package main
import (
"net/http"
"net/http/httptest"
"testing"
"github.com/stretchr/testify/assert"
)
func TestPingRoute(t *testing.T) {
router := setupRouter()
w := httptest.NewRecorder()
req, _ := http.NewRequest("GET", "/ping", nil)
router.ServeHTTP(w, req)
assert.Equal(t, 200, w.Code)
assert.Equal(t, "pong", w.Body.String())
}
优雅重启或停止
想要优雅地重启或停止你的Web服务器，使用下面的方法
我们可以使用fvbock/endless来替换默认的ListenAndServe，有关详细信息，请参阅问题＃296
router := gin.Default()
router.GET("/", handler)
// [...]
endless.ListenAndServe(":4242", router)
写日志文件
func main() {
// 禁用控制台颜色
gin.DisableConsoleColor()
// 创建记录日志的文件
f, _ := os.Create("gin.log")
gin.DefaultWriter = io.MultiWriter(f)
// 如果需要将日志同时写入文件和控制台，请使用以下代码
// gin.DefaultWriter = io.MultiWriter(f, os.Stdout)
router := gin.Default()
router.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
router.Run(":8080")
}
自定义日志格式
func main() {
router := gin.New()
// LoggerWithFormatter 中间件会将日志写入 gin.DefaultWriter
// By default gin.DefaultWriter = os.Stdout
router.Use(gin.LoggerWithFormatter(func(param gin.LogFormatterParams) string {
// 你的自定义格式
return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",
param.ClientIP,
param.TimeStamp.Format(time.RFC1123),
param.Method,
param.Path,
param.Request.Proto,
param.StatusCode,
param.Latency,
param.Request.UserAgent(),
param.ErrorMessage,
)
}))
router.Use(gin.Recovery())
router.GET("/ping", func(c *gin.Context) {
c.String(200, "pong")
})
router.Run(":8080")
}
输出示例：
::1 - [Tue, 21 Jun 2022 16:02:08 CST] "GET /ping HTTP/1.1 200 0s "PostmanRuntime/7.29.0" "
自定义路由日志的格式
默认的路由日志是这样的：
[GIN-debug] POST /foo --> main.main.func1 (3 handlers)
[GIN-debug] GET /bar --> main.main.func2 (3 handlers)
[GIN-debug] GET /status --> main.main.func3 (3 handlers)
如果你想以给定的格式记录这些信息（例如 JSON，键值对或其他格式），你可以使用gin.DebugPrintRouteFunc来定义格式，在下面的示例中，我们使用标准日志包记录路由日志，你可以使用其他适合你需求的日志工具
import (
"log"
"net/http"
"github.com/gin-gonic/gin"
)
func main() {
r := gin.Default()
gin.DebugPrintRouteFunc = func(httpMethod, absolutePath, handlerName string, nuHandlers int) {
log.Printf("endpoint %v %v %v %v\n", httpMethod, absolutePath, handlerName, nuHandlers)
}
r.POST("/foo", func(c *gin.Context) {
c.JSON(http.StatusOK, "foo")
})
r.GET("/bar", func(c *gin.Context) {
c.JSON(http.StatusOK, "bar")
})
r.GET("/status", func(c *gin.Context) {
c.JSON(http.StatusOK, "ok")
})
// Listen and Server in http://0.0.0.0:8080
r.Run()
}
Gin框架使用jwt
JWT全称JSON Web Token是一种跨域认证解决方案，属于一个开放的标准，它规定了一种Token实现方式，目前多用于前后端分离项目和OAuth2.0业务场景下。
安装
go get github.com/dgrijalva/jwt-go
使用
Claims
我们需要定制自己的需求来决定JWT中保存哪些数据，比如我们规定在JWT中要存储userid信息，那么我们就定义一个MyClaims结构体如下：
type Claims struct {
UserId uint
jwt.StandardClaims
}
接下来还需要定义一个用于签名的字符串：
var jwtKey = []byte("a_secret_crect")
生成jwt
func ReleaseToken(user model.User) (string, error) {
// 定义过期时间
expirationTime := time.Now().Add(7 * 24 * time.Hour)
claims := &Claims{
UserId: user.ID, // 自定义字段
StandardClaims: jwt.StandardClaims{
ExpiresAt: expirationTime.Unix(),
IssuedAt: time.Now().Unix(),
Issuer: "cbx",
Subject: "user token",
},
}
// 使用指定的签名方法创建签名对象
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
// 使用指定的secret签名并获得完整的编码后的字符串token
tokenString, err := token.SignedString(jwtKey)
if err != nil {
return "", err
}
return tokenString, nil
}
解析JWT
根据给定的 JWT 字符串，解析出数据。
func ParseToken(tokenString string) (*jwt.Token, *Claims, error) {
claims := &Claims{}
// 解析token
// 如果是自定义Claim结构体则需要使用 ParseWithClaims 方法
// 直接使用标准的Claim则可以直接使用Parse方法
//token, err := jwt.Parse(tokenString, func(token *jwt.Token) (i interface{}, err error) {
token, err := jwt.ParseWithClaims(tokenString, claims, func(token *jwt.Token) (interface{}, error) {
return jwtKey, nil
})
return token, claims, err
}
在gin框架中使用JWT
首先我们注册路由
UserController.Login定义如下：
func (u UserController) Login(ctx *gin.Context) {
// 接收前端传过来的手机号密码
var requestUser = model.User{}
ctx.Bind(&requestUser)
telephone := requestUser.Telephone
// 数据验证
if len(telephone) != 11 {
response.Response(ctx, http.StatusUnprocessableEntity, 422, nil, "手机号必须为11位")
return
}
// 将登录的user实体传到持久层的Login方法中
token, err := u.Repository.Login(requestUser)
if err != nil {
response.Fail(ctx, gin.H{"err": err.Error()}, "登陆失败")
return
}
// 返回结果
response.Success(ctx, gin.H{"token": token}, "登陆成功")
}
Repository.Login的定义如下
func (u UserRepository) Login(user model.User) (string, error) {
telephone := user.Telephone
password := user.Password
u.DB.Where("telephone = ?", telephone).First(&user)
if user.ID == 0 {
return "", errors.New("用户不存在")
}
// 判断密码是否正确
if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(password)); err != nil {
return "", errors.New("密码错误")
}
// 发放token
token, err := common.ReleaseToken(user)
if err != nil {
log.Printf("token generate error: %v", err)
return "", errors.New("系统异常")
}
// 返回结果
return token, nil
}
用户通过上面的接口获取Token之后，后续就会携带着Token再来请求我们的其他接口，这个时候就需要对这些请求的Token进行校验操作了，很显然我们应该实现一个检验Token的中间件，具体实现如下：
func AuthMiddleware() gin.HandlerFunc {
return func(c *gin.Context) {
// 获取authorization 头部
tokenString := c.GetHeader("Authorization")
// validate token format
if tokenString == "" || !strings.HasPrefix(tokenString, "Bearer ") {
c.JSON(http.StatusUnauthorized,gin.H{"code": 401, "msg": "权限不足"})
c.Abort()
return
}
tokenString = tokenString[7:]
token, claims, err := common.ParseToken(tokenString)
if err != nil || !token.Valid {
c.JSON(http.StatusUnauthorized,gin.H{
"code": 401,
"msg": "权限不足",
})
c.Abort()
return
}
// 验证通过后获得claim中的userId
userId := claims.UserId
DB := common.GetDB()
var user model.User
DB.First(&user,userId)
// 用户不存在
if user.ID == 0 {
c.JSON(http.StatusUnauthorized,gin.H{"code": 401, "msg": "权限不足"})
c.Abort()
return
}
// 用户存在 将user的信息写入上下文
c.Set("user",user)
c.Next()
}
}
HTTP服务压力测试工具
在项目正式上线之前，我们通常需要通过压测来评估当前系统能够支撑的请求量、排查可能存在的隐藏bug，同时了解了程序的实际处理能力能够帮我们更好的匹配项目的实际需求，节约资源成本。
压测相关术语
- 响应时间(RT) ：指系统对请求作出响应的时间.
- 吞吐量(Throughput) ：指系统在单位时间内处理请求的数量
- QPS每秒查询率(Query Per Second) ：“每秒查询率”，是一台服务器每秒能够响应的查询次数，是对一个特定的查询服务器在规定时间内所处理流量多少的衡量标准。
- TPS(TransactionPerSecond)：每秒钟系统能够处理的交易或事务的数量
- 并发连接数：某个时刻服务器所接受的请求总数
go-wrk
go-wrk是Go语言版本的wrk，Windows同学可以使用它来测试，使用如下命令来安装go-wrk：
go get github.com/adeven/go-wrk
使用方法同wrk类似，基本格式如下：
go-wrk [flags] url
常用的参数：
-H="User-Agent: go-wrk 0.1 bechmark\nContent-Type: text/html;": 由'\n'分隔的请求头
-c=100: 使用的最大连接数
-k=true: 是否禁用keep-alives
-i=false: if TLS security checks are disabled
-m="GET": HTTP请求方法
-n=1000: 请求总数
-t=1: 使用的线程数
-b="" HTTP请求体
-s="" 如果指定，它将计算响应中包含搜索到的字符串s的频率
执行测试：
go-wrk -t=8 -c=100 -n=10000 "http://127.0.0.1:8080/api/v1/posts?size=10"
输出结果：
==========================BENCHMARK==========================
URL: http://127.0.0.1:8080/api/v1/posts?size=10
Used Connections: 100
Used Threads: 8
Total number of calls: 10000
===========================TIMINGS===========================
Total time passed: 2.74s
Avg time per request: 27.11ms
Requests per second: 3644.53
Median time per request: 26.88ms
99th percentile time: 39.16ms
Slowest time for request: 45.00ms
=============================DATA=============================
Total response body sizes: 340000
Avg response body per request: 34.00 Byte
Transfer rate per second: 123914.11 Byte/s (0.12 MByte/s)
==========================RESPONSES==========================
20X Responses: 10000 (100.00%)
30X Responses: 0 (0.00%)
40X Responses: 0 (0.00%)
50X Responses: 0 (0.00%)
Errors: 0 (0.00%)