JWT令牌的使用

什么是JWT

json web token(JWT),是为了在网络应用环境间传递声明而执行的一种JSON的开放标准(RFC 7519).该token被设计为紧凑且安全的，特别适用于分布式站点的单点登录（SSO）场景。JWT的声明一般用来在身份提供者间传递被认证的用户身份信息，以便于从志愿服务期获取资源，也可以增加一些额外的其他业务了逻辑所必须的声明信息，该token也可以直接被用于认证，也可以被加密。

集群的服务其中有一部分服务器没有session，服务器没法共享session。

令牌分为3部分，头部，负载数据，验证签名。第一部分一般不变，负载数据和签名会动态变化，不能修改。令牌的长度不确定，根据负载的数据发生改变。

自定义JWT工具类

package com.ccity.utils;

import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import com.auth0.jwt.*;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

/**
 * @author 86155
 * @version 17
 * @title:ccity
 * @projectName smvc2022
 * @description: TODO
 * @date 2022/4/1020:17
 * @since 1.0
 */
public class JwtUtils {
    private String sign="ccity2022";

    public String getSign() {
        return sign;
    }

    public void setSign(String sign) {
        this.sign = sign;
    }

    public JwtUtils(String sign){
        this.sign=sign;
    }
    public JwtUtils(){

    }
    public String getToken(String sign, Map<String,String> payload, int minutes){
        //生成令牌token
        Calendar instance=Calendar.getInstance();//日历类，获取日历实例
        instance.add(Calendar.MINUTE,minutes);//设置时间令牌超时为30分钟
        JWTCreator.Builder builder=JWT.create();
        payload.forEach(builder::withClaim);
        String token= builder
                //.withHeader(map)//添加头部
                .withExpiresAt(instance.getTime())//设置过期时间
                .sign(Algorithm.HMAC256(sign));//设置签名，密钥
        return token;
    }
    public String getToken( Map<String,String> payload, int minutes){
        //生成令牌token
        Calendar instance=Calendar.getInstance();//日历类，获取日历实例
        instance.add(Calendar.MINUTE,minutes);//设置时间令牌超时为30分钟
        JWTCreator.Builder builder=JWT.create();
        if (payload!=null){
        payload.forEach(builder::withClaim);}
        String token= builder
                //.withHeader(map)//添加头部
                .withExpiresAt(instance.getTime())//设置过期时间
                .sign(Algorithm.HMAC256(sign));//设置签名，密钥
        return token;
    }
    public Map<String,String> getPayLoad(String token){
        Map<String ,String> map=new HashMap<>();
        if (verifyToken(token,sign)){
            JWTVerifier v=JWT.require(Algorithm.HMAC256(sign)).build();//根据密钥，签名创建校验者
            try {
                DecodedJWT f=v.verify(token);//校验者进行校验,没有异常及时校验成功
                Map<String, Claim> mc = f.getClaims();
                for (String k:mc.keySet()){
                    map.put(k,k.equalsIgnoreCase("exp")?String.format("%tF %<tT",mc.get(k).asDate()):mc.get(k).asString());
                }
            }
            catch (Exception e){
                e.printStackTrace();
            }
        }
        return map;
    }
    public  boolean verifyToken(String token, String sign){
        boolean flag=false;
        //校验令牌
        JWTVerifier v=JWT.require(Algorithm.HMAC256(sign)).build();//根据密钥，签名创建校验者
        try{
            DecodedJWT f=v.verify(token);//校验者进行校验,没有异常及时校验成功
            flag =true;
            System.out.printf("%tF %<tT%n",f.getClaim("exp").asDate());
            System.out.println(f.getPayload());
            System.out.println("-------------------------");
            f.getClaims().forEach((key,value)->{
                System.out.println(key+"===="+value);
            });
        }
        catch (TokenExpiredException tee){
            System.out.println("令牌过期");
        }
        catch (SignatureVerificationException sve){
            System.out.println("令牌异常，被篡改");
        }
        catch (Exception e){
            e.printStackTrace();
        }
        return  flag;
    }
    public  boolean verifyToken(String token){
        boolean flag=false;
        //校验令牌
        JWTVerifier v=JWT.require(Algorithm.HMAC256(sign)).build();//根据密钥，签名创建校验者
        try{
            DecodedJWT f=v.verify(token);//校验者进行校验,没有异常及时校验成功
            flag =true;
            System.out.printf("%tF %<tT%n",f.getClaim("exp").asDate());
            System.out.println(f.getPayload());
            System.out.println("-------------------------");
            f.getClaims().forEach((key,value)->{
                System.out.println(key+"===="+value);
            });
        }
        catch (TokenExpiredException tee){
            System.out.println("令牌过期");
        }
        catch (SignatureVerificationException sve){
            System.out.println("令牌异常，被篡改");
        }
        catch (Exception e){
            e.printStackTrace();
        }
        return  flag;
    }
}

1.创建项目，添加依赖

<!--java令牌机制-->
<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.19.0 </version>
</dependency>

2.创建类，使用JWT

package com;
import com.auth0.jwt.JWT;
import com.auth0.jwt.algorithms.Algorithm;
import java.util.Calendar;
import java.util.Date;
public class JwtDemo {
    public static void main(String[] args) {
    //生成令牌token
        Calendar instance=Calendar.getInstance();//日历类，获取日历实例
        instance.add(Calendar.MINUTE,30);//设置时间令牌超时为30分钟
        Date date=new Date();
        System.out.println(instance.getTime());
        System.out.println(date);
        String token= JWT.create()
                //.withHeader(map)//添加头部
                .withClaim("userid","admin")
                .withClaim("username","李四")
                .withExpiresAt(instance.getTime())//设置过期时间
                .sign(Algorithm.HMAC256("testjwt"));//设置签名，密钥
        System.out.println(token);
        
        //校验令牌
JWTVerifier v=JWT.require(Algorithm.HMAC256("testjwt")).build();//根据密钥，签名创建校验者
String tt="eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE2NDk1ODkxOTIsInVzZXJpZCI6ImFkbWluIiwidXNlcm5hbWUiOiLmnY7lm5sifQ.Pr_vx8qwrUSZDq6ixBAcjpYSI-mky9MiXM-ZXNWZ1ME";
try{
    System.out.println("解码开始");
    DecodedJWT f=v.verify(tt);//校验者进行校验阶码
    System.out.println(f.getClaim("userid").asString());
    System.out.println(f.getClaim("username").asString());
    System.out.printf("%tF %<tT%n",f.getClaim("exp").asDate());
    System.out.println(f.getPayload());
    System.out.println("-------------------------");
    f.getClaims().forEach((key,value)->{
        System.out.println(key+"===="+value);
    });
}
catch (TokenExpiredException tee){
    System.out.println("令牌过期");
}
catch (SignatureVerificationException sve){
    System.out.println("令牌异常，被篡改");
}
catch (Exception e){
    e.printStackTrace();
}
    }
}

3.创建令牌工具类，通过拦截器校验

每次请求前拦截验证令牌

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    boolean f=false;
    String token=request.getHeader("token");
    if ("".equals(token)||null==token){
        f=false;
    }else if (ju.verifyToken(token)){
        f=true;
    }
    if (!f){
        response.sendRedirect("/admin/login");
    }
    return f;
}

从请求中获取令牌的方法：

1.

(@RequestHeader(value = "token",required = false,defaultValue = "") String token)

2.request.getHeader("token");