update v2 add ctx

example/sample/main.go

@@ -1,9 +1,11 @@
 package main
 
 import (
+	"context"
 	"github.com/goflyfox/gtoken/gtoken"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/gogf/gf/v2/os/gcfg"
 )
 
 var TestServerName string
@@ -11,13 +13,18 @@ var TestServerName string
 //var TestServerName string = "gtoken"
 
 func main() {
-	g.Log().Info("########service start...")
+	ctx := context.TODO()
+
+	g.Log().Info(ctx, "########service start...")
+
+	if fileConfig, ok := g.Cfg().GetAdapter().(*gcfg.AdapterFile); ok {
+		fileConfig.SetPath("example/sample")
+	}
 
-	g.Cfg().SetPath("example/sample")
 	s := g.Server(TestServerName)
 	initRouter(s)
 
-	g.Log().Info("########service finish.")
+	g.Log().Info(ctx, "########service finish.")
 	s.Run()
 }
 
@@ -28,6 +35,8 @@ var gfAdminToken *gtoken.GfToken
 统一路由注册
 */
 func initRouter(s *ghttp.Server) {
+	ctx := context.TODO()
+
 	// 不认证接口
 	s.Group("/", func(group *ghttp.RouterGroup) {
 		group.Middleware(CORS)
@@ -38,6 +47,10 @@ func initRouter(s *ghttp.Server) {
 		})
 	})
 
+	MultiLogin, err := g.Cfg().Get(ctx, "gToken.MultiLogin")
+	if err != nil {
+		panic(err)
+	}
 	// 认证接口
 	loginFunc := Login
 	// 启动gtoken
@@ -47,11 +60,11 @@ func initRouter(s *ghttp.Server) {
 		LoginBeforeFunc:  loginFunc,
 		LogoutPath:       "/user/logout",
 		AuthExcludePaths: g.SliceStr{"/user/info", "/system/user/info"}, // 不拦截路径 /user/info,/system/user/info,/system/user,
-		MultiLogin:       g.Config().GetBool("gToken.MultiLogin"),
+		MultiLogin:       MultiLogin.Bool(),
 	}
 	s.Group("/", func(group *ghttp.RouterGroup) {
 		group.Middleware(CORS)
-		err := gfToken.Middleware(group)
+		err := gfToken.Middleware(ctx, group)
 		if err != nil {
 			panic(err)
 		}
@@ -78,11 +91,11 @@ func initRouter(s *ghttp.Server) {
 		LoginBeforeFunc:  loginFunc,
 		LogoutPath:       "/user/logout",
 		AuthExcludePaths: g.SliceStr{"/admin/user/info", "/admin/system/user/info"}, // 不拦截路径 /user/info,/system/user/info,/system/user,
-		MultiLogin:       g.Config().GetBool("gToken.MultiLogin"),
+		MultiLogin:       MultiLogin.Bool(),
 	}
 	s.Group("/admin", func(group *ghttp.RouterGroup) {
 		group.Middleware(CORS)
-		err := gfAdminToken.Middleware(group)
+		err := gfAdminToken.Middleware(ctx, group)
 		if err != nil {
 			panic(err)
 		}
@@ -100,8 +113,8 @@ func initRouter(s *ghttp.Server) {
 }
 
 func Login(r *ghttp.Request) (string, interface{}) {
-	username := r.GetString("username")
-	passwd := r.GetString("passwd")
+	username := r.Get("username").String()
+	passwd := r.Get("passwd").String()
 
 	if username == "" || passwd == "" {
 		r.Response.WriteJson(gtoken.Fail("账号或密码错误."))

example/sample1/main.go

@@ -6,6 +6,7 @@ import (
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/gogf/gf/v2/os/gcfg"
 )
 
 var TestServerName string
@@ -16,7 +17,9 @@ func main() {
 	ctx := context.TODO()
 	g.Log().Info(ctx, "########service start...")
 
-	g.Cfg().SetPath("example/sample1")
+	if fileConfig, ok := g.Cfg().GetAdapter().(*gcfg.AdapterFile); ok {
+		fileConfig.SetPath("example/sample1")
+	}
 	s := g.Server(TestServerName)
 	initRouter(s)
 
@@ -74,7 +77,7 @@ func initRouter(s *ghttp.Server) {
 		AuthExcludePaths: g.SliceStr{"/user/info", "/system/user/info"}, // 不拦截路径 /user/info,/system/user/info,/system/user,
 		GlobalMiddleware: true,                                          // 开启全局拦截
 	}
-	err := gfToken.Start()
+	err := gfToken.Start(ctx)
 	if err != nil {
 		panic(err)
 	}

example/sample1/test/server1/server.go

@@ -1,9 +1,11 @@
 package server1
 
 import (
+	"context"
 	"github.com/goflyfox/gtoken/gtoken"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
+	"github.com/gogf/gf/v2/os/gcfg"
 )
 
 var TestServerName string
@@ -13,13 +15,17 @@ var TestServerName string
 var server *ghttp.Server
 
 func Start() {
-	g.Log().Info("########service start...")
+	ctx := context.TODO()
 
-	g.Cfg().SetPath("../config")
+	g.Log().Info(ctx, "########service start...")
+
+	if fileConfig, ok := g.Cfg().GetAdapter().(*gcfg.AdapterFile); ok {
+		fileConfig.SetPath("example/sample1")
+	}
 	server = g.Server(TestServerName)
 	initRouter(server)
 
-	g.Log().Info("########service finish.")
+	g.Log().Info(ctx, "########service finish.")
 	server.Start()
 }
 
@@ -56,18 +62,53 @@ func initRouter(s *ghttp.Server) {
 	})
 
 	loginFunc := Login
+
+	ctx := context.TODO()
+	CacheModeVar, err := g.Cfg().Get(ctx, "gToken.CacheMode")
+	if err != nil {
+		panic(err)
+	}
+	CacheKey, err := g.Cfg().Get(ctx, "gToken.CacheKey")
+	if err != nil {
+		panic(err)
+	}
+	Timeout, err := g.Cfg().Get(ctx, "gToken.Timeout")
+	if err != nil {
+		panic(err)
+	}
+	MaxRefresh, err := g.Cfg().Get(ctx, "gToken.MaxRefresh")
+	if err != nil {
+		panic(err)
+	}
+	TokenDelimiter, err := g.Cfg().Get(ctx, "gToken.TokenDelimiter")
+	if err != nil {
+		panic(err)
+	}
+	EncryptKey, err := g.Cfg().Get(ctx, "gToken.EncryptKey")
+	if err != nil {
+		panic(err)
+	}
+	AuthFailMsg, err := g.Cfg().Get(ctx, "gToken.AuthFailMsg")
+	if err != nil {
+		panic(err)
+	}
+	MultiLogin, err := g.Cfg().Get(ctx, "gToken.MultiLogin")
+	if err != nil {
+		panic(err)
+	}
+
 	// 启动gtoken
 	gfToken = &gtoken.GfToken{
 		ServerName: TestServerName,
 		//Timeout:         10 * 1000,
-		CacheMode:        g.Cfg().GetInt8("gToken.CacheMode"),
-		CacheKey:         g.Cfg().GetString("gToken.CacheKey"),
-		Timeout:          g.Cfg().GetInt("gToken.Timeout"),
-		MaxRefresh:       g.Cfg().GetInt("gToken.MaxRefresh"),
-		TokenDelimiter:   g.Cfg().GetString("gToken.TokenDelimiter"),
-		EncryptKey:       g.Cfg().GetBytes("gToken.EncryptKey"),
-		AuthFailMsg:      g.Cfg().GetString("gToken.AuthFailMsg"),
-		MultiLogin:       g.Config().GetBool("gToken.MultiLogin"),
+		CacheMode:        CacheModeVar.Int8(),
+		CacheKey:         CacheKey.String(),
+		Timeout:          Timeout.Int(),
+		MaxRefresh:       MaxRefresh.Int(),
+		TokenDelimiter:   TokenDelimiter.String(),
+		EncryptKey:       EncryptKey.Bytes(),
+		AuthFailMsg:      AuthFailMsg.String(),
+		MultiLogin:       MultiLogin.Bool(),
 		LoginPath:        "/login",
 		LoginBeforeFunc:  loginFunc,
 		LogoutPath:       "/user/logout",
@@ -75,15 +116,16 @@ func initRouter(s *ghttp.Server) {
 		AuthExcludePaths: g.SliceStr{"/user/info", "/system/user/info"}, // 不拦截路径 /user/info,/system/user/info,/system/user,
 		GlobalMiddleware: true,                                          // 开启全局拦截
 	}
-	err := gfToken.Start()
+	err = gfToken.Start(ctx)
 	if err != nil {
 		panic(err)
 	}
 }
 
 func Login(r *ghttp.Request) (string, interface{}) {
-	username := r.GetString("username")
-	passwd := r.GetString("passwd")
+
+	username := r.Get("username").String()
+	passwd := r.Get("passwd").String()
 
 	if username == "" || passwd == "" {
 		r.Response.WriteJson(gtoken.Fail("账号或密码错误."))

gtoken/gtoken.go

@@ -81,7 +81,7 @@ type GfToken struct {
 }
 
 // InitConfig 初始化配置信息
-func (m *GfToken) InitConfig() bool {
+func (m *GfToken) InitConfig(ctx context.Context) bool {
 	if m.CacheMode == 0 {
 		m.CacheMode = CacheModeCache
 	}
@@ -124,14 +124,14 @@ func (m *GfToken) InitConfig() bool {
 			if !respData.Success() {
 				err := r.Response.WriteJson(respData)
 				if err != nil {
-					g.Log().Error(err)
+					g.Log().Error(ctx, err)
 				}
 			} else {
 				err := r.Response.WriteJson(Succ(g.Map{
 					"token": respData.GetString("token"),
 				}))
 				if err != nil {
-					g.Log().Error(err)
+					g.Log().Error(ctx, err)
 				}
 			}
 		}
@@ -148,12 +148,12 @@ func (m *GfToken) InitConfig() bool {
 			if respData.Success() {
 				err := r.Response.WriteJson(Succ("Logout success"))
 				if err != nil {
-					g.Log().Error(err)
+					g.Log().Error(ctx, err)
 				}
 			} else {
 				err := r.Response.WriteJson(respData)
 				if err != nil {
-					g.Log().Error(err)
+					g.Log().Error(ctx, err)
 				}
 			}
 		}
@@ -186,12 +186,12 @@ func (m *GfToken) InitConfig() bool {
 
 				no := gconv.String(gtime.TimestampMilli())
 
-				g.Log().Warning(fmt.Sprintf("[AUTH_%s][url:%s][params:%s][data:%s]",
+				g.Log().Warning(ctx, fmt.Sprintf("[AUTH_%s][url:%s][params:%s][data:%s]",
 					no, r.URL.Path, params, respData.Json()))
 				respData.Msg = m.AuthFailMsg
 				err := r.Response.WriteJson(respData)
 				if err != nil {
-					g.Log().Error(err)
+					g.Log().Error(ctx, err)
 				}
 				r.ExitAll()
 			}
@@ -203,7 +203,7 @@ func (m *GfToken) InitConfig() bool {
 
 // Start 启动
 func (m *GfToken) Start(ctx context.Context) error {
-	if !m.InitConfig() {
+	if !m.InitConfig(ctx) {
 		return errors.New("InitConfig fail")
 	}
 	g.Log().Info(ctx, "[GToken][params:"+m.String()+"]start... ")
@@ -253,8 +253,8 @@ func (m *GfToken) Start(ctx context.Context) error {
 }
 
 // Stop 结束
-func (m *GfToken) Stop() error {
-	g.Log().Info("[GToken]stop. ")
+func (m *GfToken) Stop(ctx context.Context) error {
+	g.Log().Info(ctx, "[GToken]stop. ")
 	return nil
 }
 
@@ -263,7 +263,7 @@ func (m *GfToken) GetTokenData(r *ghttp.Request) Resp {
 	respData := m.getRequestToken(r)
 	if respData.Success() {
 		// 验证token
-		respData = m.validToken(respData.DataString())
+		respData = m.validToken(r.Context(), respData.DataString())
 	}
 
 	return respData
@@ -280,16 +280,16 @@ func (m *GfToken) Login(r *ghttp.Request) {
 
 	if m.MultiLogin {
 		// 支持多端重复登录，返回相同token
-		userCacheResp := m.getToken(userKey)
+		userCacheResp := m.getToken(r.Context(), userKey)
 		if userCacheResp.Success() {
-			respToken := m.EncryptToken(userKey, userCacheResp.GetString("uuid"))
+			respToken := m.EncryptToken(r.Context(), userKey, userCacheResp.GetString("uuid"))
 			m.LoginAfterFunc(r, respToken)
 			return
 		}
 	}
 
 	// 生成token
-	respToken := m.genToken(userKey, data)
+	respToken := m.genToken(r.Context(), userKey, data)
 	m.LoginAfterFunc(r, respToken)
 
 }
@@ -301,7 +301,7 @@ func (m *GfToken) Logout(r *ghttp.Request) {
 		respData := m.getRequestToken(r)
 		if respData.Success() {
 			// 删除token
-			m.RemoveToken(respData.DataString())
+			m.RemoveToken(r.Context(), respData.DataString())
 		}
 
 		m.LogoutAfterFunc(r, respData)
@@ -311,7 +311,7 @@ func (m *GfToken) Logout(r *ghttp.Request) {
 // AuthMiddleware 认证拦截
 func (m *GfToken) authMiddleware(r *ghttp.Request) {
 	urlPath := r.URL.Path
-	if !m.AuthPath(urlPath) {
+	if !m.AuthPath(r.Context(), urlPath) {
 		// 如果不需要认证，继续
 		r.Middleware.Next()
 		return
@@ -327,7 +327,7 @@ func (m *GfToken) authMiddleware(r *ghttp.Request) {
 	tokenResp := m.getRequestToken(r)
 	if tokenResp.Success() {
 		// 验证token
-		tokenResp = m.validToken(tokenResp.DataString())
+		tokenResp = m.validToken(r.Context(), tokenResp.DataString())
 	}
 
 	m.AuthAfterFunc(r, tokenResp)
@@ -336,7 +336,7 @@ func (m *GfToken) authMiddleware(r *ghttp.Request) {
 
 // AuthPath 判断路径是否需要进行认证拦截
 // return true 需要认证
-func (m *GfToken) AuthPath(urlPath string) bool {
+func (m *GfToken) AuthPath(ctx context.Context, urlPath string) bool {
 	// 去除后斜杠
 	if strings.HasSuffix(urlPath, "/") {
 		urlPath = gstr.SubStr(urlPath, 0, len(urlPath)-1)
@@ -400,17 +400,17 @@ func (m *GfToken) getRequestToken(r *ghttp.Request) Resp {
 	if authHeader != "" {
 		parts := strings.SplitN(authHeader, " ", 2)
 		if !(len(parts) == 2 && parts[0] == "Bearer") {
-			g.Log().Warning("[GToken]authHeader:" + authHeader + " get token key fail")
+			g.Log().Warning(r.Context(), "[GToken]authHeader:"+authHeader+" get token key fail")
 			return Unauthorized("get token key fail", "")
 		} else if parts[1] == "" {
-			g.Log().Warning("[GToken]authHeader:" + authHeader + " get token fail")
+			g.Log().Warning(r.Context(), "[GToken]authHeader:"+authHeader+" get token fail")
 			return Unauthorized("get token fail", "")
 		}
 
 		return Succ(parts[1])
 	}
 
-	authHeader = r.GetString("token")
+	authHeader = r.Get("token").String()
 	if authHeader == "" {
 		return Unauthorized("query token fail", "")
 	}
@@ -419,8 +419,8 @@ func (m *GfToken) getRequestToken(r *ghttp.Request) Resp {
 }
 
 // genToken 生成Token
-func (m *GfToken) genToken(userKey string, data interface{}) Resp {
-	token := m.EncryptToken(userKey, "")
+func (m *GfToken) genToken(ctx context.Context, userKey string, data interface{}) Resp {
+	token := m.EncryptToken(ctx, userKey, "")
 	if !token.Success() {
 		return token
 	}
@@ -434,7 +434,7 @@ func (m *GfToken) genToken(userKey string, data interface{}) Resp {
 		"refreshTime": gtime.Now().TimestampMilli() + gconv.Int64(m.MaxRefresh),
 	}
 
-	cacheResp := m.setCache(cacheKey, userCache)
+	cacheResp := m.setCache(ctx, cacheKey, userCache)
 	if !cacheResp.Success() {
 		return cacheResp
 	}
@@ -443,12 +443,12 @@ func (m *GfToken) genToken(userKey string, data interface{}) Resp {
 }
 
 // validToken 验证Token
-func (m *GfToken) validToken(token string) Resp {
+func (m *GfToken) validToken(ctx context.Context, token string) Resp {
 	if token == "" {
 		return Unauthorized("valid token empty", "")
 	}
 
-	decryptToken := m.DecryptToken(token)
+	decryptToken := m.DecryptToken(ctx, token)
 	if !decryptToken.Success() {
 		return decryptToken
 	}
@@ -456,13 +456,13 @@ func (m *GfToken) validToken(token string) Resp {
 	userKey := decryptToken.GetString("userKey")
 	uuid := decryptToken.GetString("uuid")
 
-	userCacheResp := m.getToken(userKey)
+	userCacheResp := m.getToken(ctx, userKey)
 	if !userCacheResp.Success() {
 		return userCacheResp
 	}
 
 	if uuid != userCacheResp.GetString("uuid") {
-		g.Log().Error("[GToken]user auth error, decryptToken:" + decryptToken.Json() + " cacheValue:" + gconv.String(userCacheResp.Data))
+		g.Log().Error(ctx, "[GToken]user auth error, decryptToken:"+decryptToken.Json()+" cacheValue:"+gconv.String(userCacheResp.Data))
 		return Unauthorized("user auth error", "")
 	}
 
@@ -470,10 +470,10 @@ func (m *GfToken) validToken(token string) Resp {
 }
 
 // getToken 通过userKey获取Token
-func (m *GfToken) getToken(userKey string) Resp {
+func (m *GfToken) getToken(ctx context.Context, userKey string) Resp {
 	cacheKey := m.CacheKey + userKey
 
-	userCacheResp := m.getCache(cacheKey)
+	userCacheResp := m.getCache(ctx, cacheKey)
 	if !userCacheResp.Success() {
 		return userCacheResp
 	}
@@ -486,26 +486,26 @@ func (m *GfToken) getToken(userKey string) Resp {
 	if gconv.Int64(refreshTime) == 0 || nowTime > gconv.Int64(refreshTime) {
 		userCache["createTime"] = gtime.Now().TimestampMilli()
 		userCache["refreshTime"] = gtime.Now().TimestampMilli() + gconv.Int64(m.MaxRefresh)
-		g.Log().Debug("[GToken]refreshToken:" + gconv.String(userCache))
-		return m.setCache(cacheKey, userCache)
+		g.Log().Debug(ctx, "[GToken]refreshToken:"+gconv.String(userCache))
+		return m.setCache(ctx, cacheKey, userCache)
 	}
 
 	return Succ(userCache)
 }
 
 // RemoveToken 删除Token
-func (m *GfToken) RemoveToken(token string) Resp {
-	decryptToken := m.DecryptToken(token)
+func (m *GfToken) RemoveToken(ctx context.Context, token string) Resp {
+	decryptToken := m.DecryptToken(ctx, token)
 	if !decryptToken.Success() {
 		return decryptToken
 	}
 
 	cacheKey := m.CacheKey + decryptToken.GetString("userKey")
-	return m.removeCache(cacheKey)
+	return m.removeCache(ctx, cacheKey)
 }
 
 // EncryptToken token加密方法
-func (m *GfToken) EncryptToken(userKey string, uuid string) Resp {
+func (m *GfToken) EncryptToken(ctx context.Context, userKey string, uuid string) Resp {
 	if userKey == "" {
 		return Fail("encrypt userKey empty")
 	}
@@ -514,7 +514,7 @@ func (m *GfToken) EncryptToken(userKey string, uuid string) Resp {
 		// 重新生成uuid
 		newUuid, err := gmd5.Encrypt(grand.Letters(10))
 		if err != nil {
-			g.Log().Error("[GToken]uuid error", err)
+			g.Log().Error(ctx, "[GToken]uuid error", err)
 			return Error("uuid error")
 		}
 		uuid = newUuid
@@ -524,7 +524,7 @@ func (m *GfToken) EncryptToken(userKey string, uuid string) Resp {
 
 	token, err := gaes.Encrypt([]byte(tokenStr), m.EncryptKey)
 	if err != nil {
-		g.Log().Error("[GToken]encrypt error token:", tokenStr, err)
+		g.Log().Error(ctx, "[GToken]encrypt error token:", tokenStr, err)
 		return Error("encrypt error")
 	}
 
@@ -536,24 +536,24 @@ func (m *GfToken) EncryptToken(userKey string, uuid string) Resp {
 }
 
 // DecryptToken token解密方法
-func (m *GfToken) DecryptToken(token string) Resp {
+func (m *GfToken) DecryptToken(ctx context.Context, token string) Resp {
 	if token == "" {
 		return Fail("decrypt token empty")
 	}
 
 	token64, err := gbase64.Decode([]byte(token))
 	if err != nil {
-		g.Log().Error("[GToken]decode error token:", token, err)
+		g.Log().Error(ctx, "[GToken]decode error token:", token, err)
 		return Error("decode error")
 	}
 	decryptToken, err2 := gaes.Decrypt(token64, m.EncryptKey)
 	if err2 != nil {
-		g.Log().Error("[GToken]decrypt error token:", token, err2)
+		g.Log().Error(ctx, "[GToken]decrypt error token:", token, err2)
 		return Error("decrypt error")
 	}
 	tokenArray := gstr.Split(string(decryptToken), m.TokenDelimiter)
 	if len(tokenArray) < 2 {
-		g.Log().Error("[GToken]token len error token:", token)
+		g.Log().Error(ctx, "[GToken]token len error token:", token)
 		return Error("token len error")
 	}
 

gtoken/gtoken_cache.go

@@ -1,6 +1,7 @@
 package gtoken
 
 import (
+	"context"
 	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcache"
@@ -9,19 +10,19 @@ import (
 )
 
 // setCache 设置缓存
-func (m *GfToken) setCache(cacheKey string, userCache g.Map) Resp {
+func (m *GfToken) setCache(ctx context.Context, cacheKey string, userCache g.Map) Resp {
 	switch m.CacheMode {
 	case CacheModeCache:
-		gcache.Set(cacheKey, userCache, gconv.Duration(m.Timeout)*time.Millisecond)
+		gcache.Set(ctx, cacheKey, userCache, gconv.Duration(m.Timeout)*time.Millisecond)
 	case CacheModeRedis:
 		cacheValueJson, err1 := gjson.Encode(userCache)
 		if err1 != nil {
-			g.Log().Error("[GToken]cache json encode error", err1)
+			g.Log().Error(ctx, "[GToken]cache json encode error", err1)
 			return Error("cache json encode error")
 		}
-		_, err := g.Redis().Do("SETEX", cacheKey, m.Timeout/1000, cacheValueJson)
+		_, err := g.Redis().Do(ctx, "SETEX", cacheKey, m.Timeout/1000, cacheValueJson)
 		if err != nil {
-			g.Log().Error("[GToken]cache set error", err)
+			g.Log().Error(ctx, "[GToken]cache set error", err)
 			return Error("cache set error")
 		}
 	default:
@@ -32,13 +33,13 @@ func (m *GfToken) setCache(cacheKey string, userCache g.Map) Resp {
 }
 
 // getCache 获取缓存
-func (m *GfToken) getCache(cacheKey string) Resp {
+func (m *GfToken) getCache(ctx context.Context, cacheKey string) Resp {
 	var userCache g.Map
 	switch m.CacheMode {
 	case CacheModeCache:
-		userCacheValue, err := gcache.Get(cacheKey)
+		userCacheValue, err := gcache.Get(ctx, cacheKey)
 		if err != nil {
-			g.Log().Error("[GToken]cache get error", err)
+			g.Log().Error(ctx, "[GToken]cache get error", err)
 			return Error("cache get error")
 		}
 		if userCacheValue == nil {
@@ -46,9 +47,9 @@ func (m *GfToken) getCache(cacheKey string) Resp {
 		}
 		userCache = gconv.Map(userCacheValue)
 	case CacheModeRedis:
-		userCacheJson, err := g.Redis().Do("GET", cacheKey)
+		userCacheJson, err := g.Redis().Do(ctx, "GET", cacheKey)
 		if err != nil {
-			g.Log().Error("[GToken]cache get error", err)
+			g.Log().Error(ctx, "[GToken]cache get error", err)
 			return Error("cache get error")
 		}
 		if userCacheJson == nil {
@@ -57,7 +58,7 @@ func (m *GfToken) getCache(cacheKey string) Resp {
 
 		err = gjson.DecodeTo(userCacheJson, &userCache)
 		if err != nil {
-			g.Log().Error("[GToken]cache get json error", err)
+			g.Log().Error(ctx, "[GToken]cache get json error", err)
 			return Error("cache get json error")
 		}
 	default:
@@ -68,18 +69,18 @@ func (m *GfToken) getCache(cacheKey string) Resp {
 }
 
 // removeCache 删除缓存
-func (m *GfToken) removeCache(cacheKey string) Resp {
+func (m *GfToken) removeCache(ctx context.Context, cacheKey string) Resp {
 	switch m.CacheMode {
 	case CacheModeCache:
-		_, err := gcache.Remove(cacheKey)
+		_, err := gcache.Remove(ctx, cacheKey)
 		if err != nil {
-			g.Log().Error(err)
+			g.Log().Error(ctx, err)
 		}
 	case CacheModeRedis:
 		var err error
-		_, err = g.Redis().Do("DEL", cacheKey)
+		_, err = g.Redis().Do(ctx, "DEL", cacheKey)
 		if err != nil {
-			g.Log().Error("[GToken]cache remove error", err)
+			g.Log().Error(ctx, "[GToken]cache remove error", err)
 			return Error("cache remove error")
 		}
 	default:

gtoken/gtoken_group.go

@@ -1,34 +1,35 @@
 package gtoken
 
 import (
+	"context"
 	"errors"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/net/ghttp"
 )
 
 // Middleware 绑定group
-func (m *GfToken) Middleware(group *ghttp.RouterGroup) error {
-	if !m.InitConfig() {
+func (m *GfToken) Middleware(ctx context.Context, group *ghttp.RouterGroup) error {
+	if !m.InitConfig(ctx) {
 		return errors.New("InitConfig fail")
 	}
 
 	// 设置为Group模式
 	m.MiddlewareType = MiddlewareTypeGroup
-	g.Log().Info("[GToken][params:" + m.String() + "]start... ")
+	g.Log().Info(ctx, "[GToken][params:"+m.String()+"]start... ")
 
 	// 缓存模式
 	if m.CacheMode > CacheModeRedis {
-		g.Log().Error("[GToken]CacheMode set error")
+		g.Log().Error(ctx, "[GToken]CacheMode set error")
 		return errors.New("CacheMode set error")
 	}
 	// 登录
 	if m.LoginPath == "" || m.LoginBeforeFunc == nil {
-		g.Log().Error("[GToken]LoginPath or LoginBeforeFunc not set")
+		g.Log().Error(ctx, "[GToken]LoginPath or LoginBeforeFunc not set")
 		return errors.New("LoginPath or LoginBeforeFunc not set")
 	}
 	// 登出
 	if m.LogoutPath == "" {
-		g.Log().Error("[GToken]LogoutPath not set")
+		g.Log().Error(ctx, "[GToken]LogoutPath not set")
 		return errors.New("LogoutPath not set")
 	}
 

gtoken/gtoken_test.go

@@ -1,12 +1,15 @@
 package gtoken_test
 
 import (
+	"context"
 	"github.com/goflyfox/gtoken/gtoken"
 	"github.com/gogf/gf/v2/frame/g"
 	"testing"
 )
 
 func TestAuthPathGlobal(t *testing.T) {
+	ctx := context.Background()
+
 	t.Log("Global auth path test ")
 	// 启动gtoken
 	gfToken := &gtoken.GfToken{
@@ -17,7 +20,7 @@ func TestAuthPathGlobal(t *testing.T) {
 	}
 
 	authPath(gfToken, t)
-	flag := gfToken.AuthPath("/test")
+	flag := gfToken.AuthPath(ctx, "/test")
 	if flag {
 		t.Error("error:", "/test auth path error")
 	}
@@ -38,6 +41,8 @@ func TestBindAuthPath(t *testing.T) {
 }
 
 func TestGroupAuthPath(t *testing.T) {
+	ctx := context.Background()
+
 	t.Log("Group auth path test ")
 	// 启动gtoken
 	gfToken := &gtoken.GfToken{
@@ -47,28 +52,30 @@ func TestGroupAuthPath(t *testing.T) {
 		MiddlewareType:   gtoken.MiddlewareTypeGroup,                 // 开启组拦截
 	}
 
-	flag := gfToken.AuthPath("/login")
+	flag := gfToken.AuthPath(ctx, "/login")
 	if flag {
 		t.Error("error:", "/login auth path error")
 	}
 
-	flag = gfToken.AuthPath("/user/info")
+	flag = gfToken.AuthPath(ctx, "/user/info")
 	if flag {
 		t.Error("error:", "/user/info auth path error")
 	}
 
-	flag = gfToken.AuthPath("/system/user/info")
+	flag = gfToken.AuthPath(ctx, "/system/user/info")
 	if flag {
 		t.Error("error:", "/system/user/info auth path error")
 	}
 
-	flag = gfToken.AuthPath("/system/test")
+	flag = gfToken.AuthPath(ctx, "/system/test")
 	if !flag {
 		t.Error("error:", "/system/test auth path error")
 	}
 }
 
 func TestAuthPathNoExclude(t *testing.T) {
+	ctx := context.Background()
+
 	t.Log("auth no exclude path test ")
 	// 启动gtoken
 	gfToken := &gtoken.GfToken{
@@ -78,23 +85,25 @@ func TestAuthPathNoExclude(t *testing.T) {
 	}
 
 	authFlag := gfToken.AuthPath
-	if authFlag("/test") {
-		t.Error("error:", "/test auth path error")
+	if authFlag(ctx, "/test") {
+		t.Error(ctx, "error:", "/test auth path error")
 	}
-	if !authFlag("/system/dept") {
-		t.Error("error:", "/system/dept auth path error")
+	if !authFlag(ctx, "/system/dept") {
+		t.Error(ctx, "error:", "/system/dept auth path error")
 	}
 
-	if !authFlag("/user/info") {
-		t.Error("error:", "/user/info auth path error")
+	if !authFlag(ctx, "/user/info") {
+		t.Error(ctx, "error:", "/user/info auth path error")
 	}
 
-	if !authFlag("/system/user") {
-		t.Error("error:", "/system/user auth path error")
+	if !authFlag(ctx, "/system/user") {
+		t.Error(ctx, "error:", "/system/user auth path error")
 	}
 }
 
 func TestAuthPathExclude(t *testing.T) {
+	ctx := context.Background()
+
 	t.Log("auth path test ")
 	// 启动gtoken
 	gfToken := &gtoken.GfToken{
@@ -105,54 +114,56 @@ func TestAuthPathExclude(t *testing.T) {
 	}
 
 	authFlag := gfToken.AuthPath
-	if !authFlag("/test") {
+	if !authFlag(ctx, "/test") {
 		t.Error("error:", "/test auth path error")
 	}
-	if !authFlag("//system/dept") {
+	if !authFlag(ctx, "//system/dept") {
 		t.Error("error:", "/system/dept auth path error")
 	}
 
-	if authFlag("/user/info") {
+	if authFlag(ctx, "/user/info") {
 		t.Error("error:", "/user/info auth path error")
 	}
 
-	if authFlag("/system/user") {
+	if authFlag(ctx, "/system/user") {
 		t.Error("error:", "/system/user auth path error")
 	}
 
-	if authFlag("/system/user/info") {
+	if authFlag(ctx, "/system/user/info") {
 		t.Error("error:", "/system/user/info auth path error")
 	}
 
 }
 
 func authPath(gfToken *gtoken.GfToken, t *testing.T) {
-	flag := gfToken.AuthPath("/user/info")
+	ctx := context.Background()
+
+	flag := gfToken.AuthPath(ctx, "/user/info")
 	if flag {
 		t.Error("error:", "/user/info auth path error")
 	}
 
-	flag = gfToken.AuthPath("/system/user")
+	flag = gfToken.AuthPath(ctx, "/system/user")
 	if flag {
 		t.Error("error:", "/system/user auth path error")
 	}
 
-	flag = gfToken.AuthPath("/system/user/info")
+	flag = gfToken.AuthPath(ctx, "/system/user/info")
 	if flag {
 		t.Error("error:", "/system/user/info auth path error")
 	}
 
-	flag = gfToken.AuthPath("/system/dept")
+	flag = gfToken.AuthPath(ctx, "/system/dept")
 	if !flag {
 		t.Error("error:", "/system/dept auth path error")
 	}
 
-	flag = gfToken.AuthPath("/user/list")
+	flag = gfToken.AuthPath(ctx, "/user/list")
 	if !flag {
 		t.Error("error:", "/user/list auth path error")
 	}
 
-	flag = gfToken.AuthPath("/user/add")
+	flag = gfToken.AuthPath(ctx, "/user/add")
 	if !flag {
 		t.Error("error:", "/user/add auth path error")
 	}
@@ -160,17 +171,19 @@ func authPath(gfToken *gtoken.GfToken, t *testing.T) {
 
 func TestEncryptDecryptToken(t *testing.T) {
 	t.Log("encrypt and decrypt token test ")
+	ctx := context.Background()
+
 	gfToken := gtoken.GfToken{}
-	gfToken.InitConfig()
+	gfToken.InitConfig(ctx)
 
 	userKey := "123123"
-	token := gfToken.EncryptToken(userKey, "")
+	token := gfToken.EncryptToken(ctx, userKey, "")
 	if !token.Success() {
 		t.Error(token.Json())
 	}
 	t.Log(token.DataString())
 
-	token2 := gfToken.DecryptToken(token.GetString("token"))
+	token2 := gfToken.DecryptToken(ctx, token.GetString("token"))
 	if !token2.Success() {
 		t.Error(token2.Json())
 	}
@@ -186,18 +199,20 @@ func TestEncryptDecryptToken(t *testing.T) {
 
 func BenchmarkEncryptDecryptToken(b *testing.B) {
 	b.Log("encrypt and decrypt token test ")
+
+	ctx := context.Background()
 	gfToken := gtoken.GfToken{}
-	gfToken.InitConfig()
+	gfToken.InitConfig(ctx)
 
 	userKey := "123123"
-	token := gfToken.EncryptToken(userKey, "")
+	token := gfToken.EncryptToken(ctx, userKey, "")
 	if !token.Success() {
 		b.Error(token.Json())
 	}
 	b.Log(token.DataString())
 
 	for i := 0; i < b.N; i++ {
-		token2 := gfToken.DecryptToken(token.GetString("token"))
+		token2 := gfToken.DecryptToken(ctx, token.GetString("token"))
 		if !token2.Success() {
 			b.Error(token2.Json())
 		}