springboot整合jjwt

1.引入依赖

        <!-- base64 -->
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk15on</artifactId>
            <version>1.70</version>
        </dependency>
<!--        jwtBuilder.compact()会用到这个包，JAXB API是java EE 的API，在java SE 9.0 中不再包含这个 Jar 包。 JDK 9 中引入了模块的概念，默认情况下，Java SE中将不再包含java EE 的Jar包,在 JDK 6/7 / 8 时关于这个API 都是捆绑在一起的.-->
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
        </dependency>
<!--        Hutool是一个小而全的Java工具类库，通过静态方法封装，降低相关API的学习成本，提高工作效率，使Java拥有函数式语言般的优雅，让Java语言也可以“甜甜的”。-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.6</version>
        </dependency>
        <dependency>
<!--            实现对象池化组件-->
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt</artifactId>
            <version>0.9.1</version>
        </dependency>
        <dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>4.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.66</version>

2.jwt工具类

package com.example.demo.util;

import com.example.demo.common.constant.JwtConstant;
import com.example.demo.entity.CheckResult;
import io.jsonwebtoken.*;
import org.bouncycastle.util.encoders.Base64;

import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Date;

public class JwtUtils {

    public static String createJWT(String id, String subject, Long ttlMillis) {

        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        SecretKey secretKey = generalKey();
        JwtBuilder jwtBuilder = Jwts.builder()
                .setId(id)
                .setSubject(subject)//主题
                .setIssuer("lydia")   //签发者
                .setIssuedAt(now)  //签发时间
                .signWith(signatureAlgorithm,secretKey);  //签名算法以及秘钥
        if (ttlMillis>=0){
            long expMillis = nowMillis + ttlMillis;
            Date expDate= new Date(expMillis);
            jwtBuilder.setExpiration(expDate);   //过期时间
        }
        return jwtBuilder.compact();
    }

    public static String getJwtToken(String username) {return createJWT(username,username, (long) (60*60*1000));}

    public static CheckResult validateJWT( String jwtStr){

        CheckResult checkResult = new CheckResult();
        Claims claims = null;
        try {
            claims = parseJWT(jwtStr);
             checkResult.setClaims(claims);
             checkResult.setSuccess(true);
        }catch (ExpiredJwtException e) {
            checkResult.setErrCode(JwtConstant.JWT_ERRCODE_EXPIRE);
            checkResult.setSuccess(false);
        }catch (SignatureException e) {
            checkResult.setErrCode(JwtConstant.JWT_ERRCODE_FAIL);
            checkResult.setSuccess(false);
        }catch (Exception e) {
            checkResult.setErrCode(JwtConstant.JWT_ERRCODE_FAIL);
            checkResult.setSuccess(false);
        }
        return checkResult;
    }

    //生成加密key
    public static SecretKey generalKey(){

        byte[] encodedKey = Base64.decode(JwtConstant.JWT_SECRET);
        SecretKey key = new SecretKeySpec(encodedKey,0,encodedKey.length,"AES");
        return key;
    }

    //解析jwt字符串
    public static Claims parseJWT(String jwt){
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJwt(jwt)
                .getBody();
    }

    public static void main(String[] args) {
        String sc = createJWT("1","asdf", (long) (60*60*1000));
        System.out.println(validateJWT(sc).getErrCode());
    }
}

3.CheckResult网络返回状态类

package com.example.demo.entity;

import io.jsonwebtoken.Claims;

public class CheckResult {

    private int errCode;
    private boolean success;
    private Claims claims;

    public int getErrCode() {
        return errCode;
    }

    public void setErrCode(int errCode) {
        this.errCode = errCode;
    }

    public boolean isSuccess() {
        return success;
    }

    public void setSuccess(boolean success) {
        this.success = success;
    }

    public Claims getClaims() {
        return claims;
    }

    public void setClaims(Claims claims) {
        this.claims = claims;
    }
}

4.R网络返回类型类

package com.example.demo.entity;

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

public class R extends HashMap<String,Object> {
    private static final long serialVersionUID = 1l;

    public R() {put("code",200);}

    public static R error(){return error(500,"未知异常，请联系管理员");}
    public static R error(String msg){return error(500,msg);}
    public static R error(int code, String msg) {

        R r = new R();
        r.put("code",code);
        r.put("msg",msg);
        return r;
    }
    public static R ok(){return new R();}

    public static R ok(String msg){
        R r = new R();
        r.put("msg",msg);
        return r;
    }
    public static R ok(Map<String,Object> map){
        R r = new R();
        r.putAll(map);
        return r;
    }
    public R put(String key,Object value){
        super.put(key,value);
        return this;
    }

}