JWT工具类

package org.oak;


import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.JWTVerifier;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.exceptions.JWTVerificationException;
import com.auth0.jwt.interfaces.Claim;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.*;

/**
 * @author zhong
 * @Description JWT工具类
 * @date Aug 18, 2021
 * @Version 1.0
 */
public class JwtUtil {

    /**
     * key
     */
    private static String jwtKey = "zg19491001dfdlhksl";

    /**
     * 过期时间
     */
    private static Integer expiredTimeIn = 24 * 60 * 60;

    /**
     * JWT KEY
     *
     * @param jwtKey
     */
    public void setJwtKey(String jwtKey) {
        JwtUtil.jwtKey = jwtKey;
    }

    /**
     * 过期时间
     *
     * @param expiredTimeIn
     */
    public void setExpiredTimeIn(Integer expiredTimeIn) {
        JwtUtil.expiredTimeIn = expiredTimeIn;
    }

    /**
     * 生成令牌
     *
     * @param uid 用户id
     * @return
     */
    public static String makeToken(Long uid) {
        return JwtUtil.getToken(uid);
    }

    public static String makeToken(Map<String, String> map) {
        return JwtUtil.getToken(map);
    }

    /**
     * 获取令牌
     *
     * @param uid 用户id
     * @return
     */
    private static String getToken(Long uid) {
        // 指定算法
        Algorithm algorithm = Algorithm.HMAC256(JwtUtil.jwtKey);

        Map<String, Date> dateMap = JwtUtil.calculateExpiredIssues();

        /**
         * withClaim(） 写入自定义数据
         * withExpiresAt() 设置过期时间
         * withIssuedAt() 设置当前时间
         * sign() 签名算法
         */
        JWTCreator.Builder builder = JWT.create();
        return JWT.create()
                .withClaim("uid", uid)
                .withExpiresAt(dateMap.get("expiredTime"))
                .withIssuedAt(dateMap.get("now"))
                .sign(algorithm);
    }

    private static String getToken(Map<String, String> map) {
        // 指定算法
        Algorithm algorithm = Algorithm.HMAC256(JwtUtil.jwtKey);

        Map<String, Date> dateMap = JwtUtil.calculateExpiredIssues();

        /**
         * withClaim(） 写入自定义数据
         * withExpiresAt() 设置过期时间
         * withIssuedAt() 设置当前时间
         * sign() 签名算法
         */
        JWTCreator.Builder builder = JWT.create();
        map.forEach((k, v) -> {
            builder.withClaim(k, v);
        });
        return builder.withExpiresAt(dateMap.get("expiredTime"))
                .withIssuedAt(dateMap.get("now"))
                .sign(algorithm);
    }

    /**
     * 获取自定义数据
     *
     * @param token
     * @return
     */
    public static Optional<Map<String, Claim>> getClaims(String token) {
        DecodedJWT decodedJWT;

        // 指定算法
        Algorithm algorithm = Algorithm.HMAC256(JwtUtil.jwtKey);
        JWTVerifier jwtVerifier = JWT.require(algorithm).build();

        try {
            decodedJWT = jwtVerifier.verify(token);
        } catch (JWTVerificationException e) {
            return Optional.empty();
        }

        return Optional.of(decodedJWT.getClaims());
    }

    /**
     * 验证Token
     *
     * @param token
     * @return
     */
    public static boolean verifyToken(String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(JwtUtil.jwtKey);
            JWTVerifier jwtVerifier = JWT.require(algorithm).build();
            jwtVerifier.verify(token);
        } catch (JWTVerificationException e) {
            return false;
        }

        return true;
    }

    /**
     * 计算过期时间
     *
     * @return
     */
    private static Map<String, Date> calculateExpiredIssues() {
        Map<String, Date> map = new HashMap<>();
        Calendar calendar = Calendar.getInstance();
        Date now = calendar.getTime();
        calendar.add(Calendar.SECOND, JwtUtil.expiredTimeIn);
        // 当前时间
        map.put("now", now);
        // 过期时间
        map.put("expiredTime", calendar.getTime());
        return map;
    }


    public static void main(String[] args) {
        String token = makeToken(1L);
        System.out.println(token);
        System.out.println(verifyToken(token));
        Optional<Map<String, Claim>> claims = getClaims(token);
        Map<String, Claim> stringClaimMap = claims.get();
        System.out.println(stringClaimMap);

        Map<String, String> paramMap = new HashMap<>();
        paramMap.put("uid", "1");
        paramMap.put("name", "zr");
        paramMap.put("age", "zr");
        String makeToken = makeToken(paramMap);
        verifyToken(makeToken);

        Optional<Map<String, Claim>> claims1 = getClaims(makeToken);

        Map<String, Claim> stringClaimMap1 = claims1.get();
        System.out.println(stringClaimMap1);
    }
}