Gateway：全局过滤器配置

全局过滤器配置

依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
     <groupId>io.jsonwebtoken</groupId>
     <artifactId>jjwt</artifactId>
     <version>0.9.0</version>
 </dependency>
 <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.62</version>
</dependency>

过滤器

import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.common.collect.Maps;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthFilter implements GlobalFilter, Ordered {

    @Value("#{'${gateway.excludedUrls}'.split(',')}")
    private List<String> excludedUrls;

    @Value("${gateway.secret}")
    private String secret;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        //获取响应对象
        ServerHttpResponse response = exchange.getResponse();

        //获取当前请求路径
        String path = exchange.getRequest().getURI().getPath();
        //排除特殊不需要令牌的路径
        if (excludedUrls.contains(path)){
            return chain.filter(exchange);
        }

        //获取令牌信息
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");

        if (StringUtils.isNotEmpty(token)){
            //合法性进行判断
            JWTUtil.VerifyResult verifyResult = JWTUtil.verifyJwt(token, secret);
            if (verifyResult.isValidate()){
                //令牌校验通过
                return chain.filter(exchange);
            }else{
                //令牌校验不通过
                Map<String,Object> responseData = Maps.newHashMap();
                responseData.put("code",verifyResult.getCode());
                responseData.put("message","验证失败");
                return responseError(response,responseData);
            }
        }else{
            //令牌不存在
            //返回错误信息
            Map<String,Object> responseData = Maps.newHashMap();
            responseData.put("code",401);
            responseData.put("message","非法请求");
            responseData.put("cause","token is empty");
            return responseError(response,responseData);
        }
    }

    //返回响应数据
    private Mono<Void> responseError(ServerHttpResponse response, Map<String, Object> responseData) {

        //将信息转换为json
        ObjectMapper objectMapper = new ObjectMapper();
        byte[] data = new byte[0];
        try{
            data = objectMapper.writeValueAsBytes(responseData);
        }catch (Exception e){
            e.printStackTrace();
        }

        //输出结果数据
        DataBuffer buffer = response.bufferFactory().wrap(data);
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        response.getHeaders().add("Content-Type","application/json;charset=utf-8");
        return response.writeWith(Mono.just(buffer));
    }

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

JWT工具类

import com.alibaba.fastjson.JSON;
import io.jsonwebtoken.*;
import org.apache.commons.codec.binary.Base64;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;


public class JWTUtil{
    /**
     * 签发JWT
     * @param tokenMap
     * @param secret
     * @return
     * @throws IOException
     */
    public static String createJWTByObj(Map<String, Object> tokenMap, String secret) throws IOException {
        SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;

        SecretKey secretKey = generalKey(secret);

        ZoneId zoneId = ZoneId.systemDefault();
        ZonedDateTime zdt = LocalDateTime.now().plusDays(3).atZone(zoneId);

        //添加构成JWT的参数
        JwtBuilder builder = Jwts.builder().setHeaderParam("typ", "JWT")
                .setId("myApp") //签发应用Id
                .setIssuedAt(Date.from(zdt.toInstant())) //签发时间
                .setHeaderParam("alg", "HS256")  //加密算法
                .addClaims(tokenMap)
                .setExpiration(Date.from(zdt.toInstant()))  //设置过期时间
                .signWith(signatureAlgorithm, secretKey);  //用密钥签名


        //生成JWT
        return builder.compact();
    }

    /**
     * 验证jwt
     */
    public static VerifyResult verifyJwt(String token, String secret) {
        //签名秘钥，和生成的签名的秘钥一模一样
        SecretKey key = generalKey(secret);
        try {

            ZoneId zoneId = ZoneId.systemDefault();
            ZonedDateTime zdt = LocalDateTime.now().atZone(zoneId);
            Jwt jwt = Jwts.parser()
                    .setSigningKey(key)
                    .parse(token);


            Date date = ((Claims) jwt.getBody()).getExpiration();
            if (date == null) {
                return new VerifyResult(false, 5002);
            }
            LocalDateTime expires = LocalDateTime.ofInstant(date.toInstant(), ZoneId.systemDefault());
            if (expires.isBefore(LocalDateTime.now())) {
                return new VerifyResult(false, 5001);
            }

            return new VerifyResult(true, 200);
        } catch (Exception e) {
            e.printStackTrace();

            return new VerifyResult(false, 5002);
        }//设置需要解析的jwt
    }

    public static Map<String,Object> decode(String token) throws IOException {
        
        String bodyData = token.split("\\.")[1];

        String bodyStr = new String(Base64.decodeBase64(bodyData),"UTF-8");
        return JSON.parseObject(bodyStr,Map.class);
    }

    /**
     * 生成key
     *
     * @param jwtSecret
     * @return
     */
    private static SecretKey generalKey(String jwtSecret) {
        
        String stringKey = jwtSecret;
        byte[] encodedKey = Base64.decodeBase64(stringKey);
        SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");

        return key;
    }

    @Data
    public static class VerifyResult{
        
        private boolean isValidate;
        /**
         * 5001:token过期;5002:无效token;5003:token校验异常
         */
        private int code;

        private Map<String,Object> tokenMap;

        public VerifyResult(boolean isValidate, int code) {
            this.isValidate = isValidate;
            this.code = code;
            System.out.println("1111");
        }
    }
}