今天和大家分享一下使用 GoFrame 的 gtoken 替换 jwt 实现 sso 登录的经验，为了让大家更好的理解会带大家读一下重点的源码。
jwt 的问题
首先说明一个 jwt 存在的问题，也就是要替换 jwt 的原因：
1.jwt 无法在服务端主动退出的问题
2.jwt 无法作废已颁布的令牌，只能等到令牌过期问题
3.jwt 携带大量用户扩展信息导致降低传输效率问题
jwt 的请求流程图

gtoken 的优势
gtoken 的请求流程和 jwt 的基本一致。
gtoken 的优势就是能帮助我们解决 jwt 的问题，另外还提供好用的特性，比如：
1.gtoken 支持单点应用使用内存存储，支持个人项目文件存储，也支持企业集群使用 redis 存储，完全适用于个人和企业生产级使用；
2.有效的避免了 jwt 服务端无法退出问题；
3.解决 jwt 无法作废已颁布的令牌，只能等到令牌过期问题；
4.通过用户扩展信息存储在服务端，有效规避了 jwt 携带大量用户扩展信息导致降低传输效率问题；
5.有效避免 jwt 需要客户端实现续签功能，增加客户端复杂度；支持服务端自动续期，客户端不需要关心续签逻辑；

注意问题
1.支持服务端缓存自动续期功能，不需要通过 refresh_token 刷新 token，简化了客户端的操作
2.版本问题千万注意：在gtoken v1.5.0全面适配 GoFrame v2.0.0 ; GoFrame v1.X.X 请使用 GfToken v1.4.X 相关版本
TIPS:下面我的演示 demo 和源码阅读都是基于 v1.4.x 版本的。

演示 demo
下面的演示 demo 可以复制到本地 main.go 文件中执行，更新依赖的时候千万注意版本。
重点说一下踩的坑，Login 方法会要求我们返回两个值：
第一个值对应 userKey，后续我们可以根据 userKey 获得 token
第二个值对应 data，是 interface{}类型，我们可以在这里定义例如 userid、username 等数据。

先有这个概念即可，为了让大家更好的理解，文章最后会带大家读源码。

入门示例
代码段的关键逻辑，已经添加了注释。

package main

import (
   "github.com/goflyfox/gtoken/gtoken"
   "github.com/gogf/gf/frame/g"
   "github.com/gogf/gf/net/ghttp"
   "github.com/gogf/gf/os/glog"
)

var TestServerName string

//var TestServerName string = "gtoken"

func main() {
   glog.Info("########service start...")

   g.Cfg().SetPath("example/sample")
   s := g.Server(TestServerName)
   initRouter(s)

   glog.Info("########service finish.")
   s.Run()
}

var gfToken *gtoken.GfToken

/*
统一路由注册
*/
func initRouter(s *ghttp.Server) {
   // 不认证接口
   s.Group("/", func(group *ghttp.RouterGroup) {
      group.Middleware(CORS)

      // 调试路由
      group.ALL("/hello", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("hello"))
      })
   })

   // 认证接口
   loginFunc := Login
   // 启动gtoken
   gfToken := &gtoken.GfToken{
      ServerName:       TestServerName,
      LoginPath:        "/login",
      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"),
   }
   s.Group("/", func(group *ghttp.RouterGroup) {
      group.Middleware(CORS)
      gfToken.Middleware(group)

      group.ALL("/system/user", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("system user"))
      })
      group.ALL("/user/data", func(r *ghttp.Request) {
         r.Response.WriteJson(gfToken.GetTokenData(r))
      })
      group.ALL("/user/info", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("user info"))
      })
      group.ALL("/system/user/info", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("system user info"))
      })
   })

   // 启动gtoken
   gfAdminToken := &gtoken.GfToken{
      ServerName: TestServerName,
      //Timeout:         10 * 1000,
      LoginPath:        "/login",
      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"),
   }
   s.Group("/admin", func(group *ghttp.RouterGroup) {
      group.Middleware(CORS)
      gfAdminToken.Middleware(group)

      group.ALL("/system/user", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("system user"))
      })
      group.ALL("/user/info", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("user info"))
      })
      group.ALL("/system/user/info", func(r *ghttp.Request) {
         r.Response.WriteJson(gtoken.Succ("system user info"))
      })
   })
}

func Login(r *ghttp.Request) (string, interface{}) {
   username := r.GetString("username")
   passwd := r.GetString("passwd")

   if username == "" || passwd == "" {
      r.Response.WriteJson(gtoken.Fail("账号或密码错误."))
      r.ExitAll()
   }

   return username, "1"
   /**
   返回的第一个参数对应：userKey
   返回的第二个参数对应：data
   {
       "code": 0,
       "msg": "success",
       "data": {
           "createTime": 1652838582190,
           "data": "1",
           "refreshTime": 1653270582190,
           "userKey": "王中阳",
           "uuid": "ac75676efeb906f9959cf35f779a1d38"
       }
   }
   */
}

// 跨域
func CORS(r *ghttp.Request) {
   r.Response.CORSDefault()
   r.Middleware.Next()
}

运行效果

启动项目：

访问不认证接口：返回成功

未登录时访问认证接口：返回错误提示

请求登录接口：返回 token

携带 token 再次访问认证接口：返回成功

以上就跑通了主体流程，就是这么简单。

分析源码

tips:下面带大家看的是 v1.4.1

下面带大家分析一下源码，学习一下作者是如何设计的。

刷新 token

首先我认为 gtoken 很好的设计思想是不使用 refresh_token 来刷新 token，而是服务端主动刷新。在源码的getToken方法中做了更新 refreshTime 和 createTime 的处理。更新 createTime 为当前时间，refreshTime 为当前时间+自定义的刷新时间。

如下图所示，getToken方法在每次执行validToken校验 token 的时候都会调用，即每次校验 token 有效性时，如果符合刷新 token 有效期的条件，就会进行刷新操作(刷新 token 的过期时间，token 值不变)

这样就实现了无感刷新 token。

GfToken 结构体
我们再来看一下 GfToken 的结构体，更好的理解一下作者的设计思路：
1.因为 CacheMode 支持 redis，也就意味着支持集群模式。
2.我们在启动 gtoken 的时候，只需要设置登录和登出路径，另外登录和登出都提供了BeforeFunc和AfterFunc，让我们能清晰的界定使用场景。

// GfToken gtoken结构体
type GfToken struct {
   // GoFrame server name
   ServerName string
   // 缓存模式 1 gcache 2 gredis 默认1
   CacheMode int8
   // 缓存key
   CacheKey string
   // 超时时间 默认10天（毫秒）
   Timeout int
   // 缓存刷新时间 默认为超时时间的一半（毫秒）
   MaxRefresh int
   // Token分隔符
   TokenDelimiter string
   // Token加密key
   EncryptKey []byte
   // 认证失败中文提示
   AuthFailMsg string
   // 是否支持多端登录，默认false
   MultiLogin bool
   // 是否是全局认证，兼容历史版本，已废弃
   GlobalMiddleware bool
   // 中间件类型 1 GroupMiddleware 2 BindMiddleware  3 GlobalMiddleware
   MiddlewareType uint

   // 登录路径
   LoginPath string
   // 登录验证方法 return userKey 用户标识 如果userKey为空，结束执行
   LoginBeforeFunc func(r *ghttp.Request) (string, interface{})
   // 登录返回方法
   LoginAfterFunc func(r *ghttp.Request, respData Resp)
   // 登出地址
   LogoutPath string
   // 登出验证方法 return true 继续执行，否则结束执行
   LogoutBeforeFunc func(r *ghttp.Request) bool
   // 登出返回方法
   LogoutAfterFunc func(r *ghttp.Request, respData Resp)

   // 拦截地址
   AuthPaths g.SliceStr
   // 拦截排除地址
   AuthExcludePaths g.SliceStr
   // 认证验证方法 return true 继续执行，否则结束执行
   AuthBeforeFunc func(r *ghttp.Request) bool
   // 认证返回方法
   AuthAfterFunc func(r *ghttp.Request, respData Resp)
}

思考题
我有 N 个子系统如何用 gtoken 实现 sso 登录呢？即实现一个子系统登录，其他各个子系统都自动登录，而无需二次登录呢？

想一想
.
.
.
我想到的解决方案是配合 cookie 实现：各个子系统二级域名不一致，但是主域名一致。
我在登录之后把 token 写入主域名的 cookie 中进行共享，前端网站通过 cookie 获得 token 请求服务接口。
同时在刷新 token 之后，也要刷新 cookie 的有效期，避免 cookie 失效导致获取不到 token。
进一步阅读源码
在经过又一次仔细阅读源码之后，找到了刷新 cookie 有效期的合适场景：AuthAfterFunc，我们可以重写这个方法，来实现验证通过后的操作：
如果 token 验证有效则刷新 cookie 有效期；如果验证无效则自定义返回信息。（往往我们自己项目中的 code 码和 gtoken 定义的不一致，但是 gtoken 支持非常方便的重写返回值）

总结
我们项目之前是使用 jwt 实现 sso 登录，在刚刚拿到需求要重写时，自己也是一头雾水。
在没有认真阅读 gtoken 源码之前，我已经设计了 refresh_token 刷新的策略。
在仔细阅读源码之后，发现真香。
这次经历最大的收获是：碰到不好解决的问题时，带着问题去阅读源码是非常高效的方式。