这篇文章主要介绍了golang中的jwt使用教程,接下来我们需要讲解一下Claims该结构体存储了token字符串的超时时间等信息以及在解析时的Token校验工作，需要的朋友可以参考下

golang-jwt使用

老版本<v4.0.0 为github.com/dgrijalva/jwt-go 新版本https://github.com/golang-jwt/jwt

本文环境为新版本

加密

1.在使用之前我们应该对它进行安装与导入

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

2.既然导入成功那就开始使用吧

package main
import (
   "fmt"
   "github.com/golang-jwt/jwt/v4"
)
func main() {
    // 创建秘钥
    key := []byte("aaa")
    // 创建Token结构体
    claims := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user": "zhangshan",
        "pass": "123123",
    })
    // 调用加密方法，发挥Token字符串
    signingString, err := claims.SignedString(key)
    if err != nil {
        return
    }
    fmt.Println(signingString)
}
//这边是输出结果
&{ 0xc0000c2690 map[alg:ES256 typ:JWT] map[user:zhangshan]  false}
// 这是加密后的字符串
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJwYXNzIjoiMTIzMTIzIiwidXNlciI6InpoYW5nc2hhbiJ9.
-2-xIJXMGKV-GyhM24OKbDVqWs4dsIANBsGhzXEfEFM

3.逐步讲解

首先我们先查看第一步

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

newWithClaims会返回一个Token结构体，而这个token结构体有以下属性

type Token struct {
   Raw       string        //原始令牌 
   Method    SigningMethod   // 加密方法 比如sha256加密     
   Header    map[string]interface{} // token头信息
   Claims    Claims  // 加密配置，比如超时时间等            
   Signature string  // 加密后的字符串         
   Valid     bool   // 是否校验             
}
type Token struct {
   Raw       string        //原始令牌 
   Method    SigningMethod   // 加密方法 比如sha256加密     
   Header    map[string]interface{} // token头信息
   Claims    Claims  // 加密配置，比如超时时间等            
   Signature string  // 加密后的字符串         
   Valid     bool   // 是否校验             
}

我们可以通过该结构体获取到加密后的字符串信息。

接下来我们需要讲解一下Claims该结构体存储了token字符串的超时时间等信息以及在解析时的Token校验工作。

type Claims interface {
   Valid() error
}
//实现类有MapClaims、RegisteredClaims、StandardClaims(舍弃)
//其实后两个结构体都是根据MapClaims编写而来，所以我们只需要掌握MapClaims即可
type MapClaims map[string]interface{}

就是一个map集合，但是它实现了上面Valid()方法，该方法里面实现了对token过期日期校验、发布时间、生效时间的校验工作。
所以在map里面有三个固定的键我们可以根据需要进行设置，exp 过期时间、iat 发布时间、nbf 生效时间

解密

既然已经将Token值进行了加密那么如何对其进行验证(俗称解密)那？

// 根据Token字符串解析成Claims结构体
_, 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
}

在该方法中，有四个个参数，我们需要注意第三个方法参数，该类型是一个方法，token作为参数，两个返回值，我们重点关注第一个返回值，该值会用来进行编码解析，所以我们需要传入上文中的key秘钥。

第四个参数为配置参数，主要控制parse过程中对token的校验工作，比如调用WithoutClaimsValidation()则会关闭token的过期检查等操作。

WithValidMethods(methods []string)  //指定使用的解密算法，他会跟token中加密方法进行名称比较，
如果false则返回错误值
WithoutClaimsValidation() // 忽略过期、发布时间等检查

源码分析

接下来我们将讲解一下具体流程

SignedString

SignedString用来生成token结构体

func (t *Token) SignedString(key interface{}) (string, error) {
   var sig, sstr string
   var err error
   // 通过base64 对header与claims进行加密
   if sstr, err = t.SigningString(); err != nil {
      return "", err
   }
   // 通过指定的加密方法，根据key值进行加密
   if sig, err = t.Method.Sign(sstr, key); err != nil {
      return "", err
   }
   // 拼接token字符串
   return strings.Join([]string{sstr, sig}, "."), nil
}

ParseWithClaims

ParseWithClaims用来解析Token字符串返回token结构体

func ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc,
 options ...ParserOption) (*Token, error) {
   // 创建解析器，
   //ParseWithClaims 解析token字符串
   return NewParser(options...).ParseWithClaims(tokenString, claims, keyFunc)
}
func (p *Parser) ParseWithClaims(tokenString string, claims Claims, keyFunc Keyfunc) 
(*Token, error) {
    // 解析字符串，将根据.进行切割，通过base64进行解码，
    根据header中的alg属性获取加密方法比如sha256
    // 返回值token为Token结构体，parts为字符串切割后的数组
    token, parts, err := p.ParseUnverified(tokenString, claims)
    if err != nil {
        return token, err
    }
    // 判断是否指定校验方法
    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{}
    // 判断是否实现keyfunc，就是第三个参数
    if keyFunc == nil {
        // keyFunc was not provided.  short circuiting validation
        return token, NewValidationError("no Keyfunc was provided.", 
        ValidationErrorUnverifiable)
    }
    // 调用方法，返回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{}
    // 判断是否进行校验，SkipClaimsValidation默认为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
            }
        }
    }
    // 进行签名验证
    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
}