Jwt工具类

Jwt工具类

Maven依赖

pom.xml

<!--Lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.20</version>
</dependency>
<!--  jwt令牌依赖  -->
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>
<!-- 阿里json框架 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

配置文件

application.yaml

jwt:
  secret: key
  issuer: 签发者
  expiration: 3600000  # 1 hour in milliseconds
  aud:
    - Dark
    - Black
    - Purple
  start-date: 2024-10-30 12:11:00

工具类

JwtTokenUtil.java

package com.example.utils;

import com.alibaba.fastjson.JSON;
import io.jsonwebtoken.*;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Function;

/**
 * [Json Web Token]工具类
 * @author peter
 * @className JwtTokenUtil
 * @packageName com.example.utils
 * @description 用于Token的生成和验证
 */
@Component
@ConfigurationProperties(prefix = "jwt")
public class JwtTokenUtil implements ApplicationListener<ApplicationReadyEvent> {
    
     /**
     * jwt密钥生成模式 >> 动态生成和静态自定义
     */
    @Getter
    @Setter
    private SecretType secret_mode;

    /**
     * jwt密钥 >> 生成token时将使用此密钥进行加密
     */
    @Getter
    @Setter
    private String secret = "secret";

    /**
     * jwt签发者 >> 用于说明签发此token的所有者
     */
    @Getter
    @Setter
    private String issuer = "1号签发者";

    /**
     * jwt到期时间【单位毫秒】 >> 当超过此段时间，jwt令牌将因过期而无法使用
     */
    @Getter
    @Setter
    private long expiration = 86400000;

    /**
     * jwt预期接收者 >> 用于确保 Token 只被特定的服务或系统接受，从而增强安全性。
     */
    @Getter
    @Setter
    private List<String> aud = new ArrayList<>(Arrays.asList("接收者1", "接收者2", "接收者3"));

    /**
     * jwt生效时间 >> 只有在此时间后，jwt所生成的token才可用
     */
    @Getter
    @Setter
    private String startDate = "2000-01-01 00:00:00";


    final Set<String> jtiSet = new HashSet<>();

    /**
     * 导出jwt令牌到期时间
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的到期时间
     */
    public Date extractExpiration(String token) {
        return extractClaim(token, Claims::getExpiration);
    }

    /**
     * 导出jwt令牌签发时间
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt签发时间
     */
    public Date extractIssuedAt(String token) {
        return extractClaim(token, Claims::getIssuedAt);
    }

    /**
     * 导出jwt令牌主题
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @description 主题一般表示用户 ID 或用户名。这里我们选择存储用户名
     * @return 返回解析出的jwt令牌主题
     */
    public String extractSubject(String token) {
        return extractClaim(token, Claims::getSubject);
    }

    /**
     * 导出jwt令牌接收者
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt令牌接收者
     */
    public String extractAudience(String token) {
        return extractClaim(token, Claims::getAudience);
    }

    /**
     * 导出jwt令牌生效时间
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt令牌生效时间
     */
    public Date extractNotBefore(String token) {
        return extractClaim(token, Claims::getNotBefore);
    }

    /**
     * 导出jwt令牌签发者
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt令牌签发者
     */
    public String extractIssuer(String token) {
        return extractClaim(token, Claims::getIssuer);
    }

    /**
     * 导出jwt令牌id
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt令牌id
     */
    public String extractId(String token) {
        return extractClaim(token, Claims::getId);
    }

    /**
     * 导出jwt令牌载荷
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @param claimsResolver 载荷解析器
     * @return 返回解析出的jwt令牌载荷信息
     */
    public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = extractAllClaims(token);
        return claimsResolver.apply(claims);
    }

    /**
     * 导出jwt令牌所有载荷信息
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回解析出的jwt令牌所有载荷信息
     */
    private Claims extractAllClaims(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }

    private Map<String,String> extractHeader(String token) {
        String[] parts = token.split("\\.");
        if (parts.length != 3) {
            throw new IllegalArgumentException("JWT token格式不正确");
        }

        // 解码头部部分
        byte[] headerBytes = java.util.Base64.getUrlDecoder().decode(parts[0]);
        return (Map<String, String>) JSON.parse(headerBytes);
    }

    /**
     * 验证token是否到期，到期true,否则false
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户的令牌
     * @return 返回到期true,否则false
     */
    private Boolean isTokenExpired(String token) {
        return extractExpiration(token).before(new Date());
    }

    /**
     * 生成token
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param username 用户名
     * @return 返回生成的token
     */
    public String generateToken(String username) {
        // jwt 有效载荷
        Map<String, Object> claims = new HashMap<>();
        // sub 主题，一般表示用户 ID 或用户名。
        claims.put("sub", username);
        // aud 预期接收者 >>> 用于确保 Token 只被特定的服务或系统接受，从而增强安全性。
        claims.put("aud", aud.get(0)); // 接收

        // iss 签发者，表示谁生成了这个 Token。
        claims.put("iss", issuer);

        String jti = UUID.randomUUID().toString().replace("-","");
        // jwt唯一标识
        claims.put("jti", jti);
        // 将生成的id加入set集合 NOTE:这里是需要存放jwtId的,这里我为了方便放set集合里了，正常请更换存储位置，例如存到redis缓存或者其他数据库中
        jtiSet.add(jti);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        //sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        Date createdDate;
        try {
            createdDate = sdf.parse(startDate);

        } catch (ParseException e) {
            throw new RuntimeException(e);
        }

        // 定义jwt生效时间.  >>>  JWT 中的 nbf 需要 秒级时间戳，所以需要除以 1000
        claims.put("nbf", createdDate.getTime()/1000);
        return createToken(claims, username);
    }

    /**
     * 生成token
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param claims 载荷信息，包含很多东西
     * @param subject 主题，这里是用户名(因为我存的是用户名，就是根据用户名来生成的token)
     * @return 返回生成的token
     */
    private String createToken(Map<String, Object> claims, String subject) {
        Map<String, Object> headers = new HashMap<>();
        // 常见头部配置【默认】
        headers.put("typ", "JWT"); // 类型jwt
        headers.put("alg", "HS256"); // 加密算法 HS256
        // 也可以自定义其他信息加入头部信息 TODO...

        return Jwts.builder()
                .setHeader(headers)      // 头部信息
                .setClaims(claims)       // 有效载荷
                .setSubject(subject)     // 主题，我们这里存了用户名
                .setIssuedAt(new Date()) // jwt签发时间
                .setExpiration(new Date(System.currentTimeMillis() + expiration))
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }

    /**
     * 【不推荐使用】验证token有效性
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户令牌
     * @param name 用户名
     * @description 这里只是验证用户名和令牌是否到期【验证不完整】,请改用 {@link #validateTokenEnhance(String, String)} ()}。
     * @return true则有效，否则无效
     */
    @Deprecated
    public Boolean validateToken(String token, String name) {
        final String username = extractSubject(token);
        return (username.equals(name) && !isTokenExpired(token));
    }

    /**
     * 验证token有效性
     * @className JwtTokenUtil
     * @packageName com.example.utils
     * @param token 用户令牌
     * @param name 用户名
     * @return true则有效，否则无效
     */
    public Boolean validateTokenEnhance(String token, String name) {

        try {
            final String username = extractSubject(token);
            if (!username.equals(name) || isTokenExpired(token)){
                // 若用户名不匹配或者令牌已到期
                return false;
            }else if (!extractIssuer(token).equals(issuer)){
                // 若签发者不匹配
                return false;
            }else if (!extractIssuedAt(token).before(new Date())||!extractIssuedAt(token).after(extractNotBefore(token))){
                // 若签发时间不在指定区间
                return false;
            }else if (!aud.contains(extractAudience(token))){
                // 若预期接收对象列表中找不到此接收对象
                return false;
            }else {
                // 若jwt的id不存在，则无效 // NOTE: 验证id是否存在已生成的名单中
                return jtiSet.contains(extractId(token));
            }

        }catch (Exception e) {
            // 解析异常信息
            if (e instanceof PrematureJwtException) {
                String message = e.getMessage();

                // 使用正则表达式提取毫秒差值
                String regex = "a difference of (\\d+) milliseconds";
                java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(regex);
                java.util.regex.Matcher matcher = pattern.matcher(message);

                if (matcher.find()) {
                    String millisecondsString = matcher.group(1);
                    long millisecondsDifference = Long.parseLong(millisecondsString);
                    SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
                    sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
                    System.out.println("令牌未到生效时间！距离生效时间剩余：");
                    System.out.println(sdf.format(millisecondsDifference));
                } else {
                    System.out.println("在异常信息中未找到相差的毫秒数");
                }
            } else {
                System.out.println("发生了一个jwt预期外的错误: " + e.getMessage());
            }

            return false;
        }
    }
    
    @Override
    public void onApplicationEvent(ApplicationReadyEvent applicationReadyEvent) {
        // 在应用启动完成后生成新的密钥
        generateNewJwtSecretKey();
    }

    /**
     * 自动生成jwt密钥
     * @author peter
     * @date 2024/11/8
     * @className JwtUtil
     * @packageName com.msrl.zhibo.utils
     */
    private void generateNewJwtSecretKey() {
        // 若生成密钥的模式为自定义，则取消每次启动项目时自动生成
        if (secret_mode.getValue()==1) {
            System.out.println("jwt密钥策略：静态自定义(CUSTOM)");
            System.out.println("jwt当前密钥："+SECRET);
            return;
        }
        // 生成一个随机的密钥
        SecureRandom secureRandom = new SecureRandom();
        byte[] secretKeyBytes = new byte[32];  // 256-bit key
        secureRandom.nextBytes(secretKeyBytes);

        // 将密钥转为Base64编码
        SECRET = Base64.getEncoder().encodeToString(secretKeyBytes);

        System.out.println("jwt密钥策略：\u001B[34;1m动态生成(AUTO)\u001B[0m");
        System.out.println("jwt当前密钥：\u001B[34;1m"+SECRET+"\u001B[0m");

        // 你可以选择将这个密钥存储在数据库或外部配置管理系统中
    }

    // 可以提供一个获取JWT密钥的方法
    public String getJwtSecretKey() {
        return SECRET;
    }
    @Getter
    enum SecretType{
        AUTO(0),
        CUSTOM(1);
        private final int value;

        SecretType(int value) {
            this.value = value;
        }
    }

    // 主测试程序入口
    public static void main(String[] args){

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        JwtTokenUtil jwtTokenUtil = new JwtTokenUtil();
        String token = jwtTokenUtil.generateToken("admin");
        System.out.println("生成的Token:\n"+token);

        Map<String,String> map = jwtTokenUtil.extractHeader(token);
        System.out.println("请求头消息：");
        System.out.println("类型:"+map.get("typ"));
        System.out.println("签名算法:"+map.get("alg"));
        System.out.println("######################");
        String jti = jwtTokenUtil.extractId(token);
        System.out.println("导出jwt唯一id:"+jti);
        String username = jwtTokenUtil.extractSubject(token);
        System.out.println("导出用户名:"+username);
        Date date2 = jwtTokenUtil.extractNotBefore(token);
        System.out.println("导出令牌生效时间:"+sdf.format(date2));
        Date date = jwtTokenUtil.extractExpiration(token);
        System.out.println("导出令牌到期时间:"+sdf.format(date));
        String s = jwtTokenUtil.extractAudience(token);
        System.out.println("导出接收者:"+s);
        String issuer = jwtTokenUtil.extractIssuer(token);
        System.out.println("导出签发者:"+issuer);
        Date date1 = jwtTokenUtil.extractIssuedAt(token);
        System.out.println("导出签发时间:"+sdf.format(date1));
        Boolean tokenExpired = jwtTokenUtil.isTokenExpired(token);
        System.out.println("jwt是否过期:"+tokenExpired);
        Boolean flag = jwtTokenUtil.validateTokenEnhance(token, "admin");
        System.out.println("令牌验证:"+flag);
        System.out.println("/////////////////////////////////////");
        String token1 = jwtTokenUtil.generateToken("user");
        System.out.println("生成的Token:\n"+token1);
        Map<String,String> map1 = jwtTokenUtil.extractHeader(token1);
        System.out.println("请求头消息：");
        System.out.println("类型:"+map1.get("typ"));
        System.out.println("签名算法:"+map1.get("alg"));
        System.out.println("######################");
        String jti1 = jwtTokenUtil.extractId(token1);
        System.out.println("导出jwt唯一id:"+jti1);
        String username1 = jwtTokenUtil.extractSubject(token1);
        System.out.println("导出用户名:"+username1);
        Date date22 = jwtTokenUtil.extractNotBefore(token1);
        System.out.println("导出令牌生效时间:"+sdf.format(date22));
        Date date3 = jwtTokenUtil.extractExpiration(token1);
        System.out.println("导出令牌到期时间:"+sdf.format(date3));
        String s3 = jwtTokenUtil.extractAudience(token1);
        System.out.println("导出接收者:"+s3);
        String issuer3 = jwtTokenUtil.extractIssuer(token1);
        System.out.println("导出签发者:"+issuer3);
        Date date13 = jwtTokenUtil.extractIssuedAt(token1);
        System.out.println("导出签发时间:"+sdf.format(date13));
        Boolean tokenExpired3 = jwtTokenUtil.isTokenExpired(token1);
        System.out.println("jwt是否过期:"+tokenExpired3);
        Boolean flag3 = jwtTokenUtil.validateTokenEnhance(token1, "user");
        System.out.println("令牌验证:"+flag3);
        System.out.println("/////////////////////////////////////");
        System.out.println(jwtTokenUtil.jtiSet);
    }
}