Demo：第四章：Gateway网关

文章目录

• 前言
• 一、项目结构
• 二、步骤
• • 1.pom.xml
  • 2.java代码
• 总结

---

前言

最近搞了一套网关校验，路由分发模块，这里分享出来给大家

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、项目结构

二、步骤

1.pom.xml

代码如下（示例）：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.liaozhiwei</groupId>
    <artifactId>gateway</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>gateway</name>
    <description>gateway</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <parent>
        <artifactId>liaozhiwei</artifactId>
        <groupId>com.liaozhiwei</groupId>
        <version>1.0.0</version>
    </parent>

    <dependencies>
<!--        网关配置-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
            <version>2.2.3.RELEASE</version>
        </dependency>
<!--        spring cloud gateway是基于webflux的，如果非要web支持的话需要导入spring-boot-starter-webflux而不是spring-boot-start-web。-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
<!--        负载均衡器-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <!--        负载-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
        <!-- nacos 依赖 开始-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            <version>2.2.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>2.2.3.RELEASE</version>
        </dependency>
        <!-- nacos 依赖 结束-->
<!--        熔断-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
            <version>2.0.1.RELEASE</version>
        </dependency>
<!--        缓存配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.13</version>
            <scope>compile</scope>
        </dependency>
        <!--添加jwt相关的包开始-->
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.10.5</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.10.5</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.10.5</version>
            <scope>runtime</scope>
        </dependency>
        <!--添加jwt相关的包结束-->
<!--        springboot程序的监控系统,可以实现健康检查,info信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.json</groupId>
            <artifactId>json</artifactId>
            <version>20180130</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>gateway</finalName>
        <plugins>
            <!-- 打包生成fat jar -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.3.4.RELEASE</version>
                <configuration>
                    <mainClass>com.gateway.GatewayApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

2.java代码

IErrorCode

package com.gateway.api;

/**
 * 封装API的错误码
 */
public interface IErrorCode {
    Integer getCode();

    String getMessage();
}

ResultCode

package com.gateway.api;


/**
 * 枚举了一些常用API操作码
 */
public enum ResultCode implements IErrorCode {
    SUCCESS(200, "操作成功"),
    FAILED(500, "操作失败"),
    VALIDATE_FAILED(404, "参数检验失败"),
    UNAUTHORIZED(401, "暂未登录或token已经过期"),
    AUTHORIZATION_HEADER_IS_EMPTY(600,"请求头中的token为空"),
    GET_TOKEN_KEY_ERROR(601,"远程获取TokenKey异常"),
    GEN_PUBLIC_KEY_ERROR(602,"生成公钥异常"),
    JWT_TOKEN_EXPIRE(603,"token校验异常"),
    TOMANY_REQUEST_ERROR(429,"后端服务触发流控"),
    BACKGROUD_DEGRADE_ERROR(604,"后端服务触发降级"),
    BAD_GATEWAY(502,"网关服务异常"),
    FORBIDDEN(403, "没有相关权限"),
    TOKEN_VALIDATE_FAILED(504, "token校验失败，请重新登录刷新token");
    private Integer code;
    private String message;

    private ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }

    public Integer getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

ResultData

package com.gateway.api;

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;

@Data
@NoArgsConstructor
public class ResultData<T> implements Serializable {
    /**
     * 状态码
     */
    public boolean status = true;

    /**
     * 状态码
     */
    private Integer code = 200;

    /**
     * 接口返回信息
     */
    private String msg;

    /**
     * 数据对象
     */
    private T data;

    /**
     * 初始化一个新创建的 ResultData 对象
     *
     * @param status 状态码
     * @param msg    返回内容
     */
    public ResultData(Boolean status, String msg) {
        this.status = status;
        this.msg = msg;
    }

    /**
     * 初始化一个新创建的 ResultData 对象
     *
     * @param status 状态码
     * @param msg    返回内容
     * @param data   数据对象
     */
    public ResultData(Boolean status, String msg, T data, Integer code) {
        this.status = status;
        this.msg = msg;
        this.data = data;
        this.code = code;
    }

    public ResultData(T data) {
        this.data = data;
    }


    /**
     * 返回成功消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static <T> ResultData<T> success(String msg, T data) {
        return new ResultData<T>(true, msg, data, 200);
    }

    /**
     * 返回成功消息
     *
     * @param msg 返回内容
     * @return 成功消息
     */
    public static <T> ResultData<T> success(String msg) {
        return ResultData.success(msg, null);
    }

    /**
     * 返回成功消息
     *
     * @return 成功消息
     */
    public static <T> ResultData<T> success() {
        return ResultData.success(null);
    }

    /**
     * 返回成功数据
     *
     * @return 成功消息
     */
    public static <T> ResultData<T> success(T data) {
        return ResultData.success(null, data);
    }

    /**
     * 返回错误消息
     *
     * @return
     */
    public static <T> ResultData<T> error() {
        return ResultData.error(null);
    }


    /**
     * 返回错误消息
     *
     * @param msg 返回内容
     * @return 警告消息
     */
    public static <T> ResultData<T> error(String msg) {
        return ResultData.error(msg, null);
    }

    /**
     * 返回错误消息
     *
     * @param code 状态码
     * @param msg  返回内容
     * @return 警告消息
     */
    public static <T> ResultData<T> error(Integer code, String msg) {
        return new ResultData<T>(false, msg, null, code);
    }


    /**
     * 返回错误消息
     *
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static <T> ResultData<T> error(String msg, T data) {
        return new ResultData<T>(false, msg, data, 500);
    }
}

RedisConfig

/**
 * Copyright (c) 2016-2019 人人开源 All rights reserved.
 *
 * https://www.renren.io
 *
 * 版权所有，侵权必究！
 */

package com.gateway.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.*;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Redis配置
 *
 * @author zhiwei liao
 */
@Configuration
public class RedisConfig {


    @Autowired
    private RedisConnectionFactory factory;

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
        return redisTemplate;
    }

    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    @Bean
    public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
}

RibbonConfig

package com.gateway.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

import java.util.Collections;


@Configuration
public class RibbonConfig {
    
    @Autowired
    private LoadBalancerClient loadBalancer;

    @Bean
    //@LoadBalanced     SmartInitializingSingleton   InitializingBean （构建bean的init方法）
    // 顺序的问题 SmartInitializingSingleton是在所有的非懒加载单例bean构建完成之后调用的
    public RestTemplate restTemplate(){
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.setInterceptors(
                Collections.singletonList(
                        new LoadBalancerInterceptor(loadBalancer)));
    
        return restTemplate;
    }
    
}

ApplicationConstant

package com.gateway.constant;

/**
 * @Description 应用常量
 * @Author zhiwei Liao
 * @Date 2021/6/15 11:06
 **/
public class ApplicationConstant {

    //本地环境
    public static final String LOCAL_ENVIRONMENT = "local";

    //开发环境
    public static final String DEV_ENVIRONMENT = "dev";

    //测试环境
    public static final String UAT_ENVIRONMENT = "uat";

    //正式环境
    public static final String PRO_ENVIRONMENT = "pro";

    //
    public static final String UAT2_ENVIRONMENT = "uat2";
}

GateWayConstant

package com.gateway.constant;

/**
 * @author zhiwei Liao
 * @version 1.0
 * @Description
 * @Date 2021/8/2 15:26
 */

public class GateWayConstant {

    public static final String KEY = "iA0`bN0&lKJ3{vH0(";
    public static final String TOKEN = "token:";
    public static final long TOKEN_EXPIRE_TIME = 86400000;
    public static final String REQUEST_TIME_BEGIN = "======请求开始时间：\n {}";
    public static final String REQUEST_TIME_END = "======请求开始时间：\n {}";
    public static final String REQUEST_GET = "=======GET请求：\n {}";
    public static final String REQUEST_POST = "======POST请求：\n {}";
    public static final String REQUEST_POST_TIME = "======POST请求：\n {}";
    public static final String URL_REQUIRING_AUTHENTICATION = "======需要认证的URL:{}：\n ";
    public static final String SKIP_CERTIFIED_URL = "======跳过认证的URL:{}：\n ";
}

GateWayException

package com.gateway.exception;


import com.gateway.api.IErrorCode;
import lombok.Data;


@Data
public class GateWayException extends RuntimeException{

    private long code;

    private String message;

    public GateWayException(IErrorCode iErrorCode) {
        this.code = iErrorCode.getCode();
        this.message = iErrorCode.getMessage();
    }
}

HttpResponseFilter

package com.b8.gateway.filter;

import org.json.JSONTokener;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.common.utils.StringUtils;
import com.gateway.api.ResultCode;
import com.gateway.api.ResultData;
import com.gateway.constant.ApplicationConstant;
import com.gateway.constant.GateWayConstant;
import com.gateway.properties.NotAuthUrlProperties;
import com.gateway.util.JsonUtils;
import com.gateway.util.JwtUtils;
import com.gateway.util.RedisUtil;
import io.jsonwebtoken.Claims;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.filter.factory.rewrite.CachedBodyOutputMessage;
import org.springframework.cloud.gateway.support.BodyInserterContext;
import org.springframework.core.annotation.Order;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ReactiveHttpOutputMessage;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpRequestDecorator;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.util.DigestUtils;
import org.springframework.util.MultiValueMap;
import org.springframework.util.PathMatcher;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.HandlerStrategies;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import java.security.PublicKey;
import java.util.*;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author zhiwei liao
 * @version 1.0
 * @Description
 * @Date 2021/5/21 18:30
 */
@Component
@Order(0)
@EnableConfigurationProperties(value = NotAuthUrlProperties.class)
public class HttpResponseFilter implements GlobalFilter, InitializingBean {

    protected final static String parameterReg = "-{28}([0-9]{24})\r\n.+name=\"(\\S*)\"\r\n\r\n(\\S*)";
    protected final static String fileParameterReg = "-{28}([0-9]{24})\r\n.+name=\"(\\S*)\"; filename=\"(\\S*)\"\r\n.*\r\n\r\n";

    private Logger log = LoggerFactory.getLogger(HttpResponseFilter.class);

    /**
     * jwt的公钥,需要网关启动,远程调用认证中心去获取公钥
     */
    private PublicKey publicKey;

    @Autowired
    private RestTemplate restTemplate;

    /**
     * 请求各个微服务 不需要用户认证的URL
     */
    @Autowired
    private NotAuthUrlProperties notAuthUrlProperties;

    //开发环境：dev开发，uat测试
    @Value("${environment}")
    private String environment;
    @Value("${dev_environment}")
    private String devEnvironment;
    @Value("${uat_environment}")
    private String uatEnvironment;
    @Value("${uat2_environment}")
    private String uat2Environment;
    @Value("${local_environment}")
    private String localEnvironment;

    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("===========环境类型：" + environment);
        String authTokenKeyIp = null;
        if(environment.equals(ApplicationConstant.LOCAL_ENVIRONMENT)){
            authTokenKeyIp = localEnvironment;
        }else if(environment.equals(ApplicationConstant.DEV_ENVIRONMENT)){
            authTokenKeyIp = devEnvironment;
        }else if(environment.equals(ApplicationConstant.UAT_ENVIRONMENT)){
            authTokenKeyIp = uatEnvironment;
        }else if(environment.equals(ApplicationConstant.UAT2_ENVIRONMENT)){
            authTokenKeyIp = uat2Environment;
        }else{
            authTokenKeyIp = devEnvironment;
        }
        //获取公钥   http://127.0.0.1:9013/oauth/token_key
        this.publicKey = JwtUtils.genPulicKey(restTemplate,authTokenKeyIp);
    }

    private boolean shouldSkip(String currentUrl) {
        //路径匹配器(简介SpringMvc拦截器的匹配器)
        //比如/oauth/** 可以匹配/oauth/token    /oauth/check_token等
        PathMatcher pathMatcher = new AntPathMatcher();
        for(String skipPath:notAuthUrlProperties.getShouldSkipUrls()) {
            if(pathMatcher.match(skipPath,currentUrl)) {
                return true;
            }
        }
        return false;
    }

    private ServerHttpRequest wrapHeader(ServerWebExchange serverWebExchange,Claims claims) {
        String loginUserInfo = JSON.toJSONString(claims);
        log.info("jwt的用户信息:{}",loginUserInfo);
//        String userId = claims.get("additionalInfo", Map.class).get("userId").toString();
        String userName = claims.get("additionalInfo",Map.class).get("userName").toString();
        String nickName = claims.get("additionalInfo",Map.class).get("nickName").toString();
//        String loginType = claims.get("additionalInfo",Map.class).get("loginType").toString();
        //向headers中放文件，记得build
        ServerHttpRequest request = serverWebExchange.getRequest().mutate()
//                .header("userId",userId)
                .header("userName",userName)
                .header("nickName",nickName)
//                .header("loginType",loginType)
                .build();
        return request;
    }


    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info(GateWayConstant.REQUEST_TIME_BEGIN, new Date());
        ServerRequest serverRequest = ServerRequest.create(exchange, HandlerStrategies.withDefaults().messageReaders());
        //获取参数类型
        String contentType = exchange.getRequest().getHeaders().getFirst(HttpHeaders.CONTENT_TYPE);
        log.info("======content type:{}", contentType);
        // 解析参数
        OAuthRequestFactory requestFactory = new WebFluxOAuthRequestFactory();
        OAuthRequest authRequest = requestFactory.createRequest(exchange.getRequest());
        Map<String, String> requestParamsMap = new HashMap<>();
        exchange.getAttributes().put(GateWayConstant.REQUEST_TIME_BEGIN, System.currentTimeMillis());
        HttpHeaders headers = new HttpHeaders();
        headers.putAll(exchange.getRequest().getHeaders());
        headers.remove(HttpHeaders.CONTENT_LENGTH);
        ServerHttpRequest serverHttpRequest = exchange.getRequest();
        //校验请求
        Mono<Void> check = check(headers, exchange, serverHttpRequest);
        if (check != null) {
            log.warn("======check未通过: {}", check);
            return check;
        }
        //1.过滤不需要认证的url,比如/oauth/**
        String currentUrl = exchange.getRequest().getURI().getPath();
        //过滤不需要认证的url
        if(shouldSkip(currentUrl)) {
            log.info(GateWayConstant.SKIP_CERTIFIED_URL,currentUrl);
        }else {
            log.info(GateWayConstant.URL_REQUIRING_AUTHENTICATION,currentUrl);
            //2. 获取token,从请求头中解析 Authorization  value:  bearer xxxxxxx或者从请求参数中解析 access_token
            //第一步:解析出我们Authorization的请求头  value为: “bearer XXXXXXXXXXXXXX”
            String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
            String acceptLanguage = exchange.getRequest().getHeaders().getFirst("accept-language");
            //第二步:判断Authorization的请求头是否为空
            if(StringUtils.isEmpty(authHeader)) {
                log.warn("======需要认证的url,请求头为空");
                ResultData resultData = new ResultData();
                resultData.setStatus(false);
                resultData.setCode(HttpStatus.UNAUTHORIZED.value());
                String msg;
                if("en_us".equals(acceptLanguage)){
                    msg = "Unauthorized";
                }else if("pl_pl".equals(acceptLanguage)){
                    msg = "nieupowa?nione";
                }else if("zh_cn".equals(acceptLanguage)){
                    msg = "未授权";
                }else {
                    msg = "Unauthorized";
                }
                resultData.setMsg(msg);
                return exchange.getResponse().writeWith(Mono.just(exchange.getResponse()
                        .bufferFactory().wrap(Objects.requireNonNull(
                                JsonUtils.toJson(resultData)).getBytes())));
            }
            //3. 校验token,拿到token后，通过公钥（需要从授权服务获取公钥）校验,校验失败或超时抛出异常
            //第三步 校验我们的jwt 若jwt不对或者超时都会抛出异常
            Claims claims = JwtUtils.validateJwtToken(authHeader,publicKey);
            if(claims == null){
                log.warn("======校验jwt,jwt不对");
                ResultData resultData = new ResultData();
                resultData.setStatus(false);
                resultData.setCode(ResultCode.TOKEN_VALIDATE_FAILED.getCode());
                String msg;
                if("en_us".equals(acceptLanguage)){
                    msg = "token validate failed";
                }else if("pl_pl".equals(acceptLanguage)){
                    msg = "token validate nie powiod?o si?";
                }else if("zh_cn".equals(acceptLanguage)){
                    msg = "token校验失败";
                }else {
                    msg = "token validate failed";
                }
                resultData.setMsg(msg);
                return exchange.getResponse().writeWith(Mono.just(exchange.getResponse()
                        .bufferFactory().wrap(Objects.requireNonNull(
                                JsonUtils.toJson(resultData)).getBytes())));
            }
            //4. 校验通过后，从token中获取的用户登录信息存储到请求头中
            //第四步 把从jwt中解析出来的 用户登陆信息存储到请求头中
            ServerHttpRequest httpRequest = wrapHeader(exchange, claims);
            headers.putAll(httpRequest.getHeaders());
        }
        Mono<String> modifiedBody = serverRequest.bodyToMono(String.class)
                .publishOn(Schedulers.immediate())
                .flatMap(originalBody -> {
                    // 根据请求头，用不同的方式解析Body
                    if (StringUtils.isNotEmpty(contentType)) {
                        if (contentType.startsWith(MediaType.MULTIPART_FORM_DATA_VALUE)) {
                            this.parseRequestBody(requestParamsMap, originalBody);
                        } else if (contentType.startsWith(MediaType.APPLICATION_JSON_VALUE)) {
                            this.parseRequestJson(requestParamsMap, originalBody);
                        } else if (contentType.startsWith(MediaType.APPLICATION_FORM_URLENCODED_VALUE)) {
                            this.parseRequestQuery(requestParamsMap, originalBody);
                        }
                    }
                    // 加载QueryParameter
                    this.parseRequestQuery(requestParamsMap, exchange.getRequest().getQueryParams());
                    log.info("所有参数：{}", JSON.toJSONString(requestParamsMap));
                    // 把信息放置到线程容器内
                    authRequest.setParameters(requestParamsMap);
                    OAuthRequestContainer.set(authRequest);
                    return Mono.just(originalBody);
                });
        log.info("所有参数：{}", JSON.toJSONString(requestParamsMap));
        // 把修改过的参数、消费过的参数，重新封装发布
        BodyInserter<Mono<String>, ReactiveHttpOutputMessage> bodyInserter = BodyInserters.fromPublisher(modifiedBody, String.class);
        CachedBodyOutputMessage outputMessage = new CachedBodyOutputMessage(exchange, headers);
        Mono<Void> result = bodyInserter.insert(outputMessage, new BodyInserterContext())
                .then(Mono.defer(() -> {
                    ServerHttpRequest decorator = decorate(exchange, headers, outputMessage);
                    return chain.filter(exchange.mutate().request(decorator).build());
                })).onErrorResume((Function<Throwable, Mono<Void>>)
                    throwable -> release(exchange, outputMessage, throwable));
        log.info(GateWayConstant.REQUEST_TIME_END, new Date());
        return result;
    }

    /**
     * 校验参数
     *
     * @param headers
     * @return
     */
    private Mono<Void> check(HttpHeaders headers, ServerWebExchange exchange, ServerHttpRequest serverHttpRequest) {
        String timestamp = headers.getFirst("timestamp");
        if (StringUtils.isEmpty(timestamp)) {
            log.info("========timestamp为空");
            return resultExchange(exchange);
        } else {
            log.info("=========timestamp:" + timestamp);
        }
        String acceptLanguage = headers.getFirst("accept-language");
        if (StringUtils.isEmpty(acceptLanguage)) {
            log.info("========acceptLanguage为空");
            return resultExchange(exchange);
        } else {
            log.info("=========acceptLanguage:" + acceptLanguage);
        }
        String vcode = headers.getFirst("vcode");
        if (StringUtils.isEmpty(vcode)) {
            log.info("========vcode为空");
            return resultExchange(exchange);
        } else {
            log.info("=========vcode:" + vcode);
            log.info("=========key:" + GateWayConstant.KEY);
            String keyMd5 = GateWayConstant.KEY + timestamp;
            String generatorVcode = DigestUtils.md5DigestAsHex(keyMd5.getBytes());
            log.info("=========generatorVcode:" + generatorVcode);
            if (!vcode.equals(generatorVcode)) {
                log.info("===========vcode校验不对");
                return resultExchange(exchange);
            }
        }
        //校验是否重复提交
        String commitRedisKey = GateWayConstant.TOKEN + vcode + serverHttpRequest.getURI().getRawPath();
        //加锁
        boolean success = RedisUtil.getLock(commitRedisKey, commitRedisKey, 1);
        if (!success) {
            log.info("=========请求太快了！请稍后再试！");
            return resultExchange(exchange);
        } else {
            //释放锁
            RedisUtil.releaseLock(commitRedisKey, commitRedisKey);
        }
        return null;
    }

    /**
     * @param exchange
     * @return Mono<Void>
     * @Description 定义拦截返回状态码
     * @Author zhiwei Liao
     * @Date 2021/5/21/14:56
     */
    private Mono<Void> resultExchange(ServerWebExchange exchange) {
        //定义拦截返回状态码
        ResultData resultData = new ResultData();
        resultData.setStatus(false);
        resultData.setCode(HttpStatus.NOT_ACCEPTABLE.value());
        resultData.setMsg(HttpStatus.NOT_ACCEPTABLE.getReasonPhrase());
        return exchange.getResponse().writeWith(Mono.just(exchange.getResponse()
                .bufferFactory().wrap(Objects.requireNonNull(
                        JsonUtils.toJson(resultData)).getBytes())));
    }

    protected void parseRequestBody(Map<String, String> parameterMap, String parameterString) {
        this.regexParseBodyString(parameterReg, parameterMap, parameterString);
        this.regexParseBodyString(fileParameterReg, parameterMap, parameterString);
    }

    protected void parseRequestJson(Map<String, String> parameterMap, String parameterString) {
        Object json = new JSONTokener(parameterString).nextValue();
        if(json instanceof JSONObject){
            JSONObject object = (JSONObject)json;
            for (String key : object.keySet()) {
                parameterMap.put(key, object.getString(key));
            }
        }else if (json instanceof JSONArray){
            JSONArray jsonArray = (JSONArray)json;
            for (Object value : jsonArray) {
                parameterMap.put(null,(String)value);
            }
        }


    }

    protected void parseRequestQuery(Map<String, String> parameterMap, MultiValueMap<String, String> queryParamMap) {
        if (queryParamMap != null && !queryParamMap.isEmpty()) {
            for (String key : queryParamMap.keySet()) {
                final List<String> stringList = queryParamMap.get(key);
                parameterMap.put(key, stringList != null && !stringList.isEmpty() ? StringUtils.join(Arrays.asList(stringList.toArray()), ",") : null);
            }
        }
    }

    protected void parseRequestQuery(Map<String, String> parameterMap, String parameterString) {
        final String[] paramsStr = parameterString.split("&");
        for (String s : paramsStr) {
            log.info("请求名：" + s.split("=")[0]);
            log.info("请求值：" + s.split("=")[1]);
            parameterMap.put(s.split("=")[0], s.split("=")[1]);
        }
    }

    protected void regexParseBodyString(String reg, Map<String, String> parameterMap, String bodyStr) {
        Matcher matcher = Pattern.compile(reg).matcher(bodyStr);
        while (matcher.find()) {
            parameterMap.put(matcher.group(2), matcher.group(3));
            log.info("请求参数编号：" + matcher.group(1));
            log.info("请求名：" + matcher.group(2));
            log.info("请求值：" + matcher.group(3));
        }
    }

    protected ServerHttpRequestDecorator decorate(ServerWebExchange exchange, HttpHeaders headers,
                                                  CachedBodyOutputMessage outputMessage) {
        return new ServerHttpRequestDecorator(exchange.getRequest()) {
            @Override
            public HttpHeaders getHeaders() {
                long contentLength = headers.getContentLength();
                HttpHeaders httpHeaders = new HttpHeaders();
                httpHeaders.putAll(super.getHeaders());
                if (contentLength > 0) {
                    httpHeaders.setContentLength(contentLength);
                } else {
                    httpHeaders.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
                }
                return httpHeaders;
            }

            @Override
            public Flux<DataBuffer> getBody() {
                return outputMessage.getBody();
            }
        };
    }

    protected Mono<Void> release(ServerWebExchange exchange,
                                 CachedBodyOutputMessage outputMessage, Throwable throwable) {
//        if (outputMessage.isCached()) {
//            return outputMessage.getBody().map(DataBufferUtils::release)
//                    .then(Mono.error(throwable));
//        }
        return Mono.error(throwable);
    }
}

OAuthRequest

package com.gateway.filter;

import java.util.Map;
import java.util.Set;


public class OAuthRequest {
    /**
     * 请求参数
     */
    private Map<String, String> parameters;
    /**
     * 请求头
     */
    private Map<String, String> headers;
    /**
     * 请求方式：POST、GET、PUT、DELETE
     */
    private String method;
    /**
     * 请求全路径
     */
    private String requestURL;
    /**
     * 请求路径
     */
    private String requestURI;
    /**
     * 请求地址参数
     */
    private String queryString;
    /**
     * 请求来源地址
     */
    private String remoteHost;

    public OAuthRequest() {
    }

    public OAuthRequest(Map<String, String> parameters, Map<String, String> headers, String method, String requestURL, String requestURI, String queryString, String remoteHost) {
        this.parameters = parameters;
        this.headers = headers;
        this.method = method;
        this.requestURL = requestURL;
        this.requestURI = requestURI;
        this.queryString = queryString;
        this.remoteHost = remoteHost;
    }


    /**
     * 获取请求参数
     *
     * @param name 参数名
     * @return 请求参数
     */
    public String getParameter(String name) {
        return parameters.get(name);
    }

    public Map<String, String> getParameters() {
        return parameters;
    }

    public OAuthRequest setParameters(Map<String, String> parameters) {
        this.parameters = parameters;
        return this;
    }

    /**
     * 获取请求头
     *
     * @param name 参数名
     * @return 请求头信息
     */
    public String getHeader(String name) {
        return headers.get(name);
    }

    public Map<String, String> getHeaders() {
        return headers;
    }

    public OAuthRequest setHeaders(Map<String, String> headers) {
        this.headers = headers;
        return this;
    }

    public String getMethod() {
        return method;
    }

    public OAuthRequest setMethod(String method) {
        this.method = method;
        return this;
    }

    public String getRequestURL() {
        return requestURL;
    }

    public OAuthRequest setRequestURL(String requestURL) {
        this.requestURL = requestURL;
        return this;
    }

    public String getRequestURI() {
        return requestURI;
    }

    public OAuthRequest setRequestURI(String requestURI) {
        this.requestURI = requestURI;
        return this;
    }

    public String getQueryString() {
        return queryString;
    }

    public OAuthRequest setQueryString(String queryString) {
        this.queryString = queryString;
        return this;
    }

    public String getRemoteHost() {
        return remoteHost;
    }

    public OAuthRequest setRemoteHost(String remoteHost) {
        this.remoteHost = remoteHost;
        return this;
    }

    public OAuthRequest narrowScope(Set<String> scope) {
        this.parameters.put("scope", String.join(",", scope.toArray(new String[]{})));
        return this;
    }
}

OAuthRequestContainer

package com.gateway.filter;


public class OAuthRequestContainer {
    private static ThreadLocal<OAuthRequest> local = new InheritableThreadLocal<>();

    private OAuthRequestContainer() {
    }

    public static void set(OAuthRequest request) {
        local.set(request);
    }

    public static OAuthRequest get() {
        return local.get();
    }

    public static void remove() {
        local.remove();
    }

    public static void rewriteOAuthRequestContainer(ThreadLocal<OAuthRequest> request) {
        local = request;
    }
}

OAuthRequestFactory

package com.gateway.filter;

import com.alibaba.nacos.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Map;

/**
 * @desc: 请求解析工厂类
 */
public abstract class OAuthRequestFactory {
    private static final Logger logger = LoggerFactory.getLogger(OAuthRequestFactory.class);

    /**
     * 构造请求实体
     *
     * @param httpRequest SpringMvc下传入HttpServletRequest
     * @return {@link OAuthRequest} 请求实体
     */
    public abstract OAuthRequest createRequest(Object httpRequest);

    /**
     * 构造封装请求实体
     *
     * @param headers     请求头信息
     * @param parameters  请求参数
     * @param remoteHost  请求来源IP
     * @param method      请求方式：POST、GET...
     * @param requestURL  请求全路径
     * @param requestURI  请求路径
     * @param queryString 请求路径参数
     */
    protected OAuthRequest buildRequest(Map<String, String> parameters, Map<String, String> headers, String method, String requestURL, String requestURI, String queryString, String remoteHost) {
        final String token = headers.get("HEADER_TOKEN.toLowerCase()");
        final String clientToken = headers.get("HEADER_TOKEN.toLowerCase()");
        // 判断是否包含认证OAuthAuthentication字段
        if (StringUtils.isNotEmpty(token)) {
            // TODO 解析令牌
            //final OAuthAuthentication authentication = resourceServerTokenServices.loadAuthentication(token);
            if (StringUtils.isNotEmpty(clientToken)) {
                // TODO 解析请求Client令牌
            }
            return new OAuthRequest(parameters, headers, method, requestURL, requestURI, queryString, remoteHost);
        }
        return new OAuthRequest(parameters, headers, method, requestURL, requestURI, queryString, remoteHost);
    }
}

WebFluxOAuthRequestFactory

package com.gateway.filter;

import com.alibaba.nacos.common.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.server.reactive.ServerHttpRequest;
import java.net.URI;
import java.util.*;


public class WebFluxOAuthRequestFactory extends OAuthRequestFactory {
    private static final Logger logger = LoggerFactory.getLogger(WebFluxOAuthRequestFactory.class);


    /**
     * 构造请求实体
     *
     * @param httpRequest SpringMvc下传入HttpServletRequest
     * @return {@link OAuthRequest} 请求实体
     */
    @Override
    public OAuthRequest createRequest(Object httpRequest) {
        ServerHttpRequest request = (ServerHttpRequest) httpRequest;
        final String sourceIp = analysisSourceIp(request);
        final URI uri = request.getURI();
        final String url = uri.getHost() + ":" + uri.getPort() + uri.getPath() + "?" + uri.getQuery();
        final Map<String, String> headersMap = getHeadersMap(request);
        return this.buildRequest(null, headersMap, request.getMethodValue().toUpperCase(), url, uri.getPath(), uri.getQuery(), sourceIp);
    }

    /**
     * 获取客户端真实IP
     */
    protected String analysisSourceIp(ServerHttpRequest request) {
        String ip = null;
        //X-Forwarded-For：Squid 服务代理
        String ipAddresses = request.getHeaders().getFirst("X-Forwarded-For");
        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {        //Proxy-Client-IP：apache 服务代理
            ipAddresses = request.getHeaders().getFirst("Proxy-Client-IP");
        }
        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {        //WL-Proxy-Client-IP：weblogic 服务代理
            ipAddresses = request.getHeaders().getFirst("WL-Proxy-Client-IP");
        }
        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {        //HTTP_CLIENT_IP：有些代理服务器
            ipAddresses = request.getHeaders().getFirst("HTTP_CLIENT_IP");
        }
        if (ipAddresses == null || ipAddresses.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {        //X-Real-IP：nginx服务代理
            ipAddresses = request.getHeaders().getFirst("X-Real-IP");
        }    //有些网络通过多层代理，那么获取到的ip就会有多个，一般都是通过逗号（,）分割开来，并且第一个ip为客户端的真实IP
        if (ipAddresses != null && ipAddresses.length() != 0) {
            ip = ipAddresses.split(",")[0];
        }    //还是不能获取到，最后再通过request.getRemoteAddr();获取
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ipAddresses)) {
            ip = Objects.requireNonNull(request.getRemoteAddress()).getHostString();
        }
        return ip;
    }

    /**
     * 获取所有Header信息
     */
    private Map<String, String> getHeadersMap(ServerHttpRequest request) {
        final HashMap<String, String> headerMap = new HashMap<>();
        for (String key : request.getHeaders().keySet()) {
            final List<String> stringList = request.getHeaders().get(key);
            headerMap.put(key, stringList != null && !stringList.isEmpty() ? StringUtils.join(Arrays.asList(stringList.toArray()), ",") : null);
        }
        return headerMap;
    }
}

NotAuthUrlProperties

package com.gateway.properties;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.util.LinkedHashSet;

@Data
@ConfigurationProperties("auth.gateway")
public class NotAuthUrlProperties {

    private LinkedHashSet<String> shouldSkipUrls;
}

JsonUtils

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.gateway.util;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalDateTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.deser.LocalTimeDeserializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
import lombok.extern.slf4j.Slf4j;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;

/**
 * JsonUtils.
 */
@Slf4j
public final class JsonUtils {

    private static final ObjectMapper MAPPER = new ObjectMapper();

    static {
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
        javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
        MAPPER.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                .disable(SerializationFeature.FAIL_ON_EMPTY_BEANS)
                .configure(JsonParser.Feature.ALLOW_COMMENTS, true)
                .configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true)
                .configure(JsonParser.Feature.ALLOW_SINGLE_QUOTES, true)
                .configure(JsonParser.Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true)
                .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"))
                .registerModule(javaTimeModule)
                .addMixIn(Map.class, IgnoreType.class);
    }

    /**
     * To json string.
     *
     * @param object the object
     * @return the string
     */
    public static String toJson(final Object object) {
        try {
            return MAPPER.writeValueAsString(object);
        } catch (IOException e) {
            log.warn("write to json string error: " + object, e);
            return "{}";
        }
    }

    /**
     * Remove class object.
     *
     * @param object the object
     * @return the object
     */
    public static Object removeClass(final Object object) {
        if (object instanceof Map) {
            Map<?, ?> map = (Map<?, ?>) object;
            Object result = map.get("result");
            if (result instanceof Map) {
                Map<?, ?> resultMap = (Map<?, ?>) result;
                resultMap.remove("class");
            }
            map.remove("class");
        }
        return object;
    }

    @JsonIgnoreProperties("class")
    @interface IgnoreType {
    }
}

JwtUtils

package com.gateway.util;

import com.gateway.api.ResultCode;
import com.gateway.exception.GateWayException;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.JwsHeader;
import io.jsonwebtoken.Jwt;
import io.jsonwebtoken.Jwts;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang.StringUtils;
import org.springframework.http.*;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Map;

@Slf4j
public class JwtUtils {

    /**
     * 认证服务器许可我们的网关的clientId(需要在oauth_client_details表中配置)
     */
    private static final String CLIENT_ID = "b8-gateway";

    /**
     * 认证服务器许可我们的网关的client_secret(需要在oauth_client_details表中配置)
     */
    private static final String CLIENT_SECRET = "a4d4aa1";

    /**
     * 认证服务器暴露的获取token_key的地址
     */
    private static final String AUTH_TOKEN_KEY_URL = ":9006/oauth/token_key";

    /**
     * 请求头中的 token的开始
     */
    private static final String AUTH_HEADER = "bearer ";


    public static void main(String[] args) {
        //密码加密方式
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        String b0h2a2 = bCryptPasswordEncoder.encode("604428249078181888");
        System.out.println(b0h2a2);
    }

    /**
     * 方法实现说明: 通过远程调用获取认证服务器颁发jwt的解析的key
     * @author:smlz
     * @param restTemplate 远程调用的操作类
     * @return: tokenKey 解析jwt的tokenKey
     * @exception:
     * @date:2020/1/22 11:31
     */
    private static String getTokenKeyByRemoteCall(RestTemplate restTemplate,String ip) throws Exception {
        //第一步:封装请求头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        headers.setBasicAuth(CLIENT_ID,CLIENT_SECRET);
        HttpEntity<MultiValueMap<String, String>> entity = new HttpEntity<>(null, headers);
        //第二步:远程调用获取token_key
        try {
            ResponseEntity<Map> response = restTemplate.exchange(ip + AUTH_TOKEN_KEY_URL, HttpMethod.GET, entity, Map.class);
            String tokenKey = response.getBody().get("value").toString();
            log.info("去认证服务器获取Token_Key:{}",tokenKey);
            return tokenKey;
        }catch (Exception e) {
            log.error("远程调用认证服务器获取Token_Key失败:{}",e.getMessage());
            throw new Exception(ResultCode.GET_TOKEN_KEY_ERROR.getMessage());
        }
    }

    /**
     * 方法实现说明:生成公钥
     * @author:smlz
     * @param restTemplate:远程调用操作类
     * @return: PublicKey 公钥对象
     * @exception:
     * @date:2020/1/22 11:52
     */
    public static PublicKey genPulicKey(RestTemplate restTemplate,String ip) throws Exception {
        String tokenKey = getTokenKeyByRemoteCall(restTemplate,ip);
        try{
            //把获取的公钥开头和结尾替换掉
            String dealTokenKey =tokenKey.replaceAll("\\-*BEGIN PUBLIC KEY\\-*", "").replaceAll("\\-*END PUBLIC KEY\\-*", "").trim();
            java.security.Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
            X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(Base64.decodeBase64(dealTokenKey));
            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
            PublicKey publicKey = keyFactory.generatePublic(pubKeySpec);
            log.info("生成公钥:{}",publicKey);
            return publicKey;
        }catch (Exception e) {
            log.info("生成公钥异常:{}",e.getMessage());
            throw new Exception(ResultCode.GEN_PUBLIC_KEY_ERROR.getMessage());
        }
    }

    /**
     * @Description 校验token
     * @MethodParameterTypes [java.lang.String, java.security.PublicKey]
     * @MethodParameters [authHeader, publicKey]
     * @MethodReturnType io.jsonwebtoken.Claims
     * @Author zhiwei Liao
     * @Date 2021/8/23 11:40
     **/
    public static Claims validateJwtToken(String authHeader,PublicKey publicKey) throws GateWayException {
        String token = null ;
        try{
            token = StringUtils.substringAfter(authHeader, AUTH_HEADER);
            Jwt<JwsHeader, Claims> parseClaimsJwt = Jwts.parser().setSigningKey(publicKey).parseClaimsJws(token);
            Claims claims = parseClaimsJwt.getBody();
            log.info("claims:{}",claims);
            return claims;
        }catch(Exception e){
            log.error("校验token异常:{},异常信息:{}",token,e.getMessage());
            return null;
        }
    }
}

RedisUtil

package com.gateway.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisConnectionUtils;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.Collections;

/**
 * @author zhiwei Liao
 * @version 1.0
 * @Description
 * @Date 2021/8/2 16:51
 */

@Component
public  class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    public static RedisTemplate redis;

    private static final String GET_LOCK_SCRIPT = "if redis.call('setNx',KEYS[1],ARGV[1]) then if redis.call('get',KEYS[1])==ARGV[1] then return redis.call('expire',KEYS[1],ARGV[2]) else return 0 end end";

    private static final String RELEASE_LOCK_SCRIPT = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";

    @PostConstruct
    public void getRedisTemplate(){
        redis = this.redisTemplate;
    }

    /**
     * 加锁
     * @param lockKey
     * @param value
     * @param expireTime  默认是秒
     * @return
     */
    public static boolean getLock(String lockKey, String value, int expireTime){
        boolean ret = false;
        try{
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(GET_LOCK_SCRIPT, Long.class);
            Object result = RedisUtil.redis.execute(redisScript,new StringRedisSerializer(),
                    new StringRedisSerializer(), Collections.singletonList(lockKey),value,String.valueOf(expireTime));
            ret = "1".equals(result.toString()) ;
            return ret;
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            RedisConnectionUtils.unbindConnection(RedisUtil.redis.getConnectionFactory());
        }
        return ret;
    }

    /**
     * 释放锁
     * @param lockKey
     * @param value
     * @return
     */
    public static boolean releaseLock(String lockKey, String value) {
        boolean ret = false;
        try{
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(RELEASE_LOCK_SCRIPT, Long.class);
            Object result = RedisUtil.redis.execute(redisScript, new StringRedisSerializer(), new StringRedisSerializer(),
                    Collections.singletonList(lockKey), value);
            ret = "1".equals(result.toString()) ;
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            RedisConnectionUtils.unbindConnection(RedisUtil.redis.getConnectionFactory());
        }
        return ret;
    }
}

B8GatewayApplication

package com.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@EnableDiscoveryClient
@SpringCloudApplication
public class B8GatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(B8GatewayApplication.class, args);
        System.out.println("=======网关服务启动成功================");
    }

    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

bootstrap.yml

server:
  port: 10002
spring:
  mvc:
    async:
      request-timeout: 20000
    static-path-pattern: /**
  application:
    # 应用名称
    name: gateway
  main:
    allow-bean-definition-overriding: true

application_key: iA0`bN0&lK0_H0(


dev_environment: http://x.xx.xx.xxx
uat_environment: http://x.xx.xx.xxx
uat2_environment: http://x.xx.xx.xxx
local_environment: http://x.xx.xx.xxx


b8auth:
  gateway:
    shouldSkipUrls:
      - /user/xx
      - /xx/xx

bootstrap-uat2.yml

# Spring
spring:
  cloud:
    nacos:
      discovery:
        # 服务注册地址
        server-addr: ${NACOSHOST:http://xx.xx.xx.xxx}:${NACOSPORT:8034}
      config:
        # 配置中心地址
        server-addr: ${spring.cloud.nacos.discovery.server-addr}
        # 配置文件格式
        file-extension: yml
        # 共享配置
        shared-configs:
          - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
    gateway:
      discovery:
        locator:
          enabled: false
          lowerCaseServiceId: true
      routes:
        - id: user
          uri: lb://user
          predicates:
            - Path=/user/**
          filters:
            - StripPrefix=1
        - id: content
          uri: lb://xx
          predicates:
            - Path=/xx/**
          filters:
            - StripPrefix=1
        - id: contentPush
          uri: lb://xx
          predicates:
            - Path=/xx/**
          filters:
            - StripPrefix=1
  redis:
    database: 0
    host: x.xx.xx.xxx
    port: 8901
    #  host: xx.xx.xx.xx
    #  port: 38764
    password: bU0@rR0\!dE7:*oFdfafsddfs
    lettuce:
      pool:
        min-idle: 8
        max-idle: 500
        max-active: 2000
        max-wait: 10000
    timeout: 5000
logging:
  level:
    root: info
    com.gateway: debug

environment: uat2
application_key: i`bNdfasfasK0_lJ3{vH0(

总结

以上就是今天要讲的内容，本文仅仅简单介绍了gateway网关的实现，目前当前功能可以拿去直接上线使用，企业级，已实现路由转发，参数校验，配置中心。可以配合授权模块使用：https://liaozhiwei.blog.csdn.net/article/details/120291130 当然里面有些写死的东西，需要大家改成自个的。