Spring Cloud Gateway（四）：路由定义定位器 RouteDefinitionLocator

梦里梦外; 2022-04-14 04:43 327阅读 0赞

> 本文基于 spring cloud gateway 2.0.1

## 1、简介 ##

RouteDefinitionLocator 是路由定义定位器的顶级接口，它的主要作用就是读取路由的配置信息（org.springframework.cloud.gateway.route.RouteDefinition）。它有五种不同的实现类，如图

![路由定义定位器][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]

## 2、RouteDefinitionLocator ##

org.springframework.cloud.gateway.route.RouteDefinitionLocator ，路由定义定位器接口，只有一个方法，用来获取路由定义列表的方法。

public interface RouteDefinitionLocator {
    
    	Flux<RouteDefinition> getRouteDefinitions();
    }

通过 RouteDefinitionLocator 的类图，可以看出该接口有多个实现类：

*  PropertiesRouteDefinitionLocator：基于属性配置
 *  DiscoveryClientRouteDefinitionLocator：基于服务发现
 *  CompositeRouteDefinitionLocator：组合方式
 *  CachingRouteDefinitionLocator：缓存方式
 *  其中还有一个接口 RouteDefinitionRepository 继承自RouteDefinitionLocator，用于对路由定义的操作（保存、删除路由定义）

### 2.1、RouteDefinition ###

RouteDefinition 作为GatewayProperties中的属性，在网关启动的时候读取配置文件中的相关配置信息

@Validated
    public class RouteDefinition {
        
        @NotEmpty
        private String id = UUID.randomUUID().toString();
        
       
        @NotEmpty
        @Valid
        private List<PredicateDefinition> predicates = new ArrayList();
        
       
        @Valid
        private List<FilterDefinition> filters = new ArrayList();
        
     
        @NotNull
        private URI uri;
        
        
        private int order = 0;
    
        public RouteDefinition() {
        }
    
        public RouteDefinition(String text) {
            int eqIdx = text.indexOf(61);
            if (eqIdx <= 0) {
                throw new ValidationException("Unable to parse RouteDefinition text '" + text + "', must be of the form name=value");
            } else {
                this.setId(text.substring(0, eqIdx));
                String[] args = StringUtils.tokenizeToStringArray(text.substring(eqIdx + 1), ",");
                this.setUri(URI.create(args[0]));
    
                for(int i = 1; i < args.length; ++i) {
                    this.predicates.add(new PredicateDefinition(args[i]));
                }
    
            }
        }
       ----------------------省略----------------------------
    }

在 RouteDefinition 中，主要有五个属性：

id：路由id，默认为uuid
    
    predicates：PredicateDefinition 路由断言定义列表
    
    filters：FilterDefinition 过滤器定义列表
    
    uri：URI 转发地址
    
    order：优先级

进入断言和路由器属性可以看到他们是一个 Map 数据结构，可以存放多个对应的 键值对数组

## 3、RouteDefinitionRepository & InMemoryRouteDefinitionRepository ##

RouteDefinitionRepository 接口中的方法用来对RouteDefinition进行增、删、查操作

public interface RouteDefinitionRepository extends RouteDefinitionLocator, RouteDefinitionWriter {
    }
    //读取路由定义信息
    public interface RouteDefinitionLocator {
    
    	Flux<RouteDefinition> getRouteDefinitions();
    }
    //对路由定会进行保存和删除操作
    public interface RouteDefinitionWriter {
        Mono<Void> save(Mono<RouteDefinition> route);
    
        Mono<Void> delete(Mono<String> routeId);
    }

RouteDefinitionRepository 通过继承自 RouteDefinitionLocator、 RouteDefinitionWriter，封装了对路由定义信息的获取、增加、删除操作，在网关内置API端点接口时会用到这些操作。

InMemoryRouteDefinitionRepository 实现了 RouteDefinitionRepository 接口，基于内存的路由定义仓库，同时也是唯一提供的实现类。我们可以根据需要自定义扩展，存放到其它的存储介质中。

public class InMemoryRouteDefinitionRepository implements RouteDefinitionRepository {
        private final Map<String, RouteDefinition> routes = Collections.synchronizedMap(new LinkedHashMap());
    
        public InMemoryRouteDefinitionRepository() {
        }
    
        //保存路由定义到内存中
        public Mono<Void> save(Mono<RouteDefinition> route) {
            return route.flatMap((r) -> {
                this.routes.put(r.getId(), r);
                return Mono.empty();
            });
        }
        //根据路由id从内存中删除指定路由定义
        public Mono<Void> delete(Mono<String> routeId) {
            return routeId.flatMap((id) -> {
                if (this.routes.containsKey(id)) {
                    this.routes.remove(id);
                    return Mono.empty();
                } else {
                    return Mono.defer(() -> {
                        return Mono.error(new NotFoundException("RouteDefinition not found: " + routeId));
                    });
                }
            });
        }
    
        //获取内存中路由定义列表
        public Flux<RouteDefinition> getRouteDefinitions() {
            return Flux.fromIterable(this.routes.values());
        }
    }

## 4、PropertiesRouteDefinitionLocator 基于配置属性的路由定义定位器 ##

从配置文件 yaml或properties中读取路由配置信息，如代码所示

public class PropertiesRouteDefinitionLocator implements RouteDefinitionLocator {
        private final GatewayProperties properties;
    
        public PropertiesRouteDefinitionLocator(GatewayProperties properties) {
            this.properties = properties;
        }
    
        public Flux<RouteDefinition> getRouteDefinitions() {
            return Flux.fromIterable(this.properties.getRoutes());
        }
    }

PropertiesRouteDefinitionLocator 通过构造函数传入 GatewayProperties 对象，然后从该对象中读取路由配置信息

## 5、DiscoveryClientRouteDefinitionLocator 基于服务发现的路由定义定位器 ##

该类通过服务发现组件从注册中心获取服务信息，此时路由定义的源就是配置中心

public class DiscoveryClientRouteDefinitionLocator implements RouteDefinitionLocator {
        //服务发现客户端
        private final DiscoveryClient discoveryClient;
        //服务发现属性
        private final DiscoveryLocatorProperties properties;
        //路由id前缀
        private final String routeIdPrefix;
    
       ------------------------------省略--------------------------------
    }
    //服务发现属性对象
    @ConfigurationProperties("spring.cloud.gateway.discovery.locator")
    public class DiscoveryLocatorProperties {
       // 开启服务发现
       private boolean enabled = false; 
       // 路由前缀，默认为 discoveryClient. getClass(). getSimpleName() + "_". 
       private String routeIdPrefix; 
       // SpEL 表达式，判断网关是否集成一个服务，默认为 true 
       private String includeExpression = "true"; 
       // SpEL 表达式，为每个路由创建uri，默认为'lb://'+ serviceId 
       private String urlExpression = "'lb://'+ serviceId"; 
       // 在 断言 和 过滤器 中使用小写 serviceId，默认为 false
       private boolean lowerCaseServiceId = false;
        //路由断言定义列表
        private List<PredicateDefinition> predicates = new ArrayList();
        //过滤器定义列表
        private List<FilterDefinition> filters = new ArrayList();
      ------------------------------省略--------------------------------
    }

在 DiscoveryLocatorProperties 定义了以上属性，要启用基于服务发现的路由定义定位器就必须设置

spring.cloud.gateway.discovery.locator.enabled= true

includeExpression 属性判断网关是否集成一个服务，默认为true，  
根据 includeExpression 表达式，过滤不符合的 ServiceInstance。

DiscoveryClientRouteDefinitionLocator -> getRouteDefinitions()

@Override
    	public Flux<RouteDefinition> getRouteDefinitions() {
            //对 includeExpression 和 urlExpression 的 表达式 处理
    		SpelExpressionParser parser = new SpelExpressionParser();
    		Expression includeExpr = parser.parseExpression(properties.getIncludeExpression());
    		Expression urlExpr = parser.parseExpression(properties.getUrlExpression());
    
    		Predicate<ServiceInstance> includePredicate;
    		if (properties.getIncludeExpression() == null || "true".equalsIgnoreCase(properties.getIncludeExpression())) {
    			includePredicate = instance -> true;
    		} else {
    			includePredicate = instance -> {
    				Boolean include = includeExpr.getValue(evalCtxt, instance, Boolean.class);
    				if (include == null) {
    					return false;
    				}
    				return include;
    			};
    		}
            //通过注册中心查找服务组装路由定义信息
    		return Flux.fromIterable(discoveryClient.getServices())
    				.map(discoveryClient::getInstances)
    				.filter(instances -> !instances.isEmpty())
    				.map(instances -> instances.get(0))
    				// 根据 includeExpression 表达式,过滤不符合的 ServiceInstance
    				.filter(includePredicate)
    				.map(instance -> {
    					String serviceId = instance.getServiceId();
    
                        RouteDefinition routeDefinition = new RouteDefinition();
                        routeDefinition.setId(this.routeIdPrefix + serviceId);
    					String uri = urlExpr.getValue(evalCtxt, instance, String.class);
    					routeDefinition.setUri(URI.create(uri));
    
    					final ServiceInstance instanceForEval = new DelegatingServiceInstance(instance, properties);
                        
                        //添加配置的断言表达式
    					for (PredicateDefinition original : this.properties.getPredicates()) {
    						PredicateDefinition predicate = new PredicateDefinition();
    						predicate.setName(original.getName());
    						for (Map.Entry<String, String> entry : original.getArgs().entrySet()) {
    							String value = getValueFromExpr(evalCtxt, parser, instanceForEval, entry);
    							predicate.addArg(entry.getKey(), value);
    						}
    						routeDefinition.getPredicates().add(predicate);
    					}
                        
                        //添加配置的过滤器
                        for (FilterDefinition original : this.properties.getFilters()) {
                        	FilterDefinition filter = new FilterDefinition();
                        	filter.setName(original.getName());
    						for (Map.Entry<String, String> entry : original.getArgs().entrySet()) {
    							String value = getValueFromExpr(evalCtxt, parser, instanceForEval, entry);
    							filter.addArg(entry.getKey(), value);
    						}
    						routeDefinition.getFilters().add(filter);
    					}
    
                        return routeDefinition;
    				});
    	}
    
    	String getValueFromExpr(SimpleEvaluationContext evalCtxt, SpelExpressionParser parser, ServiceInstance instance, Map.Entry<String, String> entry) {
    		Expression valueExpr = parser.parseExpression(entry.getValue());
    		return valueExpr.getValue(evalCtxt, instance, String.class);
    	}
    
    	private static class DelegatingServiceInstance implements ServiceInstance {
    
    		final ServiceInstance delegate;
    		private final DiscoveryLocatorProperties properties;
    
    		private DelegatingServiceInstance(ServiceInstance delegate, DiscoveryLocatorProperties properties) {
    			this.delegate = delegate;
    			this.properties = properties;
    		}
    
    		@Override
    		public String getServiceId() {
    			if (properties.isLowerCaseServiceId()) {
    				return delegate.getServiceId().toLowerCase();
    			}
    			return delegate.getServiceId();
    		}
    
    	
    	}

从源码可以看出，getRouteDefinitions 方法通过服务发现客户端从注册中心获取服务信息，组装成RouteDefinition路由定义列表，并将配置中的路由断言和过滤应用到RouteDefinition 中

## 6、CachingRouteDefinitionLocator 基于缓存的路由定义定位器 ##

缓存方式的路由定义定位器，通过传入路由定义定位器获取路由定义并缓存到本地。通过监听路由刷新时间RefreshRoutesEvent 来刷新本地缓存的路由定义信息

public class CachingRouteDefinitionLocator implements RouteDefinitionLocator {
        //路由定义定位器
        private final RouteDefinitionLocator delegate;
        //路由定义信息
        private final Flux<RouteDefinition> routeDefinitions;
        //本地缓存集合
        private final Map<String, List> cache = new HashMap();
    
        public CachingRouteDefinitionLocator(RouteDefinitionLocator delegate) {
            this.delegate = delegate;
            this.routeDefinitions = CacheFlux.lookup(this.cache, "routeDefs", RouteDefinition.class).onCacheMissResume(() -> {
                return this.delegate.getRouteDefinitions();
            });
        }
    
        public Flux<RouteDefinition> getRouteDefinitions() {
            return this.routeDefinitions;
        }
    
        //刷新本地缓存，先清空本地缓存再获取一份新的路由定义信息存储
        public Flux<RouteDefinition> refresh() {
            this.cache.clear();
            return this.routeDefinitions;
        }
       //监听路由刷新事件，刷新本地缓存的路由定义信息
        @EventListener({RefreshRoutesEvent.class})
        void handleRefresh() {
            this.refresh();
        }
    }

## 7、CompositeRouteDefinitionLocator 组合路由定义定位器 ##

组合方式路由定义定位器使用组合模式进行实现，组合多个 RouteDefinitionLocator 的实现，为获取路由定义信息 getRouteDefinitions 提供统一入口，组合的逻辑很简单，通过传入的路由定义定位器作为代理，具体的路由定义实际上是由传入的路由定义定位器产生。

public class CompositeRouteDefinitionLocator implements RouteDefinitionLocator {
        private final Flux<RouteDefinitionLocator> delegates;
    
        public CompositeRouteDefinitionLocator(Flux<RouteDefinitionLocator> delegates) {
            this.delegates = delegates;
        }
    
        public Flux<RouteDefinition> getRouteDefinitions() {
            return this.delegates.flatMap(RouteDefinitionLocator::getRouteDefinitions);
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA2NDcwMzU_size_16_color_FFFFFF_t_70]: /images/20220414/574117f78ceb4754a5b8a872ce6266d8.png