JWT认证原理、流程整合springboot

1、JWT 简介

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和服务器之间传递安全可靠的信息。

一个JWT实际上就是一个字符串，它由三部分组成，头部、载荷与签名。

• 头部（Header）

头部用于描述关于该JWT的最基本的信息，例如其类型以及签名所用的算法等。这也可以被表示成一个JSON对象。
{“typ”:“JWT”,“alg”:“HS256”}

在头部指明了签名算法是HS256算法。 我们进行BASE64编码http://base64.xpcha.com/，编码后的字符串如下：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

• 载荷（playload）

载荷就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分

（1）标准中注册的声明（建议但不强制使用）

iss: jwt签发者
sub: jwt所面向的用户
aud: 接收jwt的一方
exp: jwt的过期时间，这个过期时间必须要大于签发时间
nbf: 定义在什么时间之前，该jwt都是不可用的.
iat: jwt的签发时间
jti: jwt的唯一身份标识，主要用来作为一次性token。

（2）公共的声明

公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息.但不建议添加敏感信息，因为该部分在客户端可解密.

（3）私有的声明

私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息。

这个指的就是自定义的claim。比如前面那个结构举例中的admin和name都属于自定的claim。这些claim跟JWT标准规定的claim区别在于：JWT规定的claim，JWT的接收方在拿到JWT之后，都知道怎么对这些标准的claim进行验证(还不知道是否能够验证)；而private claims不会验证，除非明确告诉接收方要对这些claim进行验证以及规则才行。

定义一个payload:

{"sub":"1234567890","name":"John Doe","admin":true}

然后将其进行base64加密，得到Jwt的第二部分。

eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9

• 签证（signature）

jwt的第三部分是一个签证信息，这个签证信息由三部分组成：

header (base64后的)

payload (base64后的)

secret

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了jwt的第三部分。

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4i

2、整合spring boot

1、引入依赖

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

2、封装JWT工具类（使用双重验证的单例模式，多线程模式下依然可用）

package com.dev.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;

import java.util.Calendar;
import java.util.Map;

//多线程下的双重验锁机制
public class JWTUtils {
    private volatile static JWTUtils jwtUtils;
    private final static Integer SESSION_TTL=60;//过期时间一分钟
    private final static String SECRT="@#!saSSdshfvsswaa4621987";
    public static JWTUtils getJwtUtils(){
        if(jwtUtils==null){
            synchronized (JWTUtils.class){
                if(jwtUtils==null){
                    jwtUtils=new JWTUtils();
                }
            }
        }
        return jwtUtils;
    }

    //设置token
    public static String getTocken(Map<String,String> map){
        JWTCreator.Builder builder = JWT.create();
        map.forEach((k,v)->{
            builder.withClaim(k,v);
        });
        Calendar instance = Calendar.getInstance();
        instance.add(Calendar.SECOND,SESSION_TTL);//设置过期时间，单位为秒
        builder.withExpiresAt(instance.getTime());//过期时间设置为 60秒
        String sign = builder.sign(Algorithm.HMAC256(SECRT));//设置签名
        return sign;
    }

    //验证签名
    public static DecodedJWT verify(String token){
        DecodedJWT require = JWT.require(Algorithm.HMAC256(SECRT)).build().verify(token);
        return require;
    }
}

3、在网关（推荐）或者为微服务项目中定义JWT拦截器

package com.interceptors;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.InvalidClaimException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.dev.util.JWTUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.log4j.Log4j2;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.*;
import java.security.SignatureException;
import java.util.HashMap;
import java.util.Map;

/**
 * gateway的JWT拦截器
 * 代码地址：https://gitee.com/chillyCUI/springboot-jwt-2020
 */
@Log4j2
public class JWTInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, javax.servlet.http.HttpServletResponse response, Object handler) throws Exception {

        String token = request.getHeader("token");
        log.info("toker:[{}]", token);

        Map<String, Object> map = new HashMap<>();

        try {
            JWTUtils.verify(token);
            return true;
        } catch (SignatureVerificationException e) {
            e.printStackTrace();
            map.put("msg", "签名不一致");
        } catch (TokenExpiredException e) {
            e.printStackTrace();
            map.put("msg", "令牌过期");
        } catch (AlgorithmMismatchException e) {
            e.printStackTrace();
            map.put("msg", "算法不匹配");
        } catch (InvalidClaimException e) {
            e.printStackTrace();
            map.put("msg", "失效的payload");
        } catch (Exception e) {
            e.printStackTrace();
            map.put("msg", "token无效");
        }

        map.put("state", false);

        //响应到前台: 将map转为json
        String json = new ObjectMapper().writeValueAsString(map);
        response.setContentType("application/json;charset=UTF-8");
        response.getWriter().println(json);
        return false;
    }
}

4、配置JWT拦截器

package com.dev.config;

import com.dev.interceptors.JWTInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer{

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new JWTInterceptor())
                .addPathPatterns("/index/getOrder")//添加需要验证的路由
                .excludePathPatterns("/index/setToken");//不需要验证的路由
    }
}

5、使用

package com.dev.app;

import com.auth0.jwt.interfaces.DecodedJWT;
import com.dev.entity.LogsEntity;
import com.dev.feign.IndexFeignS;
import com.dev.util.JWTUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

@RestController
@RequestMapping("/index")
public class IndexController {

    @RequestMapping("/setToken")
    public String setToken(HttpServletRequest request){
        Map<String, String> map = new HashMap<>();
        map.put("userName",(request.getParameter("userName")!=null)?request.getParameter("userName").toString():"默认字符串");
        String str = JWTUtils.getJwtUtils().getTocken(map);
        return str;
    }

    @RequestMapping("/getOrder")
    public String mqInserts(HttpServletRequest request){
        String token = request.getHeader("token").toString();
        DecodedJWT verify = JWTUtils.getJwtUtils().verify(token);//验证token并获取 token里面的信息
        String name = verify.getClaim("userName").asString();
        return name;
    }

}

3、测试（postman）

1、模拟登录,获取token

2、在头信息中获取token