微服务网关和Jwt令牌 入门学习！

{"typ":"JWT","alg":"HS256"}   	//头部指明了签名算法是HS256算法;

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9   		#这就是通常JWT的头部.存放着签名的算法信息！

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

{"sub":"1234567890","name":"John Doe","admin":true}    
//sub   通常表示用户id 
//name 	用户名
//admin 是否管理员

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.TJVA95OrM7E2cBab30RMHrHDcEfxjoYZgeFONFh7HgQ

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

package com.wsm.jwt;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwtBuilder;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

//JWT 测试类
public class TestJWT {

    public static void main(String[] args) {
        //打印: 创建的JWT
        String jwt = createToken();
        System.out.println(jwt);

        System.out.println("---------------------------------------------------------------------------------------");

        //打印: JWT的解析数据
        System.out.println(getToken(jwt));
    }

    //创建 JWT
    public static String createToken() {

        JwtBuilder jwt = Jwts.builder()
                .setId("110")                                    //设置唯一编号
                .setSubject("{'id':1,'name':'张三'}")            //设置主题,可以是JSON数据(一般是要存储的用户信息！)
                .setIssuedAt(new Date())                        //设置签发日期
                .signWith(SignatureAlgorithm.HS256, "xzzb");  //设置签名 使用HS256算法，并设置SecretKey(字符串)

        String compact = jwt.compact();                          //生成 JWT;
        return compact;
    }

    //解析 JWT
    public static String getToken(String token) {
        //调用 Jwts.parser(); 方法完成解析;
        Claims xzzb = Jwts.parser()
                .setSigningKey("xzzb")  //明确Secret 解析私钥;
                .parseClaimsJws(token)  //要解析的Token;
                .getBody();             //JSON 格式;

        return xzzb.toString();         //返回！
    }
}

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;

public class JwtUtil {

    //有效期为
    public static final Long JWT_TTL = 3600000L;// 60 * 60 *1000  一个小时

    //Jwt令牌信息
    public static final String JWT_KEY = "xzzb";

    /**
     * 生成加密 secretKey
     *
     * @return
     */
    public static SecretKey generalKey() {
        byte[] encodedKey = Base64.getEncoder().encode(JwtUtil.JWT_KEY.getBytes());
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");
        return key;
    }

    /**
     *
     * @param id        jwt 唯一id
     * @param subject   设置主题,可以是JSON数据(一般是要存储的用户信息！)
     * @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);
        //如果令牌有效期为null，则默认设置有效期1小时
        if (ttlMillis == null) {
            ttlMillis = JwtUtil.JWT_TTL;
        }
        //令牌过期时间设置
        long expMillis = nowMillis + ttlMillis;
        Date expDate = new Date(expMillis);
        //生成秘钥
        SecretKey secretKey = generalKey();

        //封装Jwt令牌信息
        JwtBuilder builder = Jwts.builder()
                .setId(id)                    //唯一的ID
                .setSubject(subject)          // 主题  可以是JSON数据
                .setIssuer("admin")          // 签发者
                .setIssuedAt(now)             // 签发时间
                .signWith(signatureAlgorithm, secretKey) // 签名算法以及密匙
                .setExpiration(expDate);      // 设置过期时间
        return builder.compact();
    }

    /**
     * 解析令牌数据
     *
     * @param jwt
     * @return
     * @throws Exception
     */
    public static Claims parseJWT(String jwt) throws Exception {
        SecretKey secretKey = generalKey();
        return Jwts.parser()
                .setSigningKey(secretKey)
                .parseClaimsJws(jwt)
                .getBody();
    }
}

    /**
     * @param name 用户名
     * @param pwd 密码
     * @return
     */
    public HashMap<String, Object> userLogin(String name, String pwd) {
        //登录
        if (name.equals("admin") && pwd.equals("123")) {
            HashMap<String, Object> user = new HashMap<>();
            user.put("id", 1);
            user.put("username", name);
            user.put("passwd", pwd);
            return user;
        }
        return null;
    }

    //执行登录方法！
    @PostMapping("/login")
    public HashMap<String, Object> login(String name, String pwd) {
        HashMap<String, Object> user = userService.userLogin(name, pwd);
        if (user != null) {

            String jwt = JwtUtil.createJWT(UUID.randomUUID().toString(), JSON.toJSONString(user), null);
            HashMap<String, Object> result = new HashMap<>();
            result.put("code", "1001");
            result.put("token", jwt);
            return result;
        }
        return null;
    }

import com.wsm.jwt.JwtUtil;
import io.jsonwebtoken.Claims;
import lombok.extern.slf4j.Slf4j;
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.apache.commons.lang.StringUtils;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

//Gate way实现过滤器:
@Component
@Slf4j
public class TokenFitter implements GlobalFilter, Ordered {     //自定义过滤器类 实现GlobalFilter Ordered接口并实现两个方法;


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //获取request response
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //获取请求url 打印！
        String path = request.getURI().getPath();
        System.out.println(path);

        //判断请求... 对于请求 /user/login  /api/address/get  这请求网关可以直接放行...
        //对于一些操作本身就是不登录也可也访问...   登录请求当然直接放行,本身就是登录才有Token 不登录那里来Token 放行!
        if(path.startsWith("/user/login") || path.startsWith("/api/address/get")){
           	System.out.println("Token登录 网关同行！！");
            return chain.filter(exchange);
        }
        //获取请求中的Token       从请求头中获取Token
        String token = request.getHeaders().getFirst("token");
        //不存在 则从请求中查找, 有没有Token
        if(StringUtils.isEmpty(token)){
            token=request.getQueryParams().getFirst("token");
        }
        //还不存在则,拦截器拦截！
        if(StringUtils.isEmpty(token)){
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }


        try {
            //验证Token 是否存在/合法...
            Claims claims = JwtUtil.parseJWT(token);        //不合法出现异常,也直接请求拦截！！
        } catch (Exception e) {
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //以上都成立, 放行！！
        return chain.filter(exchange);
    }

    //过滤顺序级别
    @Override
    public int getOrder() {
        return 0;
    }
}