JWT与JJWT工具类

JWT

添加依赖

        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.19.1</version>
        </dependency>

工具类

package com.tqw.item.entity;

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.TokenExpiredException;
import com.auth0.jwt.interfaces.Claim;
import org.apache.commons.lang3.StringUtils;

import java.util.Base64;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
/**
 * JWT工具类
 */
public class JWTUtil {

    //过期时间 15分钟
    private static final long EXPIRE_TIME = 15 * 60 * 1000;
    //私钥
    private static final String TOKEN_SECRET = "privateKey";

    /**
     * 生成签名，15分钟过期
     * 根据内部改造，支持6中类型，Integer,Long,Boolean,Double,String,Date
     *
     * @param map
     * @return
     */
    public static String sign(Map<String, Object> map) {
        try {
            // 设置过期时间
            Date date = new Date(System.currentTimeMillis() + EXPIRE_TIME);
            // 私钥和加密算法
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            // 设置头部信息
            Map<String, Object> header = new HashMap<>(2);
            header.put("typ", "jwt");
            // 返回token字符串
            JWTCreator.Builder builder = JWT.create()
                    .withHeader(header)
                    .withIssuedAt(new Date()) //发证时间
                    .withExpiresAt(date);  //过期时间
            //   .sign(algorithm);  //密钥
            // map.entrySet().forEach(entry -> builder.withClaim( entry.getKey(),entry.getValue()));
            map.entrySet().forEach(entry -> {
                if (entry.getValue() instanceof Integer) {
                    builder.withClaim(entry.getKey(), (Integer) entry.getValue());
                } else if (entry.getValue() instanceof Long) {
                    builder.withClaim(entry.getKey(), (Long) entry.getValue());
                } else if (entry.getValue() instanceof Boolean) {

                    builder.withClaim(entry.getKey(), (Boolean) entry.getValue());
                } else if (entry.getValue() instanceof String) {
                    builder.withClaim(entry.getKey(), String.valueOf(entry.getValue()));
                } else if (entry.getValue() instanceof Double) {
                    builder.withClaim(entry.getKey(), (Double) entry.getValue());
                } else if (entry.getValue() instanceof Date) {
                    builder.withClaim(entry.getKey(), (Date) entry.getValue());
                }
            });
            return builder.sign(algorithm);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }


    /**
     * 检验token是否正确
     *
     * @param **token**
     * @return
     */
    public static boolean verify(String token) {
        try {
            Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
            JWTVerifier verifier = JWT.require(algorithm).build();
            verifier.verify(token);
            return true;
        } catch (Exception e) {
            //e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取用户自定义Claim集合
     *
     * @param token
     * @return
     */
    public static Map<String, Claim> getClaims(String token) {
        Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
        JWTVerifier verifier = JWT.require(algorithm).build();
        Map<String, Claim> jwt = verifier.verify(token).getClaims();
        return jwt;
    }

    /**
     * 获取过期时间
     *
     * @param token
     * @return
     */
    public static Date getExpiresAt(String token) {
        Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
        return JWT.require(algorithm).build().verify(token).getExpiresAt();
    }

    /**
     * 获取jwt发布时间
     */
    public static Date getIssuedAt(String token) {
        Algorithm algorithm = Algorithm.HMAC256(TOKEN_SECRET);
        return JWT.require(algorithm).build().verify(token).getIssuedAt();
    }

    /**
     * 验证token是否失效
     *
     * @param token
     * @return true:过期   false:没过期
     */
    public static boolean isExpired(String token) {
        try {
            final Date expiration = getExpiresAt(token);
            return expiration.before(new Date());
        } catch (TokenExpiredException e) {
            // e.printStackTrace();
            return true;
        }
    }

    /**
     * 直接Base64解密获取header内容
     *
     * @param token
     * @return
     */
    public static String getHeaderByBase64(String token) {
        if (StringUtils.isEmpty(token)) {
            return null;
        } else {
            byte[] header_byte = Base64.getDecoder().decode(token.split("\\.")[0]);
            String header = new String(header_byte);
            return header;
        }
    }

    /**
     * 直接Base64解密获取payload内容
     *
     * @param token
     * @return
     */
    public static String getPayloadByBase64(String token) {

        if (StringUtils.isEmpty(token)) {
            return null;
        } else {
            byte[] payload_byte = Base64.getDecoder().decode(token.split("\\.")[1]);
            String payload = new String(payload_byte);
            return payload;
        }
    }

}

JJWT

添加依赖

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>

工具类

package com.tqw.item.controller;


import io.jsonwebtoken.Claims;
import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JJWT加密工具
 */
public class JwtUtils {

    /**
     *  加密字符串
     */
    private String secret;

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

    /**
     * 生成令牌
     *
     * @param claims     存放进token中的自定义参数（比如：用户名，用户id，客户端ip等等。。。）
     * @param expireTime 当前令牌的过期时间,单位秒
     * @return
     */
    public String setJwt(Map<String, Object> claims, long expireTime) {
        Date nowDate = new Date();
        //过期时间
        Date expireDate = new Date(nowDate.getTime() + expireTime*1000);
        if (claims == null) {
            claims = new HashMap<>();
        }

        return Jwts.builder()
                //存放自定义值
                .setClaims(claims)
                //当前时间
                .setIssuedAt(nowDate)
                //过期时间
                .setExpiration(expireDate)
                //加密
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 校验是不是jwt签名
     * @param token
     * @return
     */
    public boolean isSigned(String token){
        return  Jwts.parser()
                .setSigningKey(secret)
                .isSigned(token);
    }

    /**
     * 解析Claims
     *
     * @param token
     * @return
     */
    private Claims parse(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (ExpiredJwtException e) {
            claims = e.getClaims();
        }
        return claims;
    }

    /**
     * 验证token是否失效
     *
     * @param token
     * @return true:有效   false:无效
     */
    public boolean isExpired(String token) {
        try {
            Claims claim = parse(token);
            //当前时间
            Date date = new Date();
            //token到期时间
            Date expiration = claim.getExpiration();
            return date.before(expiration);
        } catch (Exception exception) {
            return false;
        }
    }

    /**
     * 获取jwt令牌失效时间(单位秒）
     */
    public long getExpirationTime(String token) {
        try {
            Claims claim = parse(token);
            Date expiration = claim.getExpiration();
            long time = (expiration.getTime() - System.currentTimeMillis())/1000;
            return time;
        } catch (Exception e) {
            return -1;
        }
    }

    /**
     * 获取jwt令牌生成时间时间
     */
    public Date getIssuedAtTime(String token) {
        try {
            Claims claim = parse(token);
            return claim.getIssuedAt();
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 获取token信息
     *
     * @param token
     * @return
     */
    public Map<String, Object> getTokenInfo(String token) {
        try {
            Claims claim = parse(token);
            return claim;
        } catch (Exception e) {
            return null;
        }
    }
}