devbox
凡人多烦事01
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

详解SpringCloud-gateway动态路由两种方式，以及路由加载过程_compositeroutedefinitionlocator

作者：凡人多烦事01 | 2024-03-26 12:40:28

赞

踩

compositeroutedefinitionlocator

gateway配置路由主要有两种方式，一种是用yml配置文件，一种是写代码里，这两种方式都是不支持动态配置的。如：

下面就来看看gateway是如何加载这些配置信息的。

1 路由初始化

无论是yml还是代码，这些配置最终都是被封装到RouteDefinition对象中。

一个RouteDefinition有个唯一的ID，如果不指定，就默认是UUID，多个RouteDefinition组成了gateway的路由系统。

所有路由信息在系统启动时就被加载装配好了，并存到了内存里。我们从源码来看看。

圆圈里就是装配yml文件的，它返回的是PropertiesRouteDefinitionLocator，该类继承了RouteDefinitionLocator，RouteDefinitionLocator就是路由的装载器，里面只有一个方法，就是获取路由信息的。该接口有多个实现类，分别对应不同方式配置的路由方式。

通过这几个实现类，再结合上面的AutoConfiguration里面的Primary信息，就知道加载配置信息的顺序。

PropertiesRouteDefinitionLocator-->|配置文件加载初始化| CompositeRouteDefinitionLocator
RouteDefinitionRepository-->|存储器中加载初始化| CompositeRouteDefinitionLocator
DiscoveryClientRouteDefinitionLocator-->|注册中心加载初始化| CompositeRouteDefinitionLocator

参考：https://www.jianshu.com/p/b02c7495eb5e

https://blog.csdn.net/X5fnncxzq4/article/details/80221488

这是第一顺序，就是从CachingRouteLocator中获取路由信息，我们可以打开该类进行验证。

不管发起什么请求，必然会走上面的断点处。请求一次，走一次。这是将路由信息缓存到了Map中。配置信息一旦请求过一次，就会被缓存到上图的CachingRouteLocator类中，再次发起请求后，会直接从map中读取。

如果想动态刷新配置信息，就需要发起一个RefreshRoutesEvent的事件，上图的cache会监听该事件，并重新拉取路由配置信息。

通过下图，可以看到如果没有RouteDefinitionRepository的实例，则默认用InMemoryRouteDefinitionRepository。而做动态路由的关键就在这里。即通过自定义的RouteDefinitionRepository类，来提供路由配置信息。

例如：

在getRouteDefinitions方法返回你自定义的路由配置信息即可。这里可以用数据库、nosql等等任意你喜欢的方式来提供。而且配置信息修改后，发起一次RefreshRoutesEvent事件即可让配置生效。这就是动态配置路由的核心所在，下面来看具体代码实现。

2 基于数据库、缓存的动态路由

pom.xml如下

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.  
  6.     <groupId>com.maimeng</groupId>
  7.     <artifactId>apigateway</artifactId>
  8.     <version>0.0.1-SNAPSHOT</version>
  9.     <packaging>jar</packaging>
  10.  
  11.     <name>apigateway</name>
  12.     <description>Demo project for Spring Boot</description>
  13.  
  14.     <parent>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-parent</artifactId>
  17.         <version>2.0.6.RELEASE</version>
  18.         <relativePath/> <!-- lookup parent from repository -->
  19.     </parent>
  20.  
  21.     <properties>
  22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  24.         <java.version>1.8</java.version>
  25.         <spring-cloud.version>Finchley.SR1</spring-cloud.version>
  26.     </properties>
  27.  
  28.     <dependencies>
  29.         <dependency>
  30.             <groupId>org.springframework.cloud</groupId>
  31.             <artifactId>spring-cloud-starter-gateway</artifactId>
  32.         </dependency>
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-webflux</artifactId>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework.boot</groupId>
  39.             <artifactId>spring-boot-starter-actuator</artifactId>
  40.         </dependency>
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-data-redis</artifactId>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>com.alibaba</groupId>
  47.             <artifactId>fastjson</artifactId>
  48.             <version>1.2.51</version>
  49.         </dependency>
  50.         <!--<dependency>
  51.             <groupId>mysql</groupId>
  52.             <artifactId>mysql-connector-java</artifactId>
  53.             <scope>runtime</scope>
  54.         </dependency>-->
  55.         <dependency>
  56.             <groupId>org.springframework.boot</groupId>
  57.             <artifactId>spring-boot-starter-test</artifactId>
  58.             <scope>test</scope>
  59.         </dependency>
  60.     </dependencies>
  61.  
  62.     <dependencyManagement>
  63.         <dependencies>
  64.             <dependency>
  65.                 <groupId>org.springframework.cloud</groupId>
  66.                 <artifactId>spring-cloud-dependencies</artifactId>
  67.                 <version>${spring-cloud.version}</version>
  68.                 <type>pom</type>
  69.                 <scope>import</scope>
  70.             </dependency>
  71.         </dependencies>
  72.     </dependencyManagement>
  73.  
  74.     <build>
  75.         <plugins>
  76.             <plugin>
  77.                 <groupId>org.springframework.boot</groupId>
  78.                 <artifactId>spring-boot-maven-plugin</artifactId>
  79.             </plugin>
  80.         </plugins>
  81.     </build>
  82.  
  83.  
  84. </project>

注意这里是SR1，经测试SR2有bug，会出问题。

  1. @Configuration
  2. public class RedisConfig {
  3.  
  4.     @Bean(name = {"redisTemplate", "stringRedisTemplate"})
  5.     public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {
  6.         StringRedisTemplate redisTemplate = new StringRedisTemplate();
  7.         redisTemplate.setConnectionFactory(factory);
  8.         return redisTemplate;
  9.     }
  10.  
  11. }

核心类：

  1. @Component
  2. public class RedisRouteDefinitionRepository implements RouteDefinitionRepository {
  3.  
  4.     public static final String GATEWAY_ROUTES = "geteway_routes";
  5.  
  6.     @Resource
  7.     private StringRedisTemplate redisTemplate;
  8.  
  9.     @Override
  10.     public Flux<RouteDefinition> getRouteDefinitions() {
  11.         List<RouteDefinition> routeDefinitions = new ArrayList<>();
  12.         redisTemplate.opsForHash().values(GATEWAY_ROUTES).stream()
  13.                 .forEach(routeDefinition -> routeDefinitions.add(JSON.parseObject(routeDefinition.toString(), RouteDefinition.class)));
  14.         return Flux.fromIterable(routeDefinitions);
  15.     }
  16.  
  17.     @Override
  18.     public Mono<Void> save(Mono<RouteDefinition> route) {
  19.         return null;
  20.     }
  21.  
  22.     @Override
  23.     public Mono<Void> delete(Mono<String> routeId) {
  24.         return null;
  25.     }
  26.  
  27. }

主要是在get方法里，此处从redis里获取配置好的Definition。

然后我们的工作就是将配置信息，放到redis里即可。

下面就是我模拟的一个配置，等同于在yml里

  1. spring:
  2.   cloud:
  3.     gateway:
  4.       routes:
  5.       - id: header
  6.         uri: http://localhost:8888/header
  7.         filters:
  8.         - AddRequestHeader=header, addHeader
  9.         - AddRequestParameter=param, addParam
  10.         predicates:
  11.         - Path=/jd
  1. @Resource
  2.     private StringRedisTemplate redisTemplate;
  3.     @PostConstruct
  4.     public void main() {
  5.         RouteDefinition definition = new RouteDefinition();
  6.         definition.setId("id");
  7.         URI uri = UriComponentsBuilder.fromHttpUrl("http://127.0.0.1:8888/header").build().toUri();
  8.        // URI uri = UriComponentsBuilder.fromHttpUrl("http://baidu.com").build().toUri();
  9.         definition.setUri(uri);
  10.  
  11.         //定义第一个断言
  12.         PredicateDefinition predicate = new PredicateDefinition();
  13.         predicate.setName("Path");
  14.  
  15.         Map<String, String> predicateParams = new HashMap<>(8);
  16.         predicateParams.put("pattern", "/jd");
  17.         predicate.setArgs(predicateParams);
  18.  
  19.         //定义Filter
  20.         FilterDefinition filter = new FilterDefinition();
  21.         filter.setName("AddRequestHeader");
  22.         Map<String, String> filterParams = new HashMap<>(8);
  23.         //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
  24.         filterParams.put("_genkey_0", "header");
  25.         filterParams.put("_genkey_1", "addHeader");
  26.         filter.setArgs(filterParams);
  27.  
  28.         FilterDefinition filter1 = new FilterDefinition();
  29.         filter1.setName("AddRequestParameter");
  30.         Map<String, String> filter1Params = new HashMap<>(8);
  31.         filter1Params.put("_genkey_0", "param");
  32.         filter1Params.put("_genkey_1", "addParam");
  33.         filter1.setArgs(filter1Params);
  34.  
  35.         definition.setFilters(Arrays.asList(filter, filter1));
  36.         definition.setPredicates(Arrays.asList(predicate));
  37.  
  38.         System.out.println("definition:" + JSON.toJSONString(definition));
  39.         redisTemplate.opsForHash().put(GATEWAY_ROUTES, "key", JSON.toJSONString(definition));
  40.     }

定义好后，将其放到redis里，之后启动项目访问/jd，再启动后台的localhost:8888项目。即可进行验证。

之后如果要动态修改配置，就可以通过类似于上面的方式，来获取json字符串，然后将字符串放到redis里进行替换。替换后，需要通知gateway主动刷新一下。

刷新时，可以定义一个controller，然后调用一下notifyChanged()方法，就能完成新配置的替换了。

3 通过REST接口

gateway是自带接口能增删改查配置的，这个网上有比较多的教程，随便找个看看就明白了。譬如：

http://springcloud.cn/view/368

我发个类作为参考

  1. package com.maimeng.apigateway.route;
  2.  
  3. import com.alibaba.fastjson.JSON;
  4. import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
  5. import org.springframework.cloud.gateway.filter.FilterDefinition;
  6. import org.springframework.cloud.gateway.handler.predicate.PredicateDefinition;
  7. import org.springframework.cloud.gateway.route.RouteDefinition;
  8. import org.springframework.cloud.gateway.route.RouteDefinitionWriter;
  9. import org.springframework.context.ApplicationEventPublisher;
  10. import org.springframework.context.ApplicationEventPublisherAware;
  11. import org.springframework.data.redis.core.StringRedisTemplate;
  12. import org.springframework.stereotype.Service;
  13. import org.springframework.web.util.UriComponentsBuilder;
  14. import reactor.core.publisher.Mono;
  15.  
  16. import javax.annotation.PostConstruct;
  17. import javax.annotation.Resource;
  18. import java.net.URI;
  19. import java.util.Arrays;
  20. import java.util.HashMap;
  21. import java.util.Map;
  22.  
  23. import static com.maimeng.apigateway.repository.RedisRouteDefinitionRepository.GATEWAY_ROUTES;
  24.  
  25. /**
  26.  * @author wuweifeng wrote on 2018/10/25.
  27.  */
  28. @Service
  29. public class DynamicRouteService implements ApplicationEventPublisherAware {
  30.  
  31.     @Resource
  32.     private RouteDefinitionWriter routeDefinitionWriter;
  33.  
  34.     private ApplicationEventPublisher publisher;
  35.  
  36.     private void notifyChanged() {
  37.         this.publisher.publishEvent(new RefreshRoutesEvent(this));
  38.     }
  39.  
  40.  
  41.     /**
  42.      * 增加路由
  43.      *
  44.      */
  45.     public String add(RouteDefinition definition) {
  46.         routeDefinitionWriter.save(Mono.just(definition)).subscribe();
  47.         notifyChanged();
  48.         return "success";
  49.     }
  50.  
  51.  
  52.     /**
  53.      * 更新路由
  54.      */
  55.     public String update(RouteDefinition definition) {
  56.         try {
  57.             this.routeDefinitionWriter.delete(Mono.just(definition.getId()));
  58.         } catch (Exception e) {
  59.             return "update fail,not find route  routeId: " + definition.getId();
  60.         }
  61.         try {
  62.             routeDefinitionWriter.save(Mono.just(definition)).subscribe();
  63.             notifyChanged();
  64.             return "success";
  65.         } catch (Exception e) {
  66.             return "update route  fail";
  67.         }
  68.  
  69.  
  70.     }
  71.  
  72.     /**
  73.      * 删除路由
  74.      *
  75.      */
  76.     public String delete(String id) {
  77.         try {
  78.             this.routeDefinitionWriter.delete(Mono.just(id)).subscribe();
  79.  
  80.             notifyChanged();
  81.             return "delete success";
  82.         } catch (Exception e) {
  83.             e.printStackTrace();
  84.             return "delete fail";
  85.         }
  86.  
  87.     }
  88.  
  89.     @Override
  90.     public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
  91.         this.publisher = applicationEventPublisher;
  92.     }
  93.  
  94.     @Resource
  95.     private StringRedisTemplate redisTemplate;
  96.     @PostConstruct
  97.     public void main() {
  98.         RouteDefinition definition = new RouteDefinition();
  99.         definition.setId("id");
  100.         URI uri = UriComponentsBuilder.fromHttpUrl("http://127.0.0.1:8888/header").build().toUri();
  101.        // URI uri = UriComponentsBuilder.fromHttpUrl("http://baidu.com").build().toUri();
  102.         definition.setUri(uri);
  103.  
  104.         //定义第一个断言
  105.         PredicateDefinition predicate = new PredicateDefinition();
  106.         predicate.setName("Path");
  107.  
  108.         Map<String, String> predicateParams = new HashMap<>(8);
  109.         predicateParams.put("pattern", "/jd");
  110.         predicate.setArgs(predicateParams);
  111.  
  112.         //定义Filter
  113.         FilterDefinition filter = new FilterDefinition();
  114.         filter.setName("AddRequestHeader");
  115.         Map<String, String> filterParams = new HashMap<>(8);
  116.         //该_genkey_前缀是固定的，见org.springframework.cloud.gateway.support.NameUtils类
  117.         filterParams.put("_genkey_0", "header");
  118.         filterParams.put("_genkey_1", "addHeader");
  119.         filter.setArgs(filterParams);
  120.  
  121.         FilterDefinition filter1 = new FilterDefinition();
  122.         filter1.setName("AddRequestParameter");
  123.         Map<String, String> filter1Params = new HashMap<>(8);
  124.         filter1Params.put("_genkey_0", "param");
  125.         filter1Params.put("_genkey_1", "addParam");
  126.         filter1.setArgs(filter1Params);
  127.  
  128.         definition.setFilters(Arrays.asList(filter, filter1));
  129.         definition.setPredicates(Arrays.asList(predicate));
  130.  
  131.         System.out.println("definition:" + JSON.toJSONString(definition));
  132.         redisTemplate.opsForHash().put(GATEWAY_ROUTES, "key", JSON.toJSONString(definition));
  133.     }
  134. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/317425?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号