go get -u github.com/golang-jwt/jwt/v4
import "github.com/golang-jwt/jwt/v4"

package main
import (
   "fmt"
   "github.com/golang-jwt/jwt/v4"
)
func main() {
    // 創(chuàng)建秘鑰
   	key := []byte("aaa")
    // 創(chuàng)建Token結(jié)構(gòu)體
	claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
		"user": "zhangshan",
		"pass": "123123",
	})
    // 調(diào)用加密方法，發(fā)揮Token字符串
	signingString, err := claims.SignedString(key)
	if err != nil {
		return
	}
	fmt.Println(signingString)
}
//這邊是輸出結(jié)果
&{ 0xc0000c2690 map[alg:ES256 typ:JWT] map[user:zhangshan]  false}
// 這是加密后的字符串
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXNzIjoiMTIzMTIzIiwidXNlciI6InpoYW5nc2hhbiJ9.-2-xIJXMGKV-GyhM24OKbDVqWs4dsIANBsGhzXEfEFM

claims := jwt.NewWithClaims(jwt.SigningMethodES256, jwt.MapClaims{
      "user": "zhangshan",
   })

type Token struct {
   Raw       string        //原始令牌  
   Method    SigningMethod   // 加密方法 比如sha256加密      
   Header    map[string]interface{} // token頭信息
   Claims    Claims  // 加密配置，比如超時(shí)時(shí)間等             
   Signature string  // 加密后的字符串          
   Valid     bool   // 是否校驗(yàn)              
}
type Token struct {
   Raw       string        //原始令牌  
   Method    SigningMethod   // 加密方法 比如sha256加密      
   Header    map[string]interface{} // token頭信息
   Claims    Claims  // 加密配置，比如超時(shí)時(shí)間等             
   Signature string  // 加密后的字符串          
   Valid     bool   // 是否校驗(yàn)              
}

type Claims interface {
   Valid() error
}
//實(shí)現(xiàn)類有MapClaims、RegisteredClaims、StandardClaims(舍棄)
//其實(shí)后兩個(gè)結(jié)構(gòu)體都是根據(jù)MapClaims編寫而來，所以我們只需要掌握MapClaims即可
type MapClaims map[string]interface{}

// 根據(jù)Token字符串解析成Claims結(jié)構(gòu)體
_, err = jwt.ParseWithClaims(signingString, jwt.MapClaims{}, func(token *jwt.Token) (interface{}, error) {
   fmt.Println(token.Header)
   return []byte("aaa"), nil
})
if err != nil {
   fmt.Println(err)
   return
}

WithValidMethods(methods []string)  //指定使用的解密算法，他會(huì)跟token中加密方法進(jìn)行名稱比較，如果false則返回錯(cuò)誤值
WithoutClaimsValidation() // 忽略過期、發(fā)布時(shí)間等檢查

func (t *Token) SignedString(key interface{}) (string, error) {
   var sig, sstr string
   var err error
   // 通過base64 對header與claims進(jìn)行加密
   if sstr, err = t.SigningString(); err != nil {
      return "", err
   } 
   // 通過指定的加密方法，根據(jù)key值進(jìn)行加密
   if sig, err = t.Method.Sign(sstr, key); err != nil {
      return "", err
   }
   // 拼接token字符串
   return strings.Join([]string{sstr, sig}, "."), nil
}

func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc, options ...ParserOption) (*Token, error) {
   // 創(chuàng)建解析器，
   //ParseWithClaims 解析token字符串
   return NewParser(options...).ParseWithClaims(tokenString, claims, keyFunc)
}
func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) (*Token, error) {
    // 解析字符串，將根據(jù).進(jìn)行切割，通過base64進(jìn)行解碼，根據(jù)header中的alg屬性獲取加密方法比如sha256
    // 返回值token為Token結(jié)構(gòu)體，parts為字符串切割后的數(shù)組
	token, parts, err := p.ParseUnverified(tokenString, claims)
	if err != nil {
		return token, err
	}
	// 判斷是否指定校驗(yàn)方法
	if p.ValidMethods != nil {
		var signingMethodValid = false
		var alg = token.Method.Alg()
		for _, m := range p.ValidMethods {
			if m == alg {
				signingMethodValid = true
				break
			}
		}
		if !signingMethodValid {
			// 指定方法與token中的方法不一致
			return token, NewValidationError(fmt.Sprintf("signing method %v is invalid", alg), ValidationErrorSignatureInvalid)
		}
	}
	// 獲取key秘鑰 
	var key interface{}
    // 判斷是否實(shí)現(xiàn)keyfunc，就是第三個(gè)參數(shù)
	if keyFunc == nil {
		// keyFunc was not provided.  short circuiting validation
		return token, NewValidationError("no Keyfunc was provided.", ValidationErrorUnverifiable)
	}
    // 調(diào)用方法，返回key值
	if key, err = keyFunc(token); err != nil {
		// keyFunc returned an error
		if ve, ok := err.(*ValidationError); ok {
			return token, ve
		}
		return token, &ValidationError{Inner: err, Errors: ValidationErrorUnverifiable}
	}
	vErr := &ValidationError{}
	// 判斷是否進(jìn)行校驗(yàn)，SkipClaimsValidation默認(rèn)為false 加上！成為true
	if !p.SkipClaimsValidation {
		if err := token.Claims.Valid(); err != nil {
			// If the Claims Valid returned an error, check if it is a validation error,
			// If it was another error type, create a ValidationError with a generic ClaimsInvalid flag set
			if e, ok := err.(*ValidationError); !ok {
				vErr = &ValidationError{Inner: err, Errors: ValidationErrorClaimsInvalid}
			} else {
				vErr = e
			}
		}
	}
	// 進(jìn)行簽名驗(yàn)證
	token.Signature = parts[2]
	if err = token.Method.Verify(strings.Join(parts[0:2], "."), token.Signature, key); err != nil {
		vErr.Inner = err
		vErr.Errors |= ValidationErrorSignatureInvalid
	}
	if vErr.valid() {
		token.Valid = true
		return token, nil
	}
	return token, vErr
}