环境:springcloud Hoxton.SR11
(资料图片)
本节主要了解系统中的谓词与配置的路由信息是如何进行初始化关联生成路由对象的。每个谓词工厂中的Config对象又是如何被解析配置的。
所有的谓词工厂中的Config中属性值是如何被配置的。
在SpringCloud Gateway中的所有谓词工厂如下:
图片
命名规则:XxxRoutePredicateFactory。所有的这些谓词工厂都是如下的继承关系
public class MethodRoutePredicateFactory extends AbstractRoutePredicateFactory// public class PathRoutePredicateFactory extends AbstractRoutePredicateFactory// ...
所有的谓词工厂继承的AbstractRoutePredicateFactory中的泛型都是内部类的Config。这个是如何被配置上值的呢?
1.1 gateway自动配置在下面这个类中配置了所有的Predicate和Filter。
public class GatewayAutoConfiguration { @Bean @ConditionalOnEnabledPredicate public PathRoutePredicateFactory pathRoutePredicateFactory() { return new PathRoutePredicateFactory(); } @Bean @ConditionalOnEnabledPredicate public QueryRoutePredicateFactory queryRoutePredicateFactory() { return new QueryRoutePredicateFactory(); } @Bean public RouteLocator routeDefinitionRouteLocator(GatewayProperties properties, List gatewayFilters, List predicates, RouteDefinitionLocator routeDefinitionLocator, ConfigurationService configurationService) { return new RouteDefinitionRouteLocator(routeDefinitionLocator, predicates, gatewayFilters, properties, configurationService); } @Bean @Primary @ConditionalOnMissingBean(name = "cachedCompositeRouteLocator") public RouteLocator cachedCompositeRouteLocator(List routeLocators) { return new CachingRouteLocator(new CompositeRouteLocator(Flux.fromIterable(routeLocators))); }}
这里会层层委托最终查找查找路由定位会交给RouteDefinitionRouteLocator。CachingRouteLocator起到缓存的作用,将配置的所有路由信息保存。
注意:这里的路由信息是在容器启动后就会被初始化的。
public class CachingRouteLocator { private final RouteLocator delegate; private final Flux routes; private final Map cache = new ConcurrentHashMap<>(); private ApplicationEventPublisher applicationEventPublisher; public CachingRouteLocator(RouteLocator delegate) { this.delegate = delegate; routes = CacheFlux.lookup(cache, CACHE_KEY, Route.class) .onCacheMissResume(this::fetch); } private Flux fetch() { return this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE); }}
实例化CachingRouteLocator就开始查找所有配置的Route信息。最终的会委托给RouteDefinitionRouteLocator
RouteDefinitionRouteLocator构造函数中的initFactories方法用来映射路由工厂的XxxRoutePredicateFactory。
private void initFactories(List predicates) { predicates.forEach(factory -> { String key = factory.name(); if (this.predicates.containsKey(key)) { this.logger.warn("A RoutePredicateFactory named " + key + " already exists, class: " + this.predicates.get(key) + ". It will be overwritten."); } this.predicates.put(key, factory); });}
方法中解析每一个谓词工厂对应的名称然后缓存到predicates 集合中。
factory.name()方法解析谓词名称。
default String name() { return NameUtils.normalizeRoutePredicateName(getClass());}
CachingRouteLocator是个缓存路由定位器,是个首选的RouteLocator(@Primary),这里将RouteDefinitionRouteLocator进行了合并。
1.2 生成路由对象Route及Config配置getRoutes---》convertToRoute---》combinePredicates---》lookup。
根据上面的自动配置也知道了在服务启动时就进行初始化所有路由信息了。
获取路由信息
public Flux getRoutes() { Flux routes = this.routeDefinitionLocator.getRouteDefinitions() .map(this::convertToRoute); routes = routes.onErrorContinue((error, obj) -> { return routes.map(route -> { return route; });}
合并谓词(链式调用)
private AsyncPredicate combinePredicates( RouteDefinition routeDefinition) { // other code for (PredicateDefinition andPredicate : predicates.subList(1, predicates.size())) { AsyncPredicate found = lookup(routeDefinition, andPredicate); predicate = predicate.and(found); } return predicate;}
进入lookup中
private AsyncPredicate lookup(RouteDefinition route, PredicateDefinition predicate) { RoutePredicateFactory
lookup方法中查找,也就是在这里将对应的谓词Config与RouteDefinition(Predicate)中定义的相对应的属性关联。
进入factory.applyAsync方法
@FunctionalInterfacepublic interface RoutePredicateFactory extends ShortcutConfigurable, Configurable { default AsyncPredicate applyAsync(C config) { return toAsyncPredicate(apply(config)); // 查看下面的6.2-1图当前apply所有的实现就是系统内部定义的XxxRoutePredicateFactory }}// apply(config),如这里配置了Path谓词,那么就会进入PathRoutePredicateFactory中的apply方法public Predicate apply(Config config) { // other code return new GatewayPredicate() { public boolean test() { // todo } }}// 最后返回一个异步的谓词public static AsyncPredicate toAsyncPredicate(Predicate super ServerWebExchange> predicate) { Assert.notNull(predicate, "predicate must not be null"); // 这里from就是返回一个DefaultAsyncPredicate默认的异步谓词 return AsyncPredicate.from(predicate);}static AsyncPredicate from( Predicate super ServerWebExchange> predicate) { return new DefaultAsyncPredicate<>(GatewayPredicate.wrapIfNeeded(predicate));}
图6.2-1
图片
最后在combinePredicates方法中将当前路由中配置的所有谓词进行了and操作返回。最终回到convertToRoute方法中将当前路由中配置的谓词,过滤器进行了整合包装返回Route(一个路由对象)
public class Route implements Ordered { private final String id; private final URI uri; private final int order; private final AsyncPredicate predicate; private final List gatewayFilters; private final Map metadata;}
这些Route对象会被保存在上面说的CachingRouteLocator.routes中。
6.3 定位路由根据上面的配置RouteLocator 该类用来定位路由(查找具体的使用哪个路由);当一个请求过来会查找是哪个路由。
RouteLocator中定义了一个方法
public interface RouteLocator { Flux getRoutes();}
查看这个getRoutes方法是谁调用的
图片
看到这个RoutePredicateHandlerMapping是不是想起了Spring MVC中的HandlerMapping(我们所有的Controller都会被 RequestMappingHanlderMapping 匹配)。通过名称也就知道了该HandlerMapping用来匹配我们的路由谓词的谁来处理路由。
接下来回到前面说的RequestMappingHanlderMapping 对象,当我们请求一个路由地址时会执行该类中的lookup方法查找路由
protected Mono lookupRoute(ServerWebExchange exchange) { // 这里的this.routeLocator就是 CachingRouteLocator对象 return this.routeLocator.getRoutes() .concatMap(route -> Mono.just(route).filterWhen(r -> { exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId()); // 过滤查找符合的路由 return r.getPredicate().apply(exchange); }).doOnError(e -> logger.error( "Error applying predicate for route: " + route.getId(), e)).onErrorResume(e -> Mono.empty())) .next() .map(route -> { if (logger.isDebugEnabled()) { logger.debug("Route matched: " + route.getId()); } validateRoute(route, exchange); return route; });}
进入r.getPredicate().apply(exchange)
public interface AsyncPredicate extends Function> { static AsyncPredicate from(Predicate super ServerWebExchange> predicate) { return new DefaultAsyncPredicate<>(GatewayPredicate.wrapIfNeeded(predicate)); } class DefaultAsyncPredicate implements AsyncPredicate { private final Predicate delegate; public DefaultAsyncPredicate(Predicate delegate) { this.delegate = delegate; } @Override public Publisher apply(T t) { return Mono.just(delegate.test(t)); } @Override public String toString() { return this.delegate.toString(); } }}
这里会调用Predicate.test方法(XxxRoutePredicateFactory中的apply方法返回的GatewayPredicate)。
调用GatewayPredicate.test返回判断当前请求的路由是否匹配。
整体的一个流程:
1、系统先初始化所有的Predicate(谓词)和Filter(过滤器)
2、根据配置的路由信息(过滤器,谓词)包装返回Route对象
3、根据请求路由路径查找匹配的路由