2. 程式人生 > 程式設計 >詳解Go-JWT-RESTful身份認證教程

詳解Go-JWT-RESTful身份認證教程

阿新 • • 發佈：2020-01-09

1.什麼是JWT

JWT（JSON Web Token）是一個非常輕巧的規範,這個規範允許我們使用JWT在使用者和伺服器之間傳遞安全可靠的資訊,
一個JWT由三部分組成,Header頭部、Claims載荷、Signature簽名,

JWT原理類似我們加蓋公章或手寫簽名的的過程,合同上寫了很多條款,不是隨便一張紙隨便寫啥都可以的,必須要一些證明,比如簽名,比如蓋章,JWT就是通過附加簽名,保證傳輸過來的資訊是真的,而不是偽造的,

它將使用者資訊加密到token裡,伺服器不儲存任何使用者資訊,伺服器通過使用儲存的金鑰驗證token的正確性,只要正確即通過驗證,

2.JWT構成

一個JWT由三部分組成,

  • Header頭部：頭部,表明型別和加密演算法
  • Claims載荷：宣告,即載荷（承載的內容）
  • Signature簽名：簽名,這一部分是將header和claims進行base64轉碼後,並用header中宣告的加密演算法加鹽(secret)後構成,即：
let tmpstr = base64(header)+base64(claims)
let signature = encrypt(tmpstr,secret)
//最後三者用"."連線,即：
let token = base64(header)+"."+base64(claims)+"."+signature

3.javascript提取JWT字串荷載資訊

JWT裡面payload可以包含很多欄位,欄位越多你的token字串就越長.
你的HTTP請求通訊的傳送的資料就越多,回到之介面響應時間等待稍稍的變長一點點.

一下程式碼就是前端javascript從payload獲取登入的使用者資訊.
當然後端middleware也可以直接解析payload獲取使用者資訊,減少到資料庫中查詢user表資料.介面速度會更快,資料庫壓力更小.
後端檢查JWT身份驗證時候當然會校驗payload和Signature簽名是否合法.

let tokenString = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1Njc3Nzc5NjIsImp0aSI6IjUiLCJpYXQiOjE1Njc2OTE1NjIsImlzcyI6ImZlbGl4Lm1vam90di5jbiIsImlkIjo1LCJjcmVhdGVkX2F0IjoiMjAxOS0wOS0wNVQxMTo1Njo1OS41NjI1NDcwODYrMDg6MDAiLCJ1cGRhdGVkX2F0IjoiMjAxOS0wOS0wNVQxNjo1ODoyMC41NTYxNjAwOTIrMDg6MDAiLCJ1c2VybmFtZSI6ImVyaWMiLCJuaWNrX25hbWUiOiIiLCJlbWFpbCI6IjEyMzQ1NkBxcS5jb20iLCJtb2JpbGUiOiIiLCJyb2xlX2lkIjo4LCJzdGF0dXMiOjAsImF2YXRhciI6Ii8vdGVjaC5tb2pvdHYuY24vYXNzZXRzL2ltYWdlL2F2YXRhcl8zLnBuZyIsInJlbWFyayI6IiIsImZyaWVuZF9pZHMiOm51bGwsImthcm1hIjowLCJjb21tZW50X2lkcyI6bnVsbH0.tGjukvuE9JVjzDa42iGfh_5jIembO5YZBZDqLnaG6KQ'
function parseTokenGetUser(jwtTokenString) {
  let base64Url = jwtTokenString.split('.')[1];
  let base64 = base64Url.replace(/-/g,'+').replace(/_/g,'/');
  let jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
    return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
  }).join(''));
  let user = JSON.parse(jsonPayload);

  localStorage.setItem("token",jwtTokenString);
  localStorage.setItem("expire_ts",user.exp);
  localStorage.setItem("user",jsonPayload);
  return user;
}
parseTokenGetUser(tokenString)

複製上面javascript程式碼到瀏覽器console中執行就可以解析出使用者資訊了! 當然你要可以使用線上工具來解析jwt token的payload荷載
JWT線上解析工具

4. go語言Gin框架實現JWT使用者認證

接下來我將使用最受歡迎的gin-gonic/gin 和 dgrijalva/jwt-go

這兩個package來演示怎麼使用JWT身份認證.

4.1 登入介面

4.1.1 登入介面路由(login-route)

https://github.com/libragen/felix/blob/master/ssh2ws/ssh2ws.go

  r := gin.New()
  r.MaxMultipartMemory = 32 << 20
  //sever static file in http's root path
  binStaticMiddleware,err := felixbin.NewGinStaticBinMiddleware("/")
  if err != nil {
    return err
  }
  //支援跨域
  mwCORS := cors.New(cors.Config{
    AllowOrigins:   []string{"*"},AllowMethods:   []string{"PUT","PATCH","POST","GET","DELETE"},AllowHeaders:   []string{"Origin","Authorization","Content-Type"},ExposeHeaders:  []string{"Content-Type"},AllowCredentials: true,AllowOriginFunc: func(origin string) bool {
      return true
    },MaxAge: 2400 * time.Hour,})
  r.Use(binStaticMiddleware,mwCORS)


  {
    r.POST("comment-login",internal.LoginCommenter)    //評論使用者登陸
    r.POST("comment-register",internal.RegisterCommenter) //評論使用者註冊
  }

  api := r.Group("api")
  api.POST("admin-login",internal.LoginAdmin) //管理後臺登陸

internal.LoginCommenter 和 internal.LoginAdmin 這兩個方法是一樣的,
只需要關注其中一個就可以了,我們就關注internal.LoginCommenter

4.1.2 登入login handler

編寫登入的handler

https://github.com/libragen/felix/blob/master/ssh2ws/internal/h_login.go

func LoginCommenter(c *gin.Context) {
  var mdl model.User
  err := c.ShouldBind(&mdl)
  if handleError(c,err) {
    return
  }
  //獲取ip
  ip := c.ClientIP()
  //roleId 8 是評論系統的使用者
  data,err := mdl.Login(ip,8)
  if handleError(c,err) {
    return
  }
  jsonData(c,data)
}

其中最關鍵的是mdl.Login(ip,8)這個函式
https://github.com/libragen/felix/blob/master/model/m_users.go

  • 1.資料庫查詢使用者
  • 2.校驗使用者role_id
  • 3.比對密碼
  • 4.防止密碼洩露(清空struct的屬性)
  • 5.生成JWT-string
//Login
func (m *User) Login(ip string,roleId uint) (string,error) {
  m.Id = 0
  if m.Password == "" {
    return "",errors.New("password is required")
  }
  inputPassword := m.Password
  //獲取登入的使用者
  err := db.Where("username = ? or email = ?",m.Username,m.Username).First(&m).Error
  if err != nil {
    return "",err
  }
  //校驗使用者角色
  if (m.RoleId & roleId) != roleId {
    return "",fmt.Errorf("not role of %d",roleId)
  }
  //驗證密碼
  //password is set to bcrypt check
  if err := bcrypt.CompareHashAndPassword([]byte(m.HashedPassword),[]byte(inputPassword)); err != nil {
    return "",err
  }
  //防止密碼洩露
  m.Password = ""
  //生成jwt-string
  return jwtGenerateToken(m,time.Hour*24*365)
}

4.1.2 生成JWT-string(核心程式碼)

1.自定義payload結構體,不建議直接使用 dgrijalva/jwt-go jwt.StandardClaims結構體.因為他的payload包含的使用者資訊太少.

2.實現 type Claims interface 的 Valid() error 方法,自定義校驗內容

3.生成JWT-string jwtGenerateToken(m *User,d time.Duration) (string,error)

https://github.com/libragen/felix/blob/master/model/m_jwt.go

package model

import (
  "errors"
  "fmt"
  "time"

  "github.com/dgrijalva/jwt-go"
  "github.com/sirupsen/logrus"
)

var AppSecret = ""//viper.GetString會設定這個值(32byte長度)
var AppIss = "github.com/libragen/felix"//這個值會被viper.GetString重寫

//自定義payload結構體,不建議直接使用 dgrijalva/jwt-go `jwt.StandardClaims`結構體.因為他的payload包含的使用者資訊太少.
type userStdClaims struct {
  jwt.StandardClaims
  *User
}
//實現 `type Claims interface` 的 `Valid() error` 方法,自定義校驗內容
func (c userStdClaims) Valid() (err error) {
  if c.VerifyExpiresAt(time.Now().Unix(),true) == false {
    return errors.New("token is expired")
  }
  if !c.VerifyIssuer(AppIss,true) {
    return errors.New("token's issuer is wrong")
  }
  if c.User.Id < 1 {
    return errors.New("invalid user in jwt")
  }
  return
}

func jwtGenerateToken(m *User,error) {
  m.Password = ""
  expireTime := time.Now().Add(d)
  stdClaims := jwt.StandardClaims{
    ExpiresAt: expireTime.Unix(),IssuedAt: time.Now().Unix(),Id:    fmt.Sprintf("%d",m.Id),Issuer:  AppIss,}

  uClaims := userStdClaims{
    StandardClaims: stdClaims,User:      m,}

  token := jwt.NewWithClaims(jwt.SigningMethodHS256,uClaims)
  // Sign and get the complete encoded token as a string using the secret
  tokenString,err := token.SignedString([]byte(AppSecret))
  if err != nil {
    logrus.WithError(err).Fatal("config is wrong,can not generate jwt")
  }
  return tokenString,err
}


//JwtParseUser 解析payload的內容,得到使用者資訊
//gin-middleware 會使用這個方法
func JwtParseUser(tokenString string) (*User,error) {
  if tokenString == "" {
    return nil,errors.New("no token is found in Authorization Bearer")
  }
  claims := userStdClaims{}
  _,err := jwt.ParseWithClaims(tokenString,&claims,func(token *jwt.Token) (interface{},error) {
    if _,ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
      return nil,fmt.Errorf("unexpected signing method: %v",token.Header["alg"])
    }
    return []byte(AppSecret),nil
  })
  if err != nil {
    return nil,err
  }
  return claims.User,err
}

4.2 JWT中介軟體(middleware)

1.從url-query的_t獲取JWT-string或者從請求頭 Authorization中獲取JWT-string

2.model.JwtParseUser(token)解析JWT-string獲取User結構體(減少中介軟體查詢資料庫的操作和時間)

3.設定使用者資訊到gin.Context 其他的handler通過gin.Context.Get(contextKeyUserObj),在進行使用者Type Assert得到model.User 結構體.

4.使用了jwt-middle之後的handle從gin.Context中獲取使用者資訊

https://github.com/libragen/felix/blob/master/ssh2ws/internal/mw_jwt.go

package internal

import (
  "net/http"
  "strings"

  "github.com/libragen/felix/model"
  "github.com/gin-gonic/gin"
)

const contextKeyUserObj = "authedUserObj"
const bearerLength = len("Bearer ")

func ctxTokenToUser(c *gin.Context,roleId uint) {
  token,ok := c.GetQuery("_t")
  if !ok {
    hToken := c.GetHeader("Authorization")
    if len(hToken) < bearerLength {
      c.AbortWithStatusJSON(http.StatusPreconditionFailed,gin.H{"msg": "header Authorization has not Bearer token"})
      return
    }
    token = strings.TrimSpace(hToken[bearerLength:])
  }
  usr,err := model.JwtParseUser(token)
  if err != nil {
    c.AbortWithStatusJSON(http.StatusPreconditionFailed,gin.H{"msg": err.Error()})
    return
  }
  if (usr.RoleId & roleId) != roleId {
    c.AbortWithStatusJSON(http.StatusPreconditionFailed,gin.H{"msg": "roleId 沒有許可權"})
    return
  }

  //store the user Model in the context
  c.Set(contextKeyUserObj,*usr)
  c.Next()
  // after request
}

func MwUserAdmin(c *gin.Context) {
  ctxTokenToUser(c,2)
}

func MwUserComment(c *gin.Context) {
  ctxTokenToUser(c,8)
}

使用了jwt-middle之後的handle從gin.Context中獲取使用者資訊,
https://github.com/libragen/felix/blob/master/ssh2ws/internal/helper.go

func mWuserId(c *gin.Context) (uint,error) {
  v,exist := c.Get(contextKeyUserObj)
  if !exist {
    return 0,errors.New(contextKeyUserObj + " not exist")
  }
  user,ok := v.(model.User)
  if ok {
    return user.Id,nil
  }
  return 0,errors.New("can't convert to user struct")
}

4.2 使用JWT中介軟體

一下程式碼有兩個JWT中介軟體的用法

  • internal.MwUserAdmin 管理後臺使用者中介軟體
  • internal.MwUserCommenter 評論使用者中介軟體

https://github.com/libragen/felix/blob/master/ssh2ws/ssh2ws.go

package ssh2ws

import (
  "time"

  "github.com/libragen/felix/felixbin"
  "github.com/libragen/felix/model"
  "github.com/libragen/felix/ssh2ws/internal"
  "github.com/libragen/felix/wslog"
  "github.com/gin-contrib/cors"
  "github.com/gin-gonic/gin"
)

func RunSsh2ws(bindAddress,user,password,secret string,expire time.Duration,verbose bool) error {
  err := model.CreateGodUser(user,password)
  if err != nil {
    return err
  }
  //config jwt variables
  model.AppSecret = secret
  model.ExpireTime = expire
  model.AppIss = "felix.mojotv.cn"
  if !verbose {
    gin.SetMode(gin.ReleaseMode)
  }
  r := gin.New()
  r.MaxMultipartMemory = 32 << 20
  //sever static file in http's root path
  binStaticMiddleware,err := felixbin.NewGinStaticBinMiddleware("/")
  if err != nil {
    return err
  }

  mwCORS := cors.New(cors.Config{
    AllowOrigins:   []string{"*"},internal.LoginAdmin) //管理後臺登陸
  api.GET("meta",internal.Meta)

  //terminal log
  hub := wslog.NewHub()
  go hub.Run()

  {
    //websocket
    r.GET("ws/hook",internal.MwUserAdmin,internal.Wslog(hub))
    r.GET("ws/ssh/:id",internal.WsSsh)
  }
  //給外部呼叫
  {
    api.POST("wslog/hook-api",internal.JwtMiddlewareWslog,internal.WsLogHookApi(hub))
    api.GET("wslog/hook",internal.WslogHookAll)
    api.POST("wslog/hook",internal.WslogHookCreate)
    api.PATCH("wslog/hook",internal.WslogHookUpdate)
    api.DELETE("wslog/hook/:id",internal.WslogHookDelete)

    api.GET("wslog/msg",internal.WslogMsgAll)
    api.POST("wslog/msg-rm",internal.WslogMsgDelete)
  }

  //評論
  {
    api.GET("comment",internal.CommentAll)
    api.GET("comment/:id/:action",internal.MwUserComment,internal.CommentAction)
    api.POST("comment",internal.CommentCreate)
    api.DELETE("comment/:id",internal.CommentDelete)
  }
  {
    api.GET("hacknews",internal.HackNewAll)
    api.PATCH("hacknews",internal.HackNewUpdate)
    api.POST("hacknews-rm",internal.HackNewRm)
  }

  authG := api.Use(internal.MwUserAdmin)
  {

    //create wslog hook

    authG.GET("ssh",internal.SshAll)
    authG.POST("ssh",internal.SshCreate)
    authG.GET("ssh/:id",internal.SshOne)
    authG.PATCH("ssh",internal.SshUpdate)
    authG.DELETE("ssh/:id",internal.SshDelete)

    authG.GET("sftp/:id",internal.SftpLs)
    authG.GET("sftp/:id/dl",internal.SftpDl)
    authG.GET("sftp/:id/cat",internal.SftpCat)
    authG.GET("sftp/:id/rm",internal.SftpRm)
    authG.GET("sftp/:id/rename",internal.SftpRename)
    authG.GET("sftp/:id/mkdir",internal.SftpMkdir)
    authG.POST("sftp/:id/up",internal.SftpUp)

    authG.POST("ginbro/gen",internal.GinbroGen)
    authG.POST("ginbro/db",internal.GinbroDb)
    authG.GET("ginbro/dl",internal.GinbroDownload)

    authG.GET("ssh-log",internal.SshLogAll)
    authG.DELETE("ssh-log/:id",internal.SshLogDelete)
    authG.PATCH("ssh-log",internal.SshLogUpdate)

    authG.GET("user",internal.UserAll)
    authG.POST("user",internal.RegisterCommenter)
    //api.GET("user/:id",internal.SshAll)
    authG.DELETE("user/:id",internal.UserDelete)
    authG.PATCH("user",internal.UserUpdate)

  }

  if err := r.Run(bindAddress); err != nil {
    return err
  }
  return nil
}

5. Cookie-Session VS JWT

JWT和session有所不同,session需要在伺服器端生成,伺服器儲存session,只返回給客戶端sessionid,客戶端下次請求時帶上sessionid即可,因為session是儲存在伺服器中,有多臺伺服器時會出現一些麻煩,需要同步多臺主機的資訊,不然會出現在請求A伺服器時能獲取資訊,但是請求B伺服器身份資訊無法通過,JWT能很好的解決這個問題,伺服器端不用儲存jwt,只需要儲存加密用的secret,在使用者登入時將jwt加密生成併發送給客戶端,由客戶端儲存,以後客戶端的請求帶上,由伺服器解析jwt並驗證,這樣伺服器不用浪費空間去儲存登入資訊,不用浪費時間去做同步,

5.1 什麼是cookie

基於cookie的身份驗證是有狀態的,這意味著驗證的記錄或者會話(session)必須同時儲存在伺服器端和客戶端,伺服器端需要跟蹤記錄session並存至資料庫,
同時前端需要在cookie中儲存一個sessionID,作為session的唯一識別符號,可看做是session的“身份證”,

cookie,簡而言之就是在客戶端（瀏覽器等）儲存一些使用者操作的歷史資訊（當然包括登入資訊）,並在使用者再次訪問該站點時瀏覽器通過HTTP協議將本地cookie內容傳送給伺服器,從而完成驗證,或繼續上一步操作,

5.2 什麼是session

session,會話,簡而言之就是在伺服器上儲存使用者操作的歷史資訊,在使用者登入後,伺服器儲存使用者會話的相關資訊,併為客戶端指定一個訪問憑證,如果有客戶端憑此憑證發出請求,則在服務端儲存的資訊中,取出使用者相關登入資訊,
並且使用服務端返回的憑證常儲存於Cookie中,也可以改寫URL,將id放在url中,這個訪問憑證一般來說就是SessionID,

5.3 cookie-session身份驗證機制的流程

session和cookie的目的相同,都是為了克服http協議無狀態的缺陷,但完成的方法不同,
session可以通過cookie來完成,在客戶端儲存session id,而將使用者的其他會話訊息儲存在服務端的session物件中,與此相對的,cookie需要將所有資訊都儲存在客戶端,
因此cookie存在著一定的安全隱患,例如本地cookie中儲存的使用者名稱密碼被破譯,或cookie被其他網站收集（例如：1. appA主動設定域B cookie,讓域B cookie獲取；2. XSS,在appA上通過javascript獲取document.cookie,並傳遞給自己的appB）,

  1. 使用者輸入登入資訊
  2. 伺服器驗證登入資訊是否正確,如果正確就建立一個session,並把session存入資料庫
  3. 伺服器端會向客戶端返回帶有sessionID的cookie
  4. 在接下來的請求中,伺服器將把sessionID與資料庫中的相匹配,如果有效則處理該請求
  5. 如果使用者登出app,session會在客戶端和伺服器端都被銷燬

5.4 Cookie-session 和 JWT 使用場景

後端渲染HTML頁面建議使用Cookie-session認證

後按渲染頁面可以很方便的寫入/清除cookie到瀏覽器,許可權控制非常方便.很少需要要考慮跨域AJAX認證的問題.

App,web單頁面應用,APIs建議使用JWT認證

App、web APIs等的興起,基於token的身份驗證開始流行,
當我們談到利用token進行認證,我們一般說的就是利用JSON Web Tokens（JWTs）進行認證,雖然有不同的方式來實現token,
事實上,JWTs 已成為標準,因此在本文中將互換token與JWTs,

以上就是這篇文章的全部內容了,希望本文的內容對大家的學習或者工作能帶來一定的幫助,如果有疑問大家可以留言交流， 謝謝大家對mojotv.cn的支援.喜歡這個網站麻煩幫忙新增到收藏夾,新增我的微信好友: felixarebest 微博賬號: MojoTech 向我提問.

原文地址:Go進階24:Go-jwt RESTful身份認證教程

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。

相關推薦

詳解Go-JWT-RESTful身份認證教程

1.什麼是JWT JWT（JSON Web Token）是一個非常輕巧的規範,這個規範允許我們使用JWT在使用者和伺服器之間傳遞安全可靠的資訊,

詳解Go語言的記憶體模型及堆的分配管理

前言 這篇文章主要介紹Go記憶體分配和Go記憶體管理，會輕微涉及記憶體申請和釋放，以及Go垃圾回收。從非常巨集觀的角度看，Go的記憶體管理就是下圖這個樣子，我們今天主要關注其中標紅的部分。

詳解Go中Set的實現方式

本篇主要講述如何利用Go語言的語法特性實現Set型別的資料結構。 需求 對於Set型別的資料結構，其實本質上跟List沒什麼多大的區別。無非是Set不能含有重複的Item的特性，Set有初始化、Add、Clear、Remove、Contains等

詳解go語言 make(chan int, 1) 和 make (chan int) 的區別

遇到golang channel 的一個問題：發現go 協程讀取channel 資料 並沒有按照預期進行協作執行。

圖文詳解go語言反射實現原理

Go反射的實現和 interface 和 unsafe.Pointer 密切相關。如果對golang的 interface 底層實現還沒有理解，可以去看我之前的文章： Go語言interface底層實現 ， unsafe.Pointer 會在後續的文章中做介紹。

詳解go中的引用型別

值型別和引用型別 值型別：int、float、bool和string這些型別都屬於值型別，使用這些型別的變數直接指向存在記憶體中的值，值型別的變數的值儲存在棧中。當使用等號=將一個變數的值賦給另一個變數時，如 j = i,實際

詳解Go語言的計時器

Go語言的標準庫裡提供兩種型別的計時器Timer和Ticker。Timer經過指定的duration時間後被觸發，往自己的時間channel傳送當前時間，此後Timer不再計時。Ticker則是每隔duration時間都會把當前時間點發送給自己的時間ch

詳解go基於viper實現配置檔案熱更新及其原始碼分析

go第三方庫 github.com/spf13/viper 實現了對配置檔案的讀取並注入到結構中，好用方便。

詳解go 動態陣列 二維動態陣列

go使用動態陣列還有點麻煩，比python麻煩一點，需要先定義。 動態陣列申明 var dynaArr []string

詳解Go語言中關於包匯入必學的 8 個知識點

1. 單行匯入與多行匯入 在 Go 語言中，一個包可包含多個 .go 檔案（這些檔案必須得在同一級資料夾中），只要這些 .go 檔案的頭部都使用 package 關鍵字聲明瞭同一個包。

詳解Go多協程併發環境下的錯誤處理

引言 在Go語言中，我們通常會用到panic和recover來丟擲錯誤和捕獲錯誤，這一對操作在單協程環境下我們正常用就好了，並不會踩到什麼坑。但是在多協程併發環境下，我們常常會碰到以下兩個問題。假設我們現在有2個協程

詳解Go 結構體格式化輸出

在軟體系統中定位問題時日誌不可或缺，但是當一個系統功能繁多，需要列印的日誌也多如牛毛，此時為了提高我們瀏覽日誌的效率，便於閱讀的輸出格式必不可少。

詳解Go 併發

golang 天生語言層面支援併發,非常棒的語言,有時我們業務開發時,遇到複雜場景,需要用於併發,將多個請求使用協程組完成併發,當遇到巢狀迴圈,還存在上下文關係需要改造為併發請求,將之前的時間複雜度為O(n^2)改為O(n)的

詳解Go語言中for range的&quot;坑&quot;

前言 Go 中的for range組合可以和方便的實現對一個數組或切片進行遍歷，但是在某些情況下使用for range時很可能就會被\"坑\"，下面用一段程式碼來模擬下：

詳解Go strconv包

strconv包 　　 該包主要實現基本資料型別與其字串表示的轉換。 　　 常用函式為Atoi()、Itia()、parse系列、format系列、append系列。

詳解Go module的介紹及使用

Go1.1.1版本釋出(2018-08-24釋出)已經過去幾天，從官方的部落格中看到，有兩個比較突出的特色，一個就是今天講的module，模組概念。目前該功能還在試驗階段，有些地方還需要不斷的進行完善。在官方正式宣佈之前，打算

詳解基於JWT的springboot許可權驗證技術實現

JWT簡介 Json Web Token（JWT）：JSON網路令牌，是為了在網路應用環境間傳遞宣告而制定的一種基於JSON的開放標準（(RFC 7519)。JWT是一個輕便的安全跨平臺傳輸格式，定義了一個緊湊的自包含的方式用於通訊雙方之間以

詳解Go語言中用 os/exec 執行命令的五種方法

完整系列教程詳見：http://golang.iswbm.com 在 Golang 中用於執行命令的庫是 os/exec，exec.Command 函式返回一個 Cmd 物件，根據不同的需求，可以將命令的執行分為三種情況

深入詳解Go的channel底層實現原理【圖解】

channel的整體結構圖 簡單說明： buf是有緩衝的channel所特有的結構，用來儲存快取資料。是個迴圈連結串列

詳解go語言單鏈表及其常用方法的實現

目的 在刷演算法題中經常遇到關於連結串列的操作，在使用go語言去操作連結串列時不熟悉其實現原理，目的是為了重溫連結串列這一基礎且關鍵的資料結構。