JWT 关于登录时的鉴权校验以及Token令牌的签发

JSON Web Token（JWT）是一个非常轻巧的规范。这个规范允许我们使用JWT在用户和
服务器之间传递安全可靠的信息。
完整的JWT其实是一个字符串,分为头部(header),载荷(playload),签证(signature)三个部分。
头部中存放类型,加密算法信息
载荷存放有效信息,类似主题,过期时间,用户id,权限等用户基本信息,可以使用json
签证存放的信息类似秘钥,它的作用是防止令牌被篡改,可以用它来解析token令牌,它是由前两部分信息被base64编码之后,然后通过header中声明的加密方式进行加盐secret组合加密得到的
三部分的base64编码字符串拼接后得到完整JWT

JWT令牌的优势？

假设现在有一个APP，后台是分布式系统。APP的首页模块部署在杭州机房的服务器上，子页面模块部署在深圳机房的服务器上。此时你从首页登录了该APP，然后跳转到子页面模块。session在两个机房之间不能同步，用户是否需要重新登录？传统的方式（cookie+session）需要重新登录，用户体验不好。session共享（在多台物理机之间传输和复制session）方式对网络IO的压力大，延迟太长，用户体验也不好。JWT相当于将session保存在了客户端，解决了后台session复制的问题

JJWT 签发与验证token

1.创建token
先导入依赖:

jjwt

token创建如下:

    JwtBuilder builder = Jwts.builder();
    long currentTimeMillis = System.currentTimeMillis();
    Date date = new Date(currentTimeMillis+100000);
    builder.setId("455").setSubject("设置主题 可json").setIssuedAt(new Date()).claim("naem","zhansgan").setExpiration(date).signWith(SignatureAlgorithm.HS256,"设置签名");
    System.out.println("token:" +builder.compact());

token解析如下:

 String token="eyJhbGciOiJIUzI1NiJ9.eyJqdGkiOiI0NTUiLCJzdWIiOiLorr7nva7kuLvpopgg5Y-vanNvbiIsImlhdCI6MTU5NTE2MDU3NSwibmFlbSI6InpoYW5zZ2FuIiwiZXhwIjoxNTk1MTYwNjc1fQ.uIpKzOpLHxRQT-INGlOLalITcRD2H7p-qxHEGAtpoTY";
        Claims zhangsan = Jwts.parser().setSigningKey("zhangsan").parseClaimsJws(token).getBody();

使用JWT完成登录操作

用户访问客户端发起请求,请求先通过网关服务,在网关设置过滤器,拦截请求,如果是登录请求可以放行,否则只有在cookie头中携带正确JWTtoken令牌的请求才能放行访问被保护的资源服务
使用了jwt工具类来生成令牌和解析令牌,工具类:

package com.changgou.system.util;

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

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

/**
 * JWT工具类
 */
public class JwtUtil {

    //有效期为
    public static final Long JWT_TTL = 3600000L;// 60 * 60 *1000  一个小时
    //设置秘钥明文
    public static final String JWT_KEY = "itcast";

    /**
     * 创建token
     * @param id
     * @param subject
     * @param ttlMillis
     * @return
     */
    public static String createJWT(String id, String subject, Long ttlMillis) {

        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        if(ttlMillis==null){
            ttlMillis=JwtUtil.JWT_TTL;
        }
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        SecretKey secretKey = generalKey();

        JwtBuilder builder = Jwts.builder()
                .setId(id)              //唯一的ID
                .setSubject(subject)   // 主题  可以是JSON数据
                .setIssuer("admin")     // 签发者
                .setIssuedAt(now)      // 签发时间
                .signWith(signatureAlgorithm, secretKey) //使用HS256对称加密算法签名, 第二个参数为秘钥
                .setExpiration(expDate);// 设置过期时间
        String compact = builder.compact();
        System.out.println(compact);
        return builder.compact();
    }

    /**
     * 生成加密后的秘钥 secretKey
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }
    
    /**
     * 解析
     *
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(jwt).getBody();
    }
}

过滤器具体代码:

package com.changgou.system.filter;

import com.changgou.system.util.JwtUtil;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
@Component
public class AuthorizeFilter implements GlobalFilter, Ordered {
    private static final String AUTHORIZE_TOKEN="token";
    @Override
    public Mono filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1.获得请求对象
        ServerHttpRequest request = exchange.getRequest();
        //2.获得响应对象
        ServerHttpResponse response = exchange.getResponse();
        //3.判断是否为登录请求
        if (request.getURI().getPath().contains("/admin/login")){
            return chain.filter(exchange);
        }
        //4.判断请求头中是否有token
        String token = request.getHeaders().getFirst(AUTHORIZE_TOKEN);
        if (StringUtils.isEmpty(token)){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
           return response.setComplete();
        }
        try {
            //5.取到令牌,解析令牌
            JwtUtil.parseJWT(token);
        } catch (Exception e) {
            //6.出错表示解析的令牌过期或者伪造
            e.printStackTrace();
           return response.setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return 0;
    }
}