springboot2.x jwt token登录校验，全局拦截

什么是jwt？
jwt （json web token），是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为JSON对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。

jwt结构
jwt 有三部分组成：头Header，有效载荷Payload，签名Signature；

头Header

header典型的由两部分组成：token的类型（“JWT”）和算法名称

{
    'alg': "HS256",
    'typ': "JWT"
}

然后，用Base64对这个JSON编码就得到JWT的第一部分.

有效载荷Payload

它包含声明（要求）。声明是关于实体(通常是用户)和其他数据的声明。声明有三种类型: registered, public 和 private。

• Registered claims : 这里有一组预定义的声明，它们不是强制的，但是推荐。比如：iss (issuer), exp (expiration time), sub (subject), aud (audience)等。
• Public claims : 可以随意定义。
• Private claims : 用于在同意使用它们的各方之间共享信息，并且不是注册的或公开的声明。

{
    "sub": '12345',
    "name": 'user',
    "admin":true
}

注册的声明
iss: jwt签发者
sub: 面向的用户(jwt所面向的用户)
aud: 接收jwt的一方
exp: 过期时间戳(jwt的过期时间，这个过期时间必须要大于签发时间)
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token,从而回避重放攻击。

对payload进行Base64编码就得到JWT的第二部分
注意，不要在JWT的payload或header中放置敏感信息，除非它们是加密的。

签名Signature

为了得到签名部分，你必须有编码过的header、编码过的payload、一个秘钥，签名算法是header中指定的那个，然对它们签名即可。

jwt流程图：

https://jwt.io/#libraries-io

官网地址：https://jwt.io/#libraries-io

springboot2.x集成jwt

pom.xml添加jwt依赖

    <!--jwt (json web token) token 生成 校验-->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>

生成和解析token的工具类
1.对称加密算法

/**
 *  json web token
 * 生成和解析token的工具类
 * 对称加密算法
 *
 */
public class JwtTokenUtils {
    SecretKeySpec key;
    /**
     *
     * @param key
     * 密钥
     */
    public JwtTokenProvider(String key){
        SecretKeySpec secretKeySpec = new SecretKeySpec(key.getBytes(),
                SignatureAlgorithm.HS512.getJcaName());
        this.key=secretKeySpec;
    }
    /**
     * 生成token
     * @return
     */
    public String createToken(Claims claims){
        return Jwts.builder()
                .setHeaderParam("type","jwt")
//                .compressWith(CompressionCodecs.DEFLATE) //内容压缩
                .setClaims(claims) //jwt 主体内容
                .signWith(SignatureAlgorithm.HS512,key) //签名方式
                .compact(); //生成
    }
    /**
     *校验token
     * @param token
     * @return
     */
    public Claims parseToken(String token){
        try {
            return Jwts.parser()
                  .setSigningKey(key)
                  .parseClaimsJws(token)
                  .getBody();
        }catch (Exception e){
             return null;
        }
    }
    /**
     * Claims 初始化token有效时间 秒
     *  7天 单位秒  604800
     * @param expire 初始化token有效时间 秒
     * @return
     */
    public DefaultClaims getDefaultClaims(long expire) {
        Claims claims = initClaims(new DefaultClaims(), expire);
        return (DefaultClaims) claims;
    }
    /**
     * 设置token有效期
     * @param claims
     * @param expire
     * @return
     */
    public Claims setClaimsExpire(Claims claims,long expire) {
        return initClaims(claims, expire);
    }
    public Claims initClaims(Claims claims, long expire) {
        if (claims!=null && expire>0) {
            Date nowDate = new Date();
            Date expireDate = new Date(nowDate.getTime()+expire*1000);
            claims.setIssuedAt(nowDate);
            claims.setExpiration(expireDate);
        }
        return claims;
    }
  
}

2.非对称加密算法
采用RSA算法

/**
 * RSA 算法 
 */
public class RSAUtils {

    /**
     * 获取公钥
     * @param publicKey
     * @return
     * JDK
     * java.security.spec.X509EncodedKeySpec
     * java.security.KeyFactory
     */
    public static PublicKey getPublicKey(byte[] publicKey) {
        X509EncodedKeySpec spec = new X509EncodedKeySpec(publicKey);
        KeyFactory kf = null;
        try {
            kf = KeyFactory.getInstance("RSA");
            return kf.generatePublic(spec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取私钥
     * @param privateKey
     * @return
     * JDK
     * java.security.spec.PKCS8EncodedKeySpec
     * java.security.KeyFactory
     */
    public static PrivateKey getPrivateKey(byte[] privateKey){
        PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(privateKey);
        try {
            KeyFactory kf = KeyFactory.getInstance("RSA");
            return kf.generatePrivate(spec);
        }catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 生成公私钥
     *  byte[] publicKeyBytes = keyPair.getPublic().getEncoded();
     *  byte[] privateKeyBytes = keyPair.getPrivate().getEncoded();
     * String publicKey = Base64.getEncoder().encodeToString(publicKeyBytes)
     */
    public static KeyPair generateKey(){
        try {
            KeyPairGenerator keyPairGenerator= KeyPairGenerator.getInstance("RSA");
            SecureRandom secureRandom = new SecureRandom();
            keyPairGenerator.initialize(1024,secureRandom);
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            return keyPair;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

RSAUtils 工具生成公私钥对

/**
 * 生成和解析token的工具类【非对称加密算法版】
 *
 *
 */
public class JwtToken2Utils {

    PublicKey publicKey;
    PrivateKey privateKey;

    public JwtToken2Utils (String publicKey,String privateKey){
        byte[] publicKeyBytes = Base64.getDecoder().decode(publicKey);
        byte[] privateKeyBytes = Base64.getDecoder().decode(privateKey);

        try {
            X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(publicKeyBytes);
            KeyFactory publicKeyFactory = KeyFactory.getInstance("RSA");
            this.publicKey = publicKeyFactory.generatePublic(publicKeySpec);

            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(privateKeyBytes);
            KeyFactory privateKeyFactory = KeyFactory.getInstance("RSA");
            this.privateKey = privateKeyFactory.generatePrivate(privateKeySpec);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (InvalidKeySpecException e) {
            e.printStackTrace();
        }
    }
    public JwtToken2Utils (KeyPair  keyPair){
         this.publicKey = keyPair.getPublic();      
         this.privateKey =keyPair.getPrivate();        
    }

    /**
     * 生成token
     * @param claims
     * @return
     */
    public String createToken(Claims claims){
        return Jwts.builder()
                .setHeaderParam("type","jwt")
                .setClaims(claims) //claims，就是自定义的playload部分
//                .compressWith(CompressionCodecs.DEFLATE) //内容压缩
                .signWith(SignatureAlgorithm.RS512,privateKey) //签名用私钥
                .compact();
    }

    /**
     *
     * @param token
     * @return
     */
    public Claims parseToken(String token){
        Claims claims = Jwts.parser()
                .setSigningKey(publicKey)
                .parseClaimsJws(token)
                .getBody();
        return claims;
    }

    /**
     * Claims 初始化token有效时间 秒
     *  7天 单位秒  604800
     * @param expire
     * @return
     */
    public DefaultClaims getDefaultClaims(long expire) {
        Claims claims = initClaims(new DefaultClaims(), expire);
        return (DefaultClaims) claims;
    }

    /**
     * 设置token有效期
     * @param claims
     * @param expire
     * @return
     */
    public Claims setClaimsExpire(Claims claims,long expire) {
        return initClaims(claims, expire);
    }

    public Claims initClaims(Claims claims, long expire) {
        if (claims!=null && expire>0) {
            Date nowDate = new Date();
            Date expireDate = new Date(nowDate.getTime()+expire*1000);
            claims.setIssuedAt(nowDate);
            claims.setExpiration(expireDate);
        }
        return claims;
    }

}

拦截器Interceptor 拦截请求，校验jwt

自定义注解，用于过滤请求方法

/**
 * 自定义 注解
 * 是否需要校验jwt
 *
 * @Target:注解的作用目标
 * @Target(ElementType.TYPE)——接口、类、枚举、注解
 * @Target(ElementType.FIELD)——字段、枚举的常量
 * @Target(ElementType.METHOD)——方法
 * @Target(ElementType.PARAMETER)——方法参数
 * @Target(ElementType.CONSTRUCTOR) ——构造函数
 * @Target(ElementType.LOCAL_VARIABLE)——局部变量
 * @Target(ElementType.ANNOTATION_TYPE)——注解
 * @Target(ElementType.PACKAGE)——包
 *
 *@Retention：注解的保留位置
 *RetentionPolicy.SOURCE:这种类型的Annotations只在源代码级别保留,编译时就会被忽略,在class字节码文件中不包含。
 * RetentionPolicy.CLASS:这种类型的Annotations编译时被保留,默认的保留策略,在class文件中存在,但JVM将会忽略,运行时无法获得。
 * RetentionPolicy.RUNTIME:这种类型的Annotations将被JVM保留,所以他们能在运行时被JVM或其他使用反射机制的代码所读取和使用。
 * @Document：说明该注解将被包含在javadoc中
 * @Inherited：说明子类可以继承父类中的该注解
 *
 *
 *
 */
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginJWT {

    boolean required() default true;

}

自定义拦截Interceptor

/**
 * 自定义拦截器后，需要配置进Spring
 *
 * 拦截器Interceptor可以拿到原始的HTTP请求和响应的信息，
 *    也可以拿到你真正处理请求方法的信息，但是拿不到传进参数的那个值。
 *
 *拦截顺序：filter—>Interceptor-->ControllerAdvice-->@Aspect -->Controller
 *
 */
@Slf4j
@Component
public class JwtInterceptor implements HandlerInterceptor {

    @Value("${learn.jwt.secret}")
    private String secretKey;

    JwtTokenProvider jwtTokenProvider;

    /**
     * 在访问Controller某个方法之前这个方法会被调用。
     * @param request
     * @param response
     * @param handler
     * @return false则表示不执行postHandle方法,true 表示执行postHandle方法
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("Token Interceptor preHandle ");

        if ( !(handler instanceof HandlerMethod)){
            return true;//如果不是映射到方法直接通过
        }

        String token = request.getHeader("token");

        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        //检查有没有需要用户权限的注解
        if (method.isAnnotationPresent(LoginJWT.class)){
            LoginJWT loginJWT = method.getAnnotation(LoginJWT.class);
            if (loginJWT.required()){
                // 执行认证
                if (token == null) {
                    throw new RuntimeException("无token，请重新登录");
                }
                //校验token是否有效
                jwtTokenProvider = new JwtTokenProvider(secretKey);
                Claims claims = jwtTokenProvider.parseToken(token);
                log.info("Token Interceptor preHandle claims :{}",claims);
                if (claims!=null){
                    log.info("Token Interceptor preHandle claims 有效" );
                }else {//过期了
                    //抛出异常
                    log.info("Token Interceptor preHandle claims 过期");
                    returnJson(response);//返回前端异常
                    return false;//不执行下一步chain链,直接repose返回
                }
                return true;
            }
        }

        return true;//false则表示不执行postHandle方法
    }

    /**
     * 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）
     * preHandle方法处理之后这个方法会被调用，如果控制器Controller出现了异常，则不会执行此方法
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("Token Interceptor postHandle");
    }

    /**
     * 不管有没有异常，这个afterCompletion都会被调用
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("Token Interceptor afterCompletion");
    }
}
/**
     * 返回异常结果
     * @param response
     */
    private void returnJson(HttpServletResponse response){
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json; charset=utf-8");
        try {
            Map<String, Object> result = new HashMap<>();
            result.put("code",400);
            result.put("message","用户令牌token无效");
            result.put("data", null);
            response.getWriter().print(result);
        } catch (IOException e){

        } finally {

        }
    }

在需要jwt验证的controller的方法上加上注解LoginJWT

   @GetMapping("/test")
    @LoginJWT
    public String test(){
        return "test";
    }