Spring Cloud Gateway 之动态路由

于 2024-08-23 09:30:00 发布
阅读量721 收藏 12
点赞数 16
分类专栏： 【Spring cloud】 文章标签： java Spring Cloud 微服务 Gateway 网关 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42118323/article/details/141173786
版权

前言

熟悉 Spring Cloud Gateway 的人都知道 Gateway 提供了鉴权、路由等功能，本篇我们重点分析的是 Gateway 的动态路由功能。

Gateway Actuator API 方法源码解析

Spring Cloud Gateway 的 Actuator 端点允许监视 Spring Cloud Gateway 应用程序并与之交互，Gateway 依赖中默认包含了路由端点操作，我们引入 spring-boot-starter-actuator。

Gateway 端点开启方式如下：

management.endpoint.gateway.enabled=true
management.endpoints.web.exposure.include=gateway

我们在 IDEA 中按住 Ctrl，用鼠标点击 enable 就可以看 Gateway 端点的源码，如下：

在这里插入图片描述

GatewayControllerEndpoint 源码解析

GatewayControllerEndpoint 主要提供了三个方法，作用如下：

  • routesdef()：获取路由定义信息。
  • routes()：获取网关已经加载的所有路由信息。
  • route(@PathVariable String id)：根据路由 id 获取路由信息。
@RestControllerEndpoint(
    id = "gateway"
)
public class GatewayControllerEndpoint extends AbstractGatewayControllerEndpoint {
    public GatewayControllerEndpoint(List<GlobalFilter> globalFilters, List<GatewayFilterFactory> gatewayFilters, List<RoutePredicateFactory> routePredicates, RouteDefinitionWriter routeDefinitionWriter, RouteLocator routeLocator, RouteDefinitionLocator routeDefinitionLocator) {
        super(routeDefinitionLocator, globalFilters, gatewayFilters, routePredicates, routeDefinitionWriter, routeLocator);
    }
	
	//获取路由定义信息
    @GetMapping({"/routedefinitions"})
    public Flux<RouteDefinition> routesdef() {
        return this.routeDefinitionLocator.getRouteDefinitions();
    }
	
	//获取网关已经加载的所有路由信息
    @GetMapping({"/routes"})
    public Flux<Map<String, Object>> routes() {
        return this.routeLocator.getRoutes().map(this::serialize);
    }

    Map<String, Object> serialize(Route route) {
        HashMap<String, Object> r = new HashMap();
        r.put("route_id", route.getId());
        r.put("uri", route.getUri().toString());
        r.put("order", route.getOrder());
        r.put("predicate", route.getPredicate().toString());
        if (!CollectionUtils.isEmpty(route.getMetadata())) {
            r.put("metadata", route.getMetadata());
        }

        ArrayList<String> filters = new ArrayList();

        for(int i = 0; i < route.getFilters().size(); ++i) {
            GatewayFilter gatewayFilter = (GatewayFilter)route.getFilters().get(i);
            filters.add(gatewayFilter.toString());
        }

        r.put("filters", filters);
        return r;
    }

	//根据路由id 获取路由信息
    @GetMapping({"/routes/{id}"})
    public Mono<ResponseEntity<Map<String, Object>>> route(@PathVariable String id) {
        return this.routeLocator.getRoutes().filter((route) -> {
            return route.getId().equals(id);
        }).singleOrEmpty().map(this::serialize).map(ResponseEntity::ok).switchIfEmpty(Mono.just(ResponseEntity.notFound().build()));
    }
}

获取路由信息接口演示如下：

在这里插入图片描述

AbstractGatewayControllerEndpoint 源码解析

AbstractGatewayControllerEndpoint 主要提供了一下功能：

  • refresh()：刷新路由。
  • refresh()：获取全局过滤器。
  • refresh()：获取路由过滤器。
  • refresh()：获取断言工厂。
  • refresh()：保存路由信息。
  • refresh()：删除路由信息。
  • refresh()：根据路由id 获取组合过滤器。
public class AbstractGatewayControllerEndpoint implements ApplicationEventPublisherAware {
    private static final Log log = LogFactory.getLog(GatewayControllerEndpoint.class);
    protected RouteDefinitionLocator routeDefinitionLocator;
    protected List<GlobalFilter> globalFilters;
    protected List<GatewayFilterFactory> GatewayFilters;
    protected List<RoutePredicateFactory> routePredicates;
    protected RouteDefinitionWriter routeDefinitionWriter;
    protected RouteLocator routeLocator;
    protected ApplicationEventPublisher publisher;

    public AbstractGatewayControllerEndpoint(RouteDefinitionLocator routeDefinitionLocator, List<GlobalFilter> globalFilters, List<GatewayFilterFactory> gatewayFilters, List<RoutePredicateFactory> routePredicates, RouteDefinitionWriter routeDefinitionWriter, RouteLocator routeLocator) {
        this.routeDefinitionLocator = routeDefinitionLocator;
        this.globalFilters = globalFilters;
        this.GatewayFilters = gatewayFilters;
        this.routePredicates = routePredicates;
        this.routeDefinitionWriter = routeDefinitionWriter;
        this.routeLocator = routeLocator;
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

	//刷新路由
    @PostMapping({"/refresh"})
    public Mono<Void> refresh() {
        this.publisher.publishEvent(new RefreshRoutesEvent(this));
        return Mono.empty();
    }

	//获取全局过滤器
    @GetMapping({"/globalfilters"})
    public Mono<HashMap<String, Object>> globalfilters() {
        return this.getNamesToOrders(this.globalFilters);
    }

	//获取路由过滤器
    @GetMapping({"/routefilters"})
    public Mono<HashMap<String, Object>> routefilers() {
        return this.getNamesToOrders(this.GatewayFilters);
    }

	//获取断言工厂
    @GetMapping({"/routepredicates"})
    public Mono<HashMap<String, Object>> routepredicates() {
        return this.getNamesToOrders(this.routePredicates);
    }

    private <T> Mono<HashMap<String, Object>> getNamesToOrders(List<T> list) {
        return Flux.fromIterable(list).reduce(new HashMap(), this::putItem);
    }

    private HashMap<String, Object> putItem(HashMap<String, Object> map, Object o) {
        Integer order = null;
        if (o instanceof Ordered) {
            order = ((Ordered)o).getOrder();
        }

        map.put(o.toString(), order);
        return map;
    }
	
	//保存路由信息
    @PostMapping({"/routes/{id}"})
    public Mono<ResponseEntity<Object>> save(@PathVariable String id, @RequestBody RouteDefinition route) {
        return Mono.just(route).filter(this::validateRouteDefinition).flatMap((routeDefinition) -> {
            return this.routeDefinitionWriter.save(Mono.just(routeDefinition).map((r) -> {
                r.setId(id);
                log.debug("Saving route: " + route);
                return r;
            })).then(Mono.defer(() -> {
                return Mono.just(ResponseEntity.created(URI.create("/routes/" + id)).build());
            }));
        }).switchIfEmpty(Mono.defer(() -> {
            return Mono.just(ResponseEntity.badRequest().build());
        }));
    }

    private boolean validateRouteDefinition(RouteDefinition routeDefinition) {
        boolean hasValidFilterDefinitions = routeDefinition.getFilters().stream().allMatch((filterDefinition) -> {
            return this.GatewayFilters.stream().anyMatch((gatewayFilterFactory) -> {
                return filterDefinition.getName().equals(gatewayFilterFactory.name());
            });
        });
        boolean hasValidPredicateDefinitions = routeDefinition.getPredicates().stream().allMatch((predicateDefinition) -> {
            return this.routePredicates.stream().anyMatch((routePredicate) -> {
                return predicateDefinition.getName().equals(routePredicate.name());
            });
        });
        log.debug("FilterDefinitions valid: " + hasValidFilterDefinitions);
        log.debug("PredicateDefinitions valid: " + hasValidPredicateDefinitions);
        return hasValidFilterDefinitions && hasValidPredicateDefinitions;
    }
	
	//删除路由信息
    @DeleteMapping({"/routes/{id}"})
    public Mono<ResponseEntity<Object>> delete(@PathVariable String id) {
        return this.routeDefinitionWriter.delete(Mono.just(id)).then(Mono.defer(() -> {
            return Mono.just(ResponseEntity.ok().build());
        })).onErrorResume((t) -> {
            return t instanceof NotFoundException;
        }, (t) -> {
            return Mono.just(ResponseEntity.notFound().build());
        });
    }
	
	//根据路由id 获取组合过滤器
    @GetMapping({"/routes/{id}/combinedfilters"})
    public Mono<HashMap<String, Object>> combinedfilters(@PathVariable String id) {
        return this.routeLocator.getRoutes().filter((route) -> {
            return route.getId().equals(id);
        }).reduce(new HashMap(), this::putItem);
    }
}

获取全局过滤器演示如下：

在这里插入图片描述
其他接口不在一一演示。

通过 GatewayControllerEndpoint 和 AbstractGatewayControllerEndpoint 类的源码，我们可以知道 Gateway 提供获取路由信息、过滤器、断言等接口，这里面我们重点关注了的关于路由部分的，也是源码中涉及较多的，这两个类的源码提供了路由的增删改查及刷新的接口。

AbstractGatewayControllerEndpoint#save 方法源码分析

上面我们分析到 Gateway 源码提供了完整的增删改查及刷新的接口，我们重点来分析一下 Gateway 的新增路由的接口，也就是 AbstractGatewayControllerEndpoint#save 方法，该方法主要逻辑如下：

  • 校验新增路由的入参，入参不合法直接返回失败。
  • 调用 RouteDefinitionWriter 保存路由（实际调用的是 InMemoryRouteDefinitionRepository#save 方法）。
//org.springframework.cloud.gateway.actuate.AbstractGatewayControllerEndpoint#save
@PostMapping({"/routes/{id}"})
public Mono<ResponseEntity<Object>> save(@PathVariable String id, @RequestBody RouteDefinition route) {
	//this::validateRouteDefinition 路由参数校验
	return Mono.just(route).filter(this::validateRouteDefinition).flatMap((routeDefinition) -> {
		//this.routeDefinitionWriter.save 调用routeDefinitionWriter 进行保存
		return this.routeDefinitionWriter.save(Mono.just(routeDefinition).map((r) -> {
			r.setId(id);
			log.debug("Saving route: " + route);
			return r;
		})).then(Mono.defer(() -> {
			return Mono.just(ResponseEntity.created(URI.create("/routes/" + id)).build());
		}));
	}).switchIfEmpty(Mono.defer(() -> {
		return Mono.just(ResponseEntity.badRequest().build());
	}));
}

private boolean validateRouteDefinition(RouteDefinition routeDefinition) {
	//是否有重复的过滤器
	boolean hasValidFilterDefinitions = routeDefinition.getFilters().stream().allMatch((filterDefinition) -> {
		return this.GatewayFilters.stream().anyMatch((gatewayFilterFactory) -> {
			return filterDefinition.getName().equals(gatewayFilterFactory.name());
		});
	});
	//是否有重复的断言
	boolean hasValidPredicateDefinitions = routeDefinition.getPredicates().stream().allMatch((predicateDefinition) -> {
		return this.routePredicates.stream().anyMatch((routePredicate) -> {
			return predicateDefinition.getName().equals(routePredicate.name());
		});
	});
	log.debug("FilterDefinitions valid: " + hasValidFilterDefinitions);
	log.debug("PredicateDefinitions valid: " + hasValidPredicateDefinitions);
	return hasValidFilterDefinitions && hasValidPredicateDefinitions;
}

RouteDefinitionWriter 接口源码分析

我们上面分析到保存路由调用了的 RouteDefinitionWriter 接口的方法，RouteDefinitionWriter 中定义了保存路由和删除路由的方法，上面提到的 InMemoryRouteDefinitionRepository 间接实现了 RouteDefinitionWriter 接口。


public interface RouteDefinitionWriter {
	
	//保存路由
    Mono<Void> save(Mono<RouteDefinition> route);
	
	//删除路由
    Mono<Void> delete(Mono<String> routeId);
}

InMemoryRouteDefinitionRepository#save 方法源码分析

InMemoryRouteDefinitionRepository#save 方法的逻辑很简单，就只是把路由信息存入到 Map 对象 routes 中，基于内存的操作，因此 Gateway 重启之后就会丢失。

//org.springframework.cloud.gateway.route.InMemoryRouteDefinitionRepository#save
public Mono<Void> save(Mono<RouteDefinition> route) {
	//private final Map<String, RouteDefinition> routes = Collections.synchronizedMap(new LinkedHashMap());
	return route.flatMap((r) -> {
		if (StringUtils.isEmpty(r.getId())) {
			return Mono.error(new IllegalArgumentException("id may not be empty"));
		} else {
			//存入 routes 中  本质是一个 map
			this.routes.put(r.getId(), r);
			return Mono.empty();
		}
	});
}

AbstractGatewayControllerEndpoint#refresh 方法源码分析

AbstractGatewayControllerEndpoint#refresh 路由刷新功能，逻辑很简单，使用了事件监听的机制，发布了一个路由刷新事件。


//org.springframework.cloud.gateway.actuate.AbstractGatewayControllerEndpoint#refresh
@PostMapping({"/refresh"})
public Mono<Void> refresh() {
	//发布路由刷新事件
	this.publisher.publishEvent(new RefreshRoutesEvent(this));
	return Mono.empty();
}

CachingRouteLocator#onApplicationEvent 方法源码分析

CachingRouteLocator#onApplicationEvent 方法订阅 RefreshRoutesEvent 事件，主要做了以下两件事：

  • 调用 CachingRouteLocator#fetch 方法。
  • 发布路由刷新完成事件。

//org.springframework.cloud.gateway.route.CachingRouteLocator#onApplicationEvent
public void onApplicationEvent(RefreshRoutesEvent event) {
	try {
		//调用 CachingRouteLocator#fetch 方法
		this.fetch().collect(Collectors.toList()).subscribe((list) -> {
			Flux.fromIterable(list).materialize().collect(Collectors.toList()).subscribe((signals) -> {
				//发布路由刷新完成事件
				this.applicationEventPublisher.publishEvent(new RefreshRoutesResultEvent(this));
				this.cache.put("routes", signals);
			}, (throwable) -> {
				this.handleRefreshError(throwable);
			});
		});
	} catch (Throwable var3) {
		this.handleRefreshError(var3);
	}

}

CachingRouteLocator#fetch 方法源码分析

CachingRouteLocator#fetch 方法调用了


//org.springframework.cloud.gateway.route.CachingRouteLocator#fetch
private Flux<Route> fetch() {
	return this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE);
}

RouteDefinitionRouteLocator#getRoutes 方法源码分析

RouteDefinitionRouteLocator#getRoutes 方法主要逻辑如下：

  • 获取路由定义信息，调用 convertToRoute 方法将路由定义信息转换为路由信息 。
  • 将路由信息存入到 routes 中。
//org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getRoutes
public Flux<Route> getRoutes() {
	//调用 convertToRoute 方法将路由定义信息转化为路由
	Flux<Route> routes = this.routeDefinitionLocator.getRouteDefinitions().map(this::convertToRoute);
	if (!this.gatewayProperties.isFailOnRouteDefinitionError()) {
		routes = routes.onErrorContinue((error, obj) -> {
			if (this.logger.isWarnEnabled()) {
				this.logger.warn("RouteDefinition id " + ((RouteDefinition)obj).getId() + " will be ignored. Definition has invalid configs, " + error.getMessage());
			}

		});
	}
	
	//路由存储 routes 中
	return routes.map((route) -> {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("RouteDefinition matched: " + route.getId());
		}

		return route;
	});
}

如有不正确的地方请各位指出纠正。

码农爱java
关注
  • 16
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringCloud Gateway的使用 + Nacos动态路由
知道的越多 不知道的就越多
07-21 2万+
本文详细的分析gateway是如何使用和如何实现的，以及动态路由在gateway中的应用
基于Nacos实现Spring Cloud Gateway实现动态路由的方法示例
04-12
将Nacos与Spring Cloud Gateway结合，可以实现动态路由，即在运行时动态调整路由规则，提高系统的灵活性和可扩展性。 首先，我们要理解Spring Cloud Gateway的核心概念。它是一个基于Spring Framework 5、Project ...
springCloud之Gateway动态路由
M先生的博客
07-13 5041
学习gateway网关时，是以产品应用为目的，打算做一个类似于SAAS平台，网关负责统一的鉴权，日志记录，对外屏蔽真实的访问地址。路由信息也不能是写死在配置文件的，必须是提供管理页面可维护的。所以就略过配置文件，直接开启动态路由的实现。
SpringCloud-Gateway动态路由之Nacos
2401_85764455的博客
06-28 1011
当我们的网关Gateway程序开发完成之后，需要部署到生产环境，这个时候你的程序不能是单点运行的，肯定是多节点启动(独立部署或者docker等容器部署)，防止单节点故障导致整个服务不能访问，网关是对客户端的入口与出口，在生产运行中极为重要，哪怕是简单的重启也会导致部分请求的丢失。网关的路由配置这个时候就是一个大问题，是代码里面编写还是配置文件配置？他们都有一个致命的缺点，当有新的程序需要接入到网关进行路由或者有服务需要下线时候需要修改代码或者配置，然后重启整个网关程序，导致其他正常的服务路由受到了影响。
springcloud gateway动态路由
对象的博客
01-11 817
Component@Slf4j@Resource@Override//获取数据库路由信息//路由信息转为路由定义});//存入内存中@Override@Override。
spring cloud gateway 之 动态路由改造
lvjingang的博客
05-30 1287
目录 gateway本地文件常规路由配置 本地文件配置对业务造成的痛点 动态路由改造 1 gateway本地文件常规路由配置 我们先大致看下gateway中的常规概念 Route（路由）：路由是网关的基本单元，由ID、URI、一组Predicate、一组Filter组成，根据Predicate进行匹配转发。 Predicate（谓语、断言）：路由转发的判断条件，目前SpringCloud Gateway支持多种方式，常见如：Path、Query、Method、
详解Spring Cloud Gateway 数据库存储路由信息的扩展方案
08-26
本文详细介绍了 Spring Cloud Gateway 数据库存储路由信息的扩展方案，包括动态路由背景、动态路由实现、扩展思路等。通过扩展基于 Mysql + Redis 存储的分布式动态组件，可以满足实际生产过程中的动态刷新、实时...
详解Spring Cloud Gateway基于服务发现的默认路由规则
08-25
Spring Cloud Gateway的功能包括基于Spring Framework 5、Project Reactor和Spring Boot 2.0动态路由、Predicates和Filters、集成Hystrix断路器、集成Spring Cloud DiscoveryClient、易于编写的Predicates和Filters...
Spring Cloud GateWay 路由转发规则介绍详解
08-26
Predicate（谓语、断言）是路由转发的判断条件，目前 SpringCloud Gateway 支持多种方式，常见如：Path、Query、Method、Header 等。Filter（过滤器）是路由转发请求时所经过的过滤逻辑，用于修改请求、响应内容。 ...
spring_cloud_gateway负载均衡，动态路由
12-11
spring cloud gateway的负载均衡和动态路由的实现 demo_01,demo_02,demo_03 这三个服务相当于是集群的微服务 gateway这个服务是 springcloude gateway + ribbon 做的负载均衡 gateway_01 这个服务 是动态路由的...
【链表在Java中DeBug】
在这个充满危险的乱世之中，只有学会烤鸡才能顽强的活下去。
08-19 308
时，你实际上是在告诉当前节点 cur：“你的下一个节点应该是这个新创建的节点。，你将 cur 的引用更新为新创建的节点，这样 cur 现在就指向了你刚刚添加到链表末尾的节点。实际上，head 是一个固定的引用，它始终指向链表的第一个节点（即头节点）。当你看到链表似乎“增长”了，这实际上是因为你通过操作 cur（当前节点的引用）在链表的末尾添加了新的节点。所以，当你看到链表“增长”时，你实际上是在通过更新节点之间的链接（即 next 指针）来扩展链表结构。它只是保持了对链表起始节点的引用。
Spring Boot实现简单的Oracle数据库操作
beautiful77moon的博客
08-18 453
使用到的技术：1. Spring Boot：用于简化Spring应用的开发。2. Dynamic DataSource：实现动态多数据源的访问和切换3. Oracle JDBC Driver：与Oracle数据库进行连接和交互。4. Mybatis-Plus：简化SQL映射和数据库访问。其中BaseMapper接口提供了对数据表进行基本操作的功能。5. Lombok：用于简化Java类的开发，自动生成常用的代码，比如getter、setter、构造函数等。
【Spring框架】
m0_71941456的博客
08-18 1029
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 551
【代码】springboot网上商品订单转手系统bootpf
指针详解（四）
Limerence_Aries的博客
08-18 1021
目录1. 字符指针变量2. 数组指针变量3. 数组指针变初始化4. 二维数组传参的本质5. 函数指针变量1）函数指针变量的创建2）函数指针变量的使用3）代码解析6. typedef关键字7. 函数指针数组8. 转移表 代码const char* pstr = "hello bit."; 不是把字符串 hello bit 放到字符指针 pstr 里，而是把字符串hello bit.的首字符的地址放到了pstr中我们通过一道例题加深理解 所以数组指针变量：存放的应该是数组的地址，能够指向数组的指针变
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 535
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
Java学习_18_Stream流
最新发布
qq_41136689的博客
08-23 766
博客仅记录个人学习进度和一些查缺补漏。学习内容：BV17F411T7Ao流的出现让数据处理从几十行代码缩减到一两行就能实现，简化了很多集合数组的操作。
微服务框架
Founder_Xiao_Xin的博客
08-20 761
在分布式系统中，服务可能失败导致雪崩，Hystrix 是防雪崩利器，具有服务降级、服务熔断、服务隔离、监控等防止雪崩的技术。服务降级：接口调用失败调用本地方法返回空。服务熔断：接口调用失败进入熔断方法返回错误信息。服务隔离：隔离服务之间相互影响。服务监控：记录服务调用的运行指标。在分布式系统中，一个业务因跨越不同数据库或不同微服务而包含多个子事务，要求所有子事务同时成功或失败，这就是分布式事务。例如某电商系统下单操作，需请求订单服务、账户服务、库存服务。
SpringBoot如何做自动配置
Z_DOUBLE_Y的博客
08-18 834
Spring Boot通过注解开启自动配置，对autoconfigured的jar包下的META-INF下的spring包中下的spring.factories文件进行扫描，这个文件中包含了可以进行自动配置的类，当满足@Condition注解指定的条件时，便在依赖的支持下进行实例化，注册到Spring容器中。用注解来对一些常规的配置做默认配置，简化了各种xml配置内容，使项目能够快速运行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值