Spring Cloud Gateway 源码剖析之Route数据模型

简介: Spring Cloud Gateway 源码剖析之Route数据模型

一、前言

我们上一篇讲了:Spring Cloud Gateway 源码剖析之配置初始化,通过自动加载初始化六个配置实例,Spring Cloud Gateway 就完成自身的加载和初始化工作。我们知道 Gateway 的核心是路由加过滤,既然网关相关初始化工作做好了,那得开始路由相关的工作了。

接下来我们就来分析下平时在 properties 或者 yml 中配置的有关 Gateway 的配置是如何构建成 Route 的。

二、Route 构建方式

一般构建分为两种:外部化配置和编程方式

1、外部化配置

spring:  
        cloud: 
                gateway:    
                          routes:     
                          - id: after_route // ①    
                          uri: https://example.org // ②   
                          predicates:     
                          - Cookie=mycookie,mycookievalue // ③    
                          filters:        
                          - AddRequestHeader=X-Request-Foo, Bar // ④
  • ① 配置了一个 Route id 为 after_route
  • ② 客户端请求转发的目的地:https://example.org
  • ③ 在 request 中,当存在名字 mycookie 的 cookie 的值匹配 mycookievalue 则算成功
  • ④ 定义了一个 Filter,匹配成功后,会在请求头上添加 X-Request-Foo:Bar

2、编程方式

用上面的例子,转换成编程方式

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
   builder.routes()
        .route(r -> r.cookie("mycookie", "mycookievalue")
            .filters(f -> f.addRequestHeader("X-Request-Foo", "Bar"))
            .uri("https://example.org")
        )
        .build();
}

简单介绍了构建 Route 的两种方式,下面分析 Route 是如何把外部化配置与编码配置之间进行转换。

三、Route 构建原理

1、外部化配置

外部化配置是通过 GatewayProperties 进行构建的

/**
 * 网关配置信息加载
 * 从appliccation.yml中解析前缀为spring.cloud.gateway的配置
 */
@ConfigurationProperties("spring.cloud.gateway")
@Validated
public class GatewayProperties {
    private final Log logger = LogFactory.getLog(this.getClass());
    /**
     * 路由定义列表
     * 加载配置key=spring.cloud.gateway.routes 列表
     * List of Routes
     */
    @NotNull
    @Valid
    private List<RouteDefinition> routes = new ArrayList();
    /**
     * 默认的过滤器定义列表
     * 加载配置 key = spring.cloud.gateway.default-filters 列表
     * List of filter definitions that are applied to every route.
     */
    private List<FilterDefinition> defaultFilters = new ArrayList();
    /**
     * 网媒体类型列表
     * 加载配置 key = spring.cloud.gateway.streamingMediaTypes 列表
     * 默认包含{text/event-stream,application/stream+json}
     */
    private List<MediaType> streamingMediaTypes;
    public GatewayProperties() {
        this.streamingMediaTypes = Arrays.asList(MediaType.TEXT_EVENT_STREAM, MediaType.APPLICATION_STREAM_JSON);
    }
    ...
}

1.1 RouteDefinition

用来对 Route 进行定义。也就是,通过 GatewayProperties 会与外部化配置进行绑定,把外部化配置比如 properties 或者 yml 绑定到 GatewayProperties 中。

/**
 * 路由定义实体信息,包含路由的定义信息
 */
@Validated
public class RouteDefinition {
    /**
     * 路由ID 编号,唯一
     */
    @NotEmpty
    private String id = UUID.randomUUID().toString();
    /**
     * 谓语定义数组
     * predicates 属性,谓语定义数组
     * 请求通过   判断是否匹配。在 Route 里,PredicateDefinition 转换成 Predicate
     */
    @NotEmpty
    @Valid
    private List<PredicateDefinition> predicates = new ArrayList();
    /**
     * 过滤器定义数组
     * filters 属性,过滤器定义数组。
     * 在 Route 里,FilterDefinition 转换成 GatewayFilter
     */
    @Valid
    private List<FilterDefinition> filters = new ArrayList();
    /**
     * 路由指向的URI
     */
    @NotNull
    private URI uri;
    /**
     * 顺序
     */
    private int order = 0;
    ...
}

1.2 PredicateDefinition

/**
 * 谓语定义,在 Route 里,PredicateDefinition 将转换成 Predicate
 */
@Validated
public class PredicateDefinition {
    /**
     * 谓语定义名字
     * 通过 name 对应到 org.springframework.cloud.gateway.handler.predicate.RoutePredicateFactory 的实现类。
     * 例如: name=Query 对应到 QueryRoutePredicateFactory
     */
    @NotNull
    private String name;
    /**
     * 参数数组
     * 例如,name=Host / args={"_genkey_0" : "iocoder.cn"} ,匹配请求的 hostname 为 iocoder.cn
     */
    private Map<String, String> args = new LinkedHashMap();
    ...
}

1.3 FilterDefinition

/**
 * 过滤器定义,在 Route 里,FilterDefinition将转换成 GatewayFilter
 */
@Validated
public class FilterDefinition {
    /**
     * 过滤器定义名字
     * 通过 name 对应到 org.springframework.cloud.gateway.filter.factory.GatewayFilterFactory 的实现类。
     * 例如,name=AddRequestParameter 对应到 AddRequestParameterGatewayFilterFactory
     */
    @NotNull
    private String name;
    /**
     * 参数数组
     * 例如 name=AddRequestParameter / args={"_genkey_0": "foo", "_genkey_1": "bar"} ,添加请求参数 foo 为 bar
     */
    private Map<String, String> args = new LinkedHashMap();
    ...
}

1.4 RouteDefinitionLocator

在上一篇文章 Spring Cloud Gateway 源码剖析之配置初始化 中的 GatewayAutoConfiguration 核心配置类中,有提到此类。

@Bean
@Primary
public RouteDefinitionLocator routeDefinitionLocator(List<RouteDefinitionLocator> routeDefinitionLocators) {
    return new CompositeRouteDefinitionLocator(Flux.fromIterable(routeDefinitionLocators));
}

Gateway 提供多种方式来获取外部的配置,而 RouteDefinitionLocator 就是父接口,下面有多种实现。

在这里插入图片描述

1.4.1 PropertiesRouteDefinitionLocator

从配置文件(YML、Properties 等) 读取路由配置。代码如下:

public class PropertiesRouteDefinitionLocator implements RouteDefinitionLocator {
    private final GatewayProperties properties;
    public PropertiesRouteDefinitionLocator(GatewayProperties properties) {
        this.properties = properties;
    }
    public Flux<RouteDefinition> getRouteDefinitions() {
        // 从 GatewayProperties 获取路由配置数组。
        return Flux.fromIterable(this.properties.getRoutes());
    }
}

1.4.2 InMemoryRouteDefinitionRepository

从存储器(内存、Redis、MySQL 等)读取、保存、删除路由配置。InMemoryRouteDefinitionRepository 是基于内存的。

public class InMemoryRouteDefinitionRepository implements RouteDefinitionRepository {
    /**
        * 路由配置映射 通过此来保存route
     * key :路由编号 {@link RouteDefinition#id}
     */
    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();
        });
    }
    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());
    }
}

基于内存,通过 Map routes 来保存 Route,缺点是如果重启,那么 route 会丢失。可以实现 RouteDefinitionRepository 接口自定义比如通过 Redis、Mysql 等来保存 Route。

1.4.3 DiscoveryClientRouteDefinitionLocator

获取在注册中心的服务列表,生成对应的 RouteDefinition 数组。

public class DiscoveryClientRouteDefinitionLocator implements RouteDefinitionLocator {
    private static final Log log = LogFactory.getLog(DiscoveryClientRouteDefinitionLocator.class);
    private final DiscoveryClient discoveryClient;
    private final DiscoveryLocatorProperties properties;
    private final String routeIdPrefix;
    private final SimpleEvaluationContext evalCtxt;
    public DiscoveryClientRouteDefinitionLocator(DiscoveryClient discoveryClient, DiscoveryLocatorProperties properties) {
        this.discoveryClient = discoveryClient;
        this.properties = properties;
        if (StringUtils.hasText(properties.getRouteIdPrefix())) {
            this.routeIdPrefix = properties.getRouteIdPrefix();
        } else {
            this.routeIdPrefix = this.discoveryClient.getClass().getSimpleName() + "_";
        }
        this.evalCtxt = SimpleEvaluationContext.forReadOnlyDataBinding().withInstanceMethods().build();
    }
    public Flux<RouteDefinition> getRouteDefinitions() {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression includeExpr = parser.parseExpression(this.properties.getIncludeExpression());
        Expression urlExpr = parser.parseExpression(this.properties.getUrlExpression());
        Predicate includePredicate;
        if (this.properties.getIncludeExpression() != null && !"true".equalsIgnoreCase(this.properties.getIncludeExpression())) {
            includePredicate = (instance) -> {
                Boolean include = (Boolean)includeExpr.getValue(this.evalCtxt, instance, Boolean.class);
                return include == null ? false : include;
            };
        } else {
            includePredicate = (instance) -> {
                return true;
            };
        }
        // 获取discoveryClient,然后发起请求
        Flux var10000 = Flux.fromIterable(this.discoveryClient.getServices());
        DiscoveryClient var10001 = this.discoveryClient;
        var10001.getClass();
        return var10000.map(var10001::getInstances).filter((instances) -> {
            return !instances.isEmpty();
        }).map((instances) -> {
            return (ServiceInstance)instances.get(0);
        }).filter(includePredicate).map((instance) -> {
            String serviceId = instance.getServiceId();
            RouteDefinition routeDefinition = new RouteDefinition();
            // 设置 ID
            routeDefinition.setId(this.routeIdPrefix + serviceId);
            // 设置 uri
            String uri = (String)urlExpr.getValue(this.evalCtxt, instance, String.class);
            routeDefinition.setUri(URI.create(uri));
            ServiceInstance instanceForEval = new DiscoveryClientRouteDefinitionLocator.DelegatingServiceInstance(instance, this.properties);
            Iterator var8 = this.properties.getPredicates().iterator();
            Iterator var11;
            Entry entry;
            String value;
            while(var8.hasNext()) {
                PredicateDefinition originalx = (PredicateDefinition)var8.next();
                // 添加 path 断言
                PredicateDefinition predicate = new PredicateDefinition();
                predicate.setName(originalx.getName());
                var11 = originalx.getArgs().entrySet().iterator();
                while(var11.hasNext()) {
                    entry = (Entry)var11.next();
                    value = this.getValueFromExpr(this.evalCtxt, parser, instanceForEval, entry);
                    predicate.addArg((String)entry.getKey(), value);
                }
                routeDefinition.getPredicates().add(predicate);
            }
            var8 = this.properties.getFilters().iterator();
            while(var8.hasNext()) {
                FilterDefinition original = (FilterDefinition)var8.next();
                // 添加path 重写过滤器
                FilterDefinition filter = new FilterDefinition();
                filter.setName(original.getName());
                var11 = original.getArgs().entrySet().iterator();
                while(var11.hasNext()) {
                    entry = (Entry)var11.next();
                    value = this.getValueFromExpr(this.evalCtxt, parser, instanceForEval, entry);
                    filter.addArg((String)entry.getKey(), value);
                }
                routeDefinition.getFilters().add(filter);
            }
            return routeDefinition;
        });
    }
    ...
}

可以在官方的 GatewaySampleApplication 添加 Eureka 注册中心自行调试:

// 开启Eureka
@EnableDiscoveryClient 
public class GatewaySampleApplication {
    // ... 省略其他代码
    @Bean
    public RouteDefinitionLocator discoveryClientRouteDefinitionLocator(DiscoveryClient discoveryClient) {
        return new DiscoveryClientRouteDefinitionLocator(discoveryClient);
    }
}

当然要自己加入 Eureka 依赖以及配置文件

1.4.4 CachingRouteDefinitionLocator

public class CachingRouteDefinitionLocator implements RouteDefinitionLocator, ApplicationListener<RefreshRoutesEvent> {
    private final RouteDefinitionLocator delegate;
    private final Flux<RouteDefinition> routeDefinitions;
    // 收集Route
    private final Map<String, List> cache = new HashMap();
    public CachingRouteDefinitionLocator(RouteDefinitionLocator delegate) {
        this.delegate = delegate;
        FluxCacheBuilderMapMiss var10001 = CacheFlux.lookup(this.cache, "routeDefs", RouteDefinition.class);
        RouteDefinitionLocator var10002 = this.delegate;
        var10002.getClass();
        this.routeDefinitions = var10001.onCacheMissResume(var10002::getRouteDefinitions);
    }
    public Flux<RouteDefinition> getRouteDefinitions() {
        return this.routeDefinitions;
    }
    public Flux<RouteDefinition> refresh() {
        this.cache.clear();
        return this.routeDefinitions;
    }
    public void onApplicationEvent(RefreshRoutesEvent event) {
        this.refresh();
    }
    /** @deprecated */
    @Deprecated
    void handleRefresh() {
        this.refresh();
    }
}

1.4.5 CompositeRouteDefinitionLocator

组合多种 RouteDefinitionLocator 的实现,为 RouteDefinitionRouteLocator 提供统一入口。

public class CompositeRouteDefinitionLocator implements RouteDefinitionLocator {
    // RouteDefinitionLocator 数组
    private final Flux<RouteDefinitionLocator> delegates;
    public CompositeRouteDefinitionLocator(Flux<RouteDefinitionLocator> delegates) {
        this.delegates = delegates;
    }
    // 将组合的 delegates 的路由定义全部返回。
    public Flux<RouteDefinition> getRouteDefinitions() {
        return this.delegates.flatMap(RouteDefinitionLocator::getRouteDefinitions);
    }
}

到此为止外部化的配置的多种方式全部解析完毕。接下来我们来看下编程方式。

2、编程方式

// org.springframework.cloud.gateway.sample.GatewaySampleApplication
@SpringBootConfiguration
@EnableAutoConfiguration
@Import(AdditionalRoutesImportSelector.class)
public class GatewaySampleApplication {
    public static final String HELLO_FROM_FAKE_ACTUATOR_METRICS_GATEWAY_REQUESTS = "hello from fake /actuator/metrics/gateway.requests";
    @Value("${test.uri:http://httpbin.org:80}")
    String uri;
    public static void main(String[] args) {
        SpringApplication.run(GatewaySampleApplication.class, args);
    }
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        // @formatter:off
        // String uri = "http://httpbin.org:80";
        // String uri = "http://localhost:9080";
        // ① RouteLocatorBuilder 可以构建多个路由信息。
        return builder.routes()
                // ② 指定了 Predicates,这里包含两个:
                // 请求头Host需要匹配**.abc.org,通过 HostRoutePredicateFactory 产生。
                // 请求路径需要匹配/anything/png,通过 PathRoutePredicateFactory 产生。
                .route(r -> r.host("**.abc.org").and().path("/anything/png")
                    // ③ 指定了一个 Filter,下游服务响应后添加响应头X-TestHeader:foobar,
                    // 通过 AddResponseHeaderGatewayFilterFactory 产生。
                    .filters(f ->
                            f.prefixPath("/httpbin")
                                    .addResponseHeader("X-TestHeader", "foobar"))
                     // ④ 指定路由转发的目的地 uri。
                    .uri(uri)
                )
                .route("read_body_pred", r -> r.host("*.readbody.org")
                        .and().readBody(String.class,
                                        s -> s.trim().equalsIgnoreCase("hi"))
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "read_body_pred")
                    ).uri(uri)
                )
                .route("rewrite_request_obj", r -> r.host("*.rewriterequestobj.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_request")
                            .modifyRequestBody(String.class, Hello.class, MediaType.APPLICATION_JSON_VALUE,
                                    (exchange, s) -> {
                                        return Mono.just(new Hello(s.toUpperCase()));
                                    })
                    ).uri(uri)
                )
                .route("rewrite_request_upper", r -> r.host("*.rewriterequestupper.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_request_upper")
                            .modifyRequestBody(String.class, String.class,
                                    (exchange, s) -> {
                                        return Mono.just(s.toUpperCase() + s.toUpperCase());
                                    })
                    ).uri(uri)
                )
                .route("rewrite_response_upper", r -> r.host("*.rewriteresponseupper.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_response_upper")
                            .modifyResponseBody(String.class, String.class,
                                    (exchange, s) -> {
                                        return Mono.just(s.toUpperCase());
                                    })
                    ).uri(uri)
                )
                .route("rewrite_empty_response", r -> r.host("*.rewriteemptyresponse.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_empty_response")
                            .modifyResponseBody(String.class, String.class,
                                    (exchange, s) -> {
                                        if (s == null) {
                                            return Mono.just("emptybody");
                                        }
                                        return Mono.just(s.toUpperCase());
                                    })
                    ).uri(uri)
                )
                .route("rewrite_response_fail_supplier", r -> r.host("*.rewriteresponsewithfailsupplier.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_response_fail_supplier")
                            .modifyResponseBody(String.class, String.class,
                                    (exchange, s) -> {
                                        if (s == null) {
                                            return Mono.error(new IllegalArgumentException("this should not happen"));
                                        }
                                        return Mono.just(s.toUpperCase());
                                    })
                    ).uri(uri)
                )
                .route("rewrite_response_obj", r -> r.host("*.rewriteresponseobj.org")
                    .filters(f -> f.prefixPath("/httpbin")
                            .addResponseHeader("X-TestHeader", "rewrite_response_obj")
                            .modifyResponseBody(Map.class, String.class, MediaType.TEXT_PLAIN_VALUE,
                                    (exchange, map) -> {
                                        Object data = map.get("data");
                                        return Mono.just(data.toString());
                                    })
                            .setResponseHeader("Content-Type", MediaType.TEXT_PLAIN_VALUE)
                    ).uri(uri)
                )
                .route(r -> r.path("/image/webp")
                    .filters(f ->
                            f.prefixPath("/httpbin")
                                    .addResponseHeader("X-AnotherHeader", "baz"))
                    .uri(uri)
                )
                .route(r -> r.order(-1)
                    .host("**.throttle.org").and().path("/get")
                    .filters(f -> f.prefixPath("/httpbin")
                                    .filter(new ThrottleGatewayFilter()
                                    .setCapacity(1)
                                    .setRefillTokens(1)
                                    .setRefillPeriod(10)
                                    .setRefillUnit(TimeUnit.SECONDS)))
                    .uri(uri)
                )
                // ⑤ 创建RouteLocator实例
                .build();
        // @formatter:on
    }
    @Bean
    public RouterFunction<ServerResponse> testFunRouterFunction() {
        RouterFunction<ServerResponse> route = RouterFunctions.route(RequestPredicates.path("/testfun"),
                request -> ServerResponse.ok().body(BodyInserters.fromValue("hello")));
        return route;
    }
    @Bean
    public RouterFunction<ServerResponse> testWhenMetricPathIsNotMeet() {
        RouterFunction<ServerResponse> route = RouterFunctions
                .route(RequestPredicates.path("/actuator/metrics/gateway.requests"), request -> ServerResponse.ok()
                        .body(BodyInserters.fromValue(HELLO_FROM_FAKE_ACTUATOR_METRICS_GATEWAY_REQUESTS)));
        return route;
    }
    static class Hello {
        String message;
        Hello() {
        }
        Hello(String message) {
            this.message = message;
        }
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
    }
}


  • ① 使用 Builder 模式构建 Route
  • ② 创建 Predicates
  • ③ 创建 Filter
  • ④ 需要转发的目的地 uri
  • ⑤ 创建 RouteLocator 实例

// org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder.Builder#build
public RouteLocator build() {
    return () -> {
        return Flux.fromIterable(this.routes).map((routeBuilder) -> {
            return routeBuilder.build(); // ①
        });
    };
}
// RouteLocator 是 Route 集合
public interface RouteLocator {
    Flux<Route> getRoutes();
}

上面 build 方法返回的是 RouteLocator 对象,它是 Route 的集合所以上面 ① 中的 build 方法就是对应的 Route。

public Route build() {
    Assert.notNull(this.id, "id can not be null");
    Assert.notNull(this.uri, "uri can not be null");
    AsyncPredicate<ServerWebExchange> predicate = this.getPredicate();
    Assert.notNull(predicate, "predicate can not be null");
    return new Route(this.id, this.uri, this.order, predicate, this.gatewayFilters);
}

下面这个就是我们最重要的 Route 数据模型了,我们来看下是如何设计的吧。

public class Route implements Ordered {
    // id,标识符,区别于其他 Route。
    private final String id;
    // destination uri,路由指向的目的地 uri,即客户端请求最终被转发的目的地。
    private final URI uri;
    // order,用于多个 Route 之间的排序,数值越小排序越靠前,匹配优先级越高。
    private final int order;
    // predicate,谓语,表示匹配该 Route 的前置条件,即满足相应的条件才会被路由到目的地 uri。
    private final AsyncPredicate<ServerWebExchange> predicate;
    // gateway filters,过滤器用于处理切面逻辑,如路由转发前修改请求头等。
    private final List<GatewayFilter> gatewayFilters;
    ...
}

到这里,外部化配置的 Route、Predicate、Filter 会被映射成 RouteDefinition、FilterDefinition、PredicateDefinition,而编码方式会被映射成 Route、AsyncPredicate 、GatewayFilter。

有时候我们可能又有外部化配置又有编码方式的配置,那么这时候就需要有一个转换。那接下来就看一下 Gateway 是如何转换的。

四、RouteDefinitionRouteLocator

这里将 RouteDefinitionRouteLocator 单独作为一小节来说,RouteDefinitionRouteLocator 将外部化配置的 RouteDefinition、FilterDefinition、PredicateDefinition 转换成 Route、AsyncPredicate、GatewayFilter。

上一篇我们讲到的核心配置类 GatewayAutoConfiguration,给我提供了分析的入口,代码如下:

// ① GatewayProperties 
// ② RouteDefinitionLocator 
@Bean
public RouteLocator routeDefinitionRouteLocator(GatewayProperties properties, List<GatewayFilterFactory> GatewayFilters, List<RoutePredicateFactory> predicates, RouteDefinitionLocator routeDefinitionLocator, @Qualifier("webFluxConversionService") ConversionService conversionService) {
    // ③ 这里进行转换
    return new RouteDefinitionRouteLocator(routeDefinitionLocator, predicates, GatewayFilters, properties, conversionService);
}

1、①、② 在上面外部化配置讲过,这里就不重复阐述了。

2、③ 外部化配置进行转换,RouteDefinitionRouteLocator 是 RouteLocator 的实现

public class RouteDefinitionRouteLocator implements RouteLocator, BeanFactoryAware, ApplicationEventPublisherAware {
    protected final Log logger = LogFactory.getLog(this.getClass());
    public static final String DEFAULT_FILTERS = "defaultFilters";
    // RouteDefinition Locator,一个 RouteDefinitionLocator 对象。
    private final RouteDefinitionLocator routeDefinitionLocator;
    private final ConversionService conversionService;
    /**
        * predicates factories,Predicate 工厂列表,会被映射成 key 为 name, value 为 factory 的 Map。
     * 可以猜想出 gateway 是如何根据 PredicateDefinition 中定义的 name 来匹配到相对应的 factory 了。
     * key :{@link RoutePredicateFactory#name()}
     */
    private final Map<String, RoutePredicateFactory> predicates = new LinkedHashMap();
    /**
     * filter factories,Gateway Filter 工厂列表,同样会被映射成 key 为 name, value 为 factory 的 Map。
       * key :{@link GatewayFilterFactory#name()}
        */
    private final Map<String, GatewayFilterFactory> gatewayFilterFactories = new HashMap();
    // gateway properties,外部化配置类。
    private final GatewayProperties gatewayProperties;
    private final SpelExpressionParser parser = new SpelExpressionParser();
    private BeanFactory beanFactory;
    private ApplicationEventPublisher publisher;
    @Autowired
    private Validator validator;
    public RouteDefinitionRouteLocator(RouteDefinitionLocator routeDefinitionLocator, List<RoutePredicateFactory> predicates, List<GatewayFilterFactory> gatewayFilterFactories, GatewayProperties gatewayProperties, ConversionService conversionService) {
        // 设置 RouteDefinitionLocator
        this.routeDefinitionLocator = routeDefinitionLocator;
        this.conversionService = conversionService;
        // ① 初始化 RoutePredicateFactory
        this.initFactories(predicates);
        // ② 初始化 gatewayFilterFactories
        gatewayFilterFactories.forEach((factory) -> {
            GatewayFilterFactory var10000 = (GatewayFilterFactory)this.gatewayFilterFactories.put(factory.name(), factory);
        });
        // 设置 GatewayProperties
        this.gatewayProperties = gatewayProperties;
    }
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }
    // ③ 实现 RouteLocator 的 getRoutes() 方法 获取 route
    public Flux<Route> getRoutes() {
        // 调用 convertToRoute 方法将 RouteDefinition 转换成 Route。
        return this.routeDefinitionLocator.getRouteDefinitions().map(this::convertToRoute).map((route) -> {
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("RouteDefinition matched: " + route.getId());
            }
            return route;
        });
    }
    ...
}

2.1 ① 初始化 RoutePredicateFactory

private void initFactories(List<RoutePredicateFactory> 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);
        if (this.logger.isInfoEnabled()) {
            this.logger.info("Loaded RoutePredicateFactory [" + key + "]");
        }
    });
}

2.2 ② 初始化 gatewayFilterFactories

// FilterDefinition 转换成 GatewayFilter
private List<GatewayFilter> getFilters(RouteDefinition routeDefinition) {
    List<GatewayFilter> filters = new ArrayList();
    // ① 处理 GatewayProperties 中定义的默认的 FilterDefinition,转换成 GatewayFilter。
    if (!this.gatewayProperties.getDefaultFilters().isEmpty()) {
        filters.addAll(this.loadGatewayFilters("defaultFilters", this.gatewayProperties.getDefaultFilters()));
    }
    // ② 将 RouteDefinition 中定义的 FilterDefinition 转换成 GatewayFilter。
    if (!routeDefinition.getFilters().isEmpty()) {
        filters.addAll(this.loadGatewayFilters(routeDefinition.getId(), routeDefinition.getFilters()));
    }
    // ③ 对 GatewayFilter 进行排序,排序的详细逻辑请查阅 spring 中的 Ordered 接口。
    AnnotationAwareOrderComparator.sort(filters);
    return filters;
}

2.3 ③ 实现 RouteLocator 的 getRoutes() 方法 获取 Route,真正转换的方法

public Flux<Route> getRoutes() {
    // 调用 convertToRoute 方法将 RouteDefinition 转换成 Route。
    return this.routeDefinitionLocator.getRouteDefinitions().map(this::convertToRoute).map((route) -> {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("RouteDefinition matched: " + route.getId());
        }
        return route;
    });
}
private Route convertToRoute(RouteDefinition routeDefinition) {
    // 2.3.1 将 PredicateDefinition 转换成 AsyncPredicate。
    AsyncPredicate<ServerWebExchange> predicate = this.combinePredicates(routeDefinition);
    // 2.3.2 将 FilterDefinition 转换成 GatewayFilter。
    List<GatewayFilter> gatewayFilters = this.getFilters(routeDefinition);
    // 2.3.3 根据 1 和 2 两步骤定义的变量生成 Route 对象。
    return ((AsyncBuilder)Route.async(routeDefinition).asyncPredicate(predicate).replaceFilters(gatewayFilters)).build();
}

2.3.1 将 PredicateDefinition 转换成 AsyncPredicate

private AsyncPredicate<ServerWebExchange> combinePredicates(RouteDefinition routeDefinition) {
    List<PredicateDefinition> predicates = routeDefinition.getPredicates();
    // ① 调用 lookup 方法,将列表中第一个 PredicateDefinition 转换成 AsyncPredicate。
    AsyncPredicate<ServerWebExchange> predicate = this.lookup(routeDefinition, (PredicateDefinition)predicates.get(0));
    AsyncPredicate found;
    // ② 循环调用,将列表中每一个 PredicateDefinition 都转换成 AsyncPredicate。
    // ③ 应用and操作,将所有的 AsyncPredicate 组合成一个 AsyncPredicate 对象。
    for(Iterator var4 = predicates.subList(1, predicates.size()).iterator(); var4.hasNext(); predicate = predicate.and(found)) {
        PredicateDefinition andPredicate = (PredicateDefinition)var4.next();
        found = this.lookup(routeDefinition, andPredicate);
    }
    return predicate;
}

2.3.2 将 FilterDefinition 转换成 GatewayFilter

// FilterDefinition 转换成 GatewayFilter
private List<GatewayFilter> getFilters(RouteDefinition routeDefinition) {
    List<GatewayFilter> filters = new ArrayList();
    // ① 处理 GatewayProperties 中定义的默认的 FilterDefinition,转换成 GatewayFilter。
    if (!this.gatewayProperties.getDefaultFilters().isEmpty()) {
        filters.addAll(this.loadGatewayFilters("defaultFilters", this.gatewayProperties.getDefaultFilters()));
    }
    // ② 将 RouteDefinition 中定义的 FilterDefinition 转换成 GatewayFilter。
    if (!routeDefinition.getFilters().isEmpty()) {
        filters.addAll(this.loadGatewayFilters(routeDefinition.getId(), routeDefinition.getFilters()));
    }
    // ③ 对 GatewayFilter 进行排序,排序的详细逻辑请查阅 spring 中的 Ordered 接口。
    AnnotationAwareOrderComparator.sort(filters);
    return filters;
}

2.3.3 根据 2.3.1 和 2.3.2 两步骤定义的变量生成 Route 对象

public Route build() {
    Assert.notNull(this.id, "id can not be null");
    Assert.notNull(this.uri, "uri can not be null");
    AsyncPredicate<ServerWebExchange> predicate = this.getPredicate();
    Assert.notNull(predicate, "predicate can not be null");
    return new Route(this.id, this.uri, this.order, predicate, this.gatewayFilters);
}

到这里我们就已经知道外部化配置配合是如何转换的,那么现在 Route 已经组装完毕了,现在就是看一下 Route 里面的 Predicate 和 Filter 的实现。

五、总结

  • Route 构建方式有两种方式:外部化配置和编程方式。
  • 通过 RouteDefinitionLocator 的各种实现,来多样化的获取不同的外置配置。
  • 既有外部化配置又有编码方式的配置,那么这时候就需要有一个转换根据 RouteDefinitionRouteLocator 把这些外置配置转存成 Route。




欢迎大家关注我的公众号【老周聊架构】,Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。


喜欢的话,点赞、再看、分享三连。

相关文章
|
27天前
|
缓存 Java 开发工具
Spring是如何解决循环依赖的?从底层源码入手,详细解读Spring框架的三级缓存
三级缓存是Spring框架里,一个经典的技术点,它很好地解决了循环依赖的问题,也是很多面试中会被问到的问题,本文从源码入手,详细剖析Spring三级缓存的来龙去脉。
Spring是如何解决循环依赖的?从底层源码入手,详细解读Spring框架的三级缓存
|
27天前
|
缓存 安全 Java
Spring框架中Bean是如何加载的?从底层源码入手,详细解读Bean的创建流程
从底层源码入手,通过代码示例,追踪AnnotationConfigApplicationContext加载配置类、启动Spring容器的整个流程,并对IOC、BeanDefinition、PostProcesser等相关概念进行解释
Spring框架中Bean是如何加载的?从底层源码入手,详细解读Bean的创建流程
|
27天前
|
XML 缓存 Java
手写Spring源码(简化版)
Spring包下的类、手写@ComponentScan注解、@Component注解、@Autowired注解、@Scope注解、手写BeanDefinition、BeanNameAware、InitializingBean、BeanPostProcessor 、手写AnnotationConfigApplicationContext
手写Spring源码(简化版)
|
5天前
|
Java Spring 容器
Spring IOC、AOP与事务管理底层原理及源码解析
Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
38 9
|
2天前
|
存储 开发框架 Java
什么是Spring?什么是IOC?什么是DI?IOC和DI的关系? —— 零基础可无压力学习,带源码
文章详细介绍了Spring、IOC、DI的概念和关系,解释了控制反转(IOC)和依赖注入(DI)的原理,并提供了IOC的代码示例,阐述了Spring框架作为IOC容器的应用。
5 0
什么是Spring?什么是IOC?什么是DI?IOC和DI的关系? —— 零基础可无压力学习,带源码
|
28天前
|
负载均衡 Java Nacos
SpringCloud基础2——Nacos配置、Feign、Gateway
nacos配置管理、Feign远程调用、Gateway服务网关
SpringCloud基础2——Nacos配置、Feign、Gateway
|
12天前
|
缓存 Java Spring
手写Spring Ioc 循环依赖底层源码剖析
在Spring框架中,IoC(控制反转)是一个核心特性,它通过依赖注入(DI)实现了对象间的解耦。然而,在实际开发中,循环依赖是一个常见的问题。
24 4
|
17天前
|
XML 缓存 Java
spring源码剖析-spring-beans(内部核心组件,BeanDefinition的注册,BeanWapper创建)
spring源码剖析-spring-beans(内部核心组件,BeanDefinition的注册,BeanWapper创建)
44 10
|
13天前
|
Java 开发者 Spring
Spring Cloud Gateway 中,过滤器的分类有哪些?
Spring Cloud Gateway 中,过滤器的分类有哪些?
19 3
|
15天前
|
负载均衡 Java 网络架构
实现微服务网关:Zuul与Spring Cloud Gateway的比较分析
实现微服务网关:Zuul与Spring Cloud Gateway的比较分析
27 5