详解springcloud gateway工作原理、断言、filter、uri、id、全局跨域、globalfilter等以及关键源码实现

已于 2025-04-29 12:40:15 修改
阅读量677 收藏 19
点赞数 9
分类专栏： Javaee&云原生架构设计 文章标签： spring cloud gateway spring 微服务 spring boot java 跨域
于 2025-04-23 00:33:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazy123456789/article/details/147434164
版权

文章目录

1.gateway概念
  1. 网关就是当前微服务项目的"统一入口"
  2. 程序中的网关就是当前微服务项目对外界开放的统一入口
  3. 所有外界的请求都需要先经过网关才能访问到我们的程序
  4. 提供了统一入口之后,方便对所有请求进行统一的检查和管理
2. 网关的主要功能
  • 将所有请求统一经过网关
  • 网关可以对这些请求进行检查
  • 网关方便记录所有请求的日志
  • 网关可以统一将所有请求路由到正确的模块\服务上

“路由"的近义词就是"分配”
在这里插入图片描述

3. 工作原理

在这里插入图片描述
在这里插入图片描述
Spring Gateway的工作原理基于路由、断言（Predicates）和过滤器（Filters）三大核心概念：

  • ‌路由（Route）：定义了请求的转发规则，包括目标URL和匹配条件。
  • 断言（Predicates）：用于匹配HTTP请求的各种条件，如路径、头信息、参数等。只有匹配成功的请求才会被路由处理。
  • 过滤器（Filters）：在请求处理前后执行特定的逻辑，例如权限校验、日志记录
4. 配置和使用示例
spring:
  cloud:
    gateway:
      routes:
        - id: myroute
          uri: http://example.com
          predicates:
            - Path=/api/**
          filters:
            - AddRequestHeader=X-Request-ID, \${requestId}

这个配置定义了一个路由，所有路径以/api/开头的请求都会被转发到http://example.com，并且在请求头中添加一个X-Request-ID字段‌

springcloud gateway中配置uri有3种方式：

  • ws(websocket)方式: uri: ws://localhost:9000
  • http方式: uri: http://localhost:8130/
  • lb(注册中心中服务名字)方式: uri: lb://brilliance-consumer

springcloud gatetway命名规范

能被gateway的lb方式识别到的命名规则为：

   "[a-zA-Z]([a-zA-Z]|\\d|\\+|\\.|-)*:.*"

如果名字中有非*“a-zA-Z:.”*规则字符或者使用“_”，则会报错

5.网关gateway routes的组成

1. id：必须唯一

2. predicates（断言）
在这里插入图片描述
关键类源码分析：

package org.springframework.cloud.gateway.handler.predicate;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.core.style.ToStringCreator;
import org.springframework.http.server.PathContainer;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.util.pattern.PathPattern;
import org.springframework.web.util.pattern.PathPattern.PathMatchInfo;
import org.springframework.web.util.pattern.PathPatternParser;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_PREDICATE_MATCHED_PATH_ATTR;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_PREDICATE_MATCHED_PATH_ROUTE_ID_ATTR;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_PREDICATE_PATH_CONTAINER_ATTR;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.putUriTemplateVariables;
import static org.springframework.http.server.PathContainer.parsePath;

/**
 * @author Spencer Gibb
 * @author Dhawal Kapil
 */
public class PathRoutePredicateFactory extends AbstractRoutePredicateFactory<PathRoutePredicateFactory.Config> {

    private static final Log log = LogFactory.getLog(PathRoutePredicateFactory.class);

    private static final String MATCH_TRAILING_SLASH = "matchTrailingSlash";

    private PathPatternParser pathPatternParser = new PathPatternParser();

    public PathRoutePredicateFactory() {
       super(Config.class);
    }

    private static void traceMatch(String prefix, Object desired, Object actual, boolean match) {
       if (log.isTraceEnabled()) {
          String message = String.format("%s \"%s\" %s against value \"%s\"", prefix, desired,
                match ? "matches" : "does not match", actual);
          log.trace(message);
       }
    }

    public void setPathPatternParser(PathPatternParser pathPatternParser) {
       this.pathPatternParser = pathPatternParser;
    }

    @Override
    public List<String> shortcutFieldOrder() {
       return Arrays.asList("patterns", MATCH_TRAILING_SLASH);
    }

    @Override
    public ShortcutType shortcutType() {
       return ShortcutType.GATHER_LIST_TAIL_FLAG;
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
       final ArrayList<PathPattern> pathPatterns = new ArrayList<>();
       synchronized (this.pathPatternParser) {
          pathPatternParser.setMatchOptionalTrailingSeparator(config.isMatchTrailingSlash());
          config.getPatterns().forEach(pattern -> {
             PathPattern pathPattern = this.pathPatternParser.parse(pattern);
             pathPatterns.add(pathPattern);
          });
       }
       return new GatewayPredicate() {
          @Override
          public boolean test(ServerWebExchange exchange) {
             PathContainer path = (PathContainer) exchange.getAttributes().computeIfAbsent(
                   GATEWAY_PREDICATE_PATH_CONTAINER_ATTR,
                   s -> parsePath(exchange.getRequest().getURI().getRawPath()));

             PathPattern match = null;
             for (int i = 0; i < pathPatterns.size(); i++) {
                PathPattern pathPattern = pathPatterns.get(i);
                if (pathPattern.matches(path)) {
                   match = pathPattern;
                   break;
                }
             }

             if (match != null) {
                traceMatch("Pattern", match.getPatternString(), path, true);
                PathMatchInfo pathMatchInfo = match.matchAndExtract(path);
                putUriTemplateVariables(exchange, pathMatchInfo.getUriVariables());
                exchange.getAttributes().put(GATEWAY_PREDICATE_MATCHED_PATH_ATTR, match.getPatternString());
                String routeId = (String) exchange.getAttributes().get(GATEWAY_PREDICATE_ROUTE_ATTR);
                if (routeId != null) {
                   // populated in RoutePredicateHandlerMapping
                   exchange.getAttributes().put(GATEWAY_PREDICATE_MATCHED_PATH_ROUTE_ID_ATTR, routeId);
                }
                return true;
             }
             else {
                traceMatch("Pattern", config.getPatterns(), path, false);
                return false;
             }
          }

          @Override
          public Object getConfig() {
             return config;
          }

          @Override
          public String toString() {
             return String.format("Paths: %s, match trailing slash: %b", config.getPatterns(),
                   config.isMatchTrailingSlash());
          }
       };
    }

    @Validated
    public static class Config {

       private List<String> patterns = new ArrayList<>();

       private boolean matchTrailingSlash = true;

       public List<String> getPatterns() {
          return patterns;
       }

       public Config setPatterns(List<String> patterns) {
          this.patterns = patterns;
          return this;
       }

       /**
        * @deprecated use {@link #isMatchTrailingSlash()}
        */
       @Deprecated
       public boolean isMatchOptionalTrailingSeparator() {
          return isMatchTrailingSlash();
       }

       /**
        * @deprecated use {@link #setMatchTrailingSlash(boolean)}
        */
       @Deprecated
       public Config setMatchOptionalTrailingSeparator(boolean matchOptionalTrailingSeparator) {
          setMatchTrailingSlash(matchOptionalTrailingSeparator);
          return this;
       }

       public boolean isMatchTrailingSlash() {
          return matchTrailingSlash;
       }

       public Config setMatchTrailingSlash(boolean matchTrailingSlash) {
          this.matchTrailingSlash = matchTrailingSlash;
          return this;
       }

       @Override
       public String toString() {
          return new ToStringCreator(this).append("patterns", patterns)
                .append(MATCH_TRAILING_SLASH, matchTrailingSlash).toString();
       }

    }

}

package org.springframework.cloud.gateway.handler.predicate;

import java.util.function.Consumer;
import java.util.function.Predicate;
import org.springframework.cloud.gateway.handler.AsyncPredicate;
import org.springframework.cloud.gateway.support.Configurable;
import org.springframework.cloud.gateway.support.NameUtils;
import org.springframework.cloud.gateway.support.ShortcutConfigurable;
import org.springframework.web.server.ServerWebExchange;
import static org.springframework.cloud.gateway.support.ServerWebExchangeUtils.toAsyncPredicate;

/**
 * @author Spencer Gibb
 */
@FunctionalInterface
public interface RoutePredicateFactory<C> extends ShortcutConfigurable, Configurable<C> {

    /**
     * Pattern key.
     */
    String PATTERN_KEY = "pattern";

    // useful for javadsl
    default Predicate<ServerWebExchange> apply(Consumer<C> consumer) {
       C config = newConfig();
       consumer.accept(config);
       beforeApply(config);
       return apply(config);
    }

    default AsyncPredicate<ServerWebExchange> applyAsync(Consumer<C> consumer) {
       C config = newConfig();
       consumer.accept(config);
       beforeApply(config);
       return applyAsync(config);
    }

    default Class<C> getConfigClass() {
       throw new UnsupportedOperationException("getConfigClass() not implemented");
    }

    @Override
    default C newConfig() {
       throw new UnsupportedOperationException("newConfig() not implemented");
    }

    default void beforeApply(C config) {
    }

    Predicate<ServerWebExchange> apply(C config);

    default AsyncPredicate<ServerWebExchange> applyAsync(C config) {
       return toAsyncPredicate(apply(config));
    }

    default String name() {
       return NameUtils.normalizeRoutePredicateName(getClass());
    }

}

自定义Vip路由断言工厂实现

package com.wemedia.gateway.config;

import jakarta.validation.constraints.NotEmpty;
import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.handler.predicate.CookieRoutePredicateFactory;
import org.springframework.cloud.gateway.handler.predicate.GatewayPredicate;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * 自定义Vip路由断言工厂
 */
@Component
public class VipRoutePredicateFactory extends AbstractRoutePredicateFactory<VipRoutePredicateFactory.Config> {

    public VipRoutePredicateFactory(){
        super(Config.class);
    }

    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("param","value");
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return new GatewayPredicate() {
            @Override
            public boolean test(ServerWebExchange serverWebExchange) {
                //localhost/search?q=hhh&user=jackma
                ServerHttpRequest request = serverWebExchange.getRequest();
                String first = request.getQueryParams().getFirst(config.param);
                return StringUtils.hasText(first)&&first.equals(config.value);
            }
        };
    }


    @Validated
    public static class Config {
        @NotEmpty
        private String value;
        @NotEmpty
        private String param;

        public String getParam() {
            return param;
        }

        public void setParam(String param) {
            this.param = param;
        }


        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

    }
}

在这里插入代码片

配置Vip断言
在这里插入图片描述
3. Filter(过滤器)
在这里插入图片描述
3.1 rewritePath(路径重写)
在这里插入图片描述
在这里插入图片描述

  • 添加RewritePath过滤器，重写原先路径/readDb,在访问路径前面追加/api/order/readDb,不然网关无法直接访问/readDb;
  • 添加AddReponseHeader过滤器，给响应头增加参数X-Response-ABC,值为123

3.2 默认过滤器filter:
在这里插入图片描述
增加默认过滤器default-filters, 参数Add-ReponseHeader=X-Reponse-Abc ,值为123 给所有服务的相应头中

3.3 全局过滤器GlobalFilter

package com.wemedia.gateway.filter;

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.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 实现响应时间全局过滤器
 */
@Component
@Slf4j
public class RTGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();

        String uri = request.getURI().toString();
        long start=System.currentTimeMillis();
        log.info("请求【{}】开始时间:{}",uri,start );
        //================以上是前置逻辑==============

        Mono<Void> filter = chain.filter(exchange).doFinally((result) -> {
            //================后置逻辑
            long end = System.currentTimeMillis();
            log.info("请求【{}】结束时间:{},耗时:{}ms", uri, end, end - start);
        });
        return filter;
    }

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

过滤器filter 列表：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
3.4 自定义过滤器工厂

关键源码分析

package org.springframework.cloud.gateway.filter.factory;
import reactor.core.publisher.Mono;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.web.server.ServerWebExchange;

import static org.springframework.cloud.gateway.support.GatewayToStringStyler.filterToStringCreator;

/**
 * @author Spencer Gibb
 */
public class AddResponseHeaderGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory {

    @Override
    public GatewayFilter apply(NameValueConfig config) {
       return new GatewayFilter() {
          @Override
          public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
             return chain.filter(exchange).then(Mono.fromRunnable(() -> addHeader(exchange, config)));
          }

          @Override
          public String toString() {
             return filterToStringCreator(AddResponseHeaderGatewayFilterFactory.this)
                   .append(config.getName(), config.getValue()).toString();
          }
       };
    }

    void addHeader(ServerWebExchange exchange, NameValueConfig config) {
       final String value = ServerWebExchangeUtils.expand(exchange, config.getValue());
       HttpHeaders headers = exchange.getResponse().getHeaders();
       // if response has been commited, no more response headers will bee added.
       if (!exchange.getResponse().isCommitted()) {
          headers.add(config.getName(), value);
       }
    }

}

1.实现一次性token自定义过滤器工厂

package com.wemedia.gateway.filter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractNameValueGatewayFilterFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.UUID;

/**
 * 实现一次性令牌的自定义过滤器工场
 */
@Component
@Slf4j
public class OnceTokenGatewayFilterFactory extends AbstractNameValueGatewayFilterFactory {
    @Override
    public GatewayFilter apply(NameValueConfig config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
                //每次响应之前，添加一个一次性令牌,支持uuid,jwt等格式

                return chain.filter(exchange).then(Mono.fromRunnable(()->{
                    ServerHttpResponse response = exchange.getResponse();
                    HttpHeaders headers = response.getHeaders();
                    String value = config.getValue();
                    if("uuid".equalsIgnoreCase(value)){
                        value = UUID.randomUUID().toString();
                    }

                    if("jwt".equalsIgnoreCase(value)){
                        value="";
                    }


                    headers.add(config.getName(),value);
                }));
            }
        };
    }
}

2.配置一次性token过滤器
在这里插入图片描述
3.访问api响应结果如下：
在这里插入图片描述
3.5 实现全局跨域
在这里插入图片描述

  • 解决单机跨域方法：直接在每个controller上增加注解@CrossOrigin

在这里插入图片描述

  • 在分布式系统上解决跨域问题，在gateway上统一处理跨域问题
    配置全局跨域：
    在这里插入图片描述
    运行结果如下，增加了跨域处理：
    在这里插入图片描述
6.参考资料
  • 网关 APISIX
  • 网关：shenyu https://shenyu.apache.org/zh/ java实现
  • springcloud gateway https://blog.csdn.net/weixin_44807758/article/details/130273943
  • Sentinel
    https://sentinelguard.io/zh-cn/
    https://sentinelguard.io/zh-cn/docs/introduction.html
    https://sentinelguard.io/zh-cn/docs/dashboard.html
    https://github.com/alibaba/Sentinel
  • 开源微服务框架：
    若依：https://doc.ruoyi.vip/
    https://github.com/zhoutaoo/SpringCloud
    https://cloud.tencent.com/developer/article/2391291
万字长文带你吃透SpringCloudGateway工作原理+动态路由+源码解析
公众号：该用户快成仙了
10-13 6186
非阻塞，默认使用RxNetty作为响应式Web容器，通过非阻塞方式，利用较少的线程和资源来处理高并发请求，并提升服务资源利用的可伸缩性。函数式编程端点，通过使用Spring WebFlux的函数式编程模式定义路由端点，处理请求。
一文搞懂 Spring Cloud Gateway 源码
奋斗的edison
07-15 909
今天主要分享一下 Spring Cloud Gateway 的基本概念和入门操作，通过阅读源码了解其背后的工作原理
SpringCloud网关：Gateway路由配置与过滤器链
最新发布
程序媛学姐的博客
03-21 1334
除了使用内置过滤器外，Gateway还支持自定义过滤器，以满足特定业务需求。自定义过滤器有两种方式：实现GatewayFilter接口或继承AbstractGatewayFilterFactory类。/*** 自定义GatewayFilter* 记录请求处理时间*/@Component@Override= null) {})@Override/*** 在路由配置中使用自定义过滤器*/@Bean.build();/*** 自定义过滤器工厂。
Spring cloud gateway工作流程原理解析
08-19
主要介绍了Spring cloud gateway工作流程原理解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring Cloud GateWay 原理
杨宇昌的博客
04-29 5756
Spring Cloud GateWay 原理
细到不能再细的 Spring Cloud Gateway 原理分析（内含多张图片讲解）
热门推荐
nimo10050的博客
10-22 1万+
通过绘制多图讲解 Spring Cloud Gateway 的原理。层层递进！！ Spring Cloud Gateway 使用了 Spring WebFlux 非阻塞网络框架，底层网络通信默认使用了高性能非阻塞的 Netty ，解决了 Spring Cloud Zuul 因为阻塞的线程模型带来的性能下降的问题。
SpringCloud Gateway路由核心原理解析
雨后是冰雹
10-26 1984
SpringCloud Gateway 是 Spring 官方基于 Spring Spring Boot 和 Project Reactor 等技术开发的网关，Gateway 旨在为微服务架构提供一种简单而有效的统一的API路由管理方式。Gateway作为 Spring Cloud 生态系中的网关，目标是替代 ZUUL，其不仅提供统一的路由方式，并且基于 Filter 链的方式提供了关基本的功能，例如：安全，监控/埋点，和限流等。
spring cloud gateway之filter篇
weixin_34249678的博客
12-17 3065
转载请标明出处： www.fangzhipeng.com 本文出自方志朋的博客 在上一篇文章详细的介绍了Gateway的Predict，Predict决定了请求由哪一个路由处理，在路由处理之前，需要经过“pre”类型的过滤器处理，处理返回响应之后，可以由“post”类型的过滤器处理。 filter的作用和生命周期 由filter工作流程点，可以知道filter有着非常重要的作用，在“pre”类...
SpringCloud集成微服务API网关Gateway（详解）
Tao_unafraid的博客
06-06 4022
本篇博客介绍了如何使用SpringCloud Gateway集成统一网关，探讨了网关的作用以及技术实现方式。从搭建网关服务、路由断言工厂、路由过滤器到全局过滤器，逐步深入讲解了实现原理和配置方法。此外，还详细讨论了跨域问题及解决方案，以CORS为例展示了如何在网关中进行跨域处理。通过本文，读者可以全面了解SpringCloud Gateway的基本原理和使用方法，以及如何解决常见的跨域问题。
SpringCloud篇（服务网关 - GateWay）
ADFVBM的博客
02-06 1155
Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。创建项目，引入nacos服务发现和gateway依赖配置application.yml，包括服务基本信息、nacos地址、路由路由id：路由的唯一标示。
Spring Cloud Gateway源码解析
至尊宝
05-23 7092
文章概览一、概述二、GlobalFilter和GatewayFilter1.GlobalFilter2.GatewayFilter三、原理四、源码分析五、自定义GatewayFilter 一、概述 本周又回顾了一下Spring Cloud Gateway的内容，主要参考《重新定义Spring Cloud实战》以及一些网络博客，虽然内容都差不多，但我还想照猫画虎总结一下子，加深印象。 SpringCloud gateway是Spring Cloud生态体系的第二代网关，是基于Spring5.0、Spring
Spring Cloud Gateway源码解读
m0_67390379的博客
04-08 348
一SpringCloudGateway的处理流程 二源码阅读关键断点 ReactorHttpHandlerAdapter HttpWebHandlerAdapter DispatcherHandler RoutePredicateHandlerMapping FilteringWebHandler
Spring Cloud Gateway 之 Filter
程序员果果的博客
02-23 2139
简介 网关经常需要对路由请求进行过滤，进行一些操作，如鉴权之后构造头部之类的，过滤的种类很多，如增加请求头、增加请求 参数 、增加响应头和断路器等等功能，这就用到了Spring Cloud Gateway 的 Filter。 作用 当我们有很多个服务时，比如下图中的user-service、goods-service、sales-service等服务，客户端请求各个服务的Api时，每个服务都需要做...
网关 Spring-Cloud-Gateway 源码解析 —— 调试环境搭建
weixin_34253539的博客
03-23 233
本文主要基于 Spring-Cloud-Gateway 2.0.X M4 摘要: 原创出处 http://www.iocoder.cn/Spring-Cloud-Gateway/build-debugging-environment/ 「芋道源码」欢迎转载，保留摘要，谢谢！ 1. 依赖工具 2. 源码拉取 3. 运行示例 4. 彩蛋
GateWay原理
xingxinggua9620的博客
01-29 5793
1. 网关Gateway的基本组成 GateWay官网地址 中文官网 Route:路由是GateWay最基础的组件,它包含一个ID,一个目标Url,一些断言集合,一些过滤器集合;如果断言成功的话,路由器就会被匹配 Predicate:输入类型是Spring FrameworkServerWebExchange。这使您可以匹配HTTP请求中的所有内容，例如标头或参数。 Filter:这些是使用特定工厂构造的Spring FrameworkGatewayFilter实例。在这里，您可以在发送下游请求之前或
Spring Cloud——Gateway源码分析
努力找工作呀
04-18 690
1.入口：初始自动配置类 查看gateway core包的Spring.factoires # Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ #用来验证项目中是否存在DispatcherServlet(SpringMvc使用,webFlux中不能存在) 是否不存在DispatcherHandler(WebFlux使用) org.springframework.cloud.gateway.c
spring Cloud Gateway 源码分析
Artistic Life
03-29 767
老样子, 查看factories内配置如下 # Auto Configure org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ # 依赖包校验配置 org.springframework.cloud.gateway.config.GatewayClassPathWarningAutoConfiguration,\ #...
spring cloud gateway 源码解析
小程序员的大梦想
03-22 814
http://www.iocoder.cn/Spring-Cloud-Gateway/build-debugging-environment/
Spring-cloud-gateway 源码浅析
weixin_46172484的博客
06-30 1305
SpringCloudGateway 源码浅析
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值