spring cloud gateway 源码解析（2）动态路由

摘要：先看看是怎么获取我们配置的路由在启动时，帮我们注册了一系列这里注入所有，我们在配置文件里配置的路由就是通过子类来完成的，可以参考实现自己的的存储，会在后面转换成接着看类里的获取路由定义方法即轮训所有的市现率调用，这样就把所有整合到一起了接着

先看看gateway是怎么获取我们配置的路由：
在gateway启动时，GatewayAutoConfiguration帮我们注册了一系列beans

    @Bean
    @Primary
    public RouteDefinitionLocator routeDefinitionLocator(List routeDefinitionLocators) {
        //这里注入所有RouteDefinitionLocator，我们在配置文件里配置的路由就是通过子类PropertiesRouteDefinitionLocator来完成的，
        //可以参考InMemoryRouteDefinitionRepository实现自己的RouteDefinition的存储，RouteDefinition会在后面转换成Route
        return new CompositeRouteDefinitionLocator(Flux.fromIterable(routeDefinitionLocators));
    }

    //接着看CompositeRouteDefinitionLocator类里的获取路由定义方法：
    public Flux getRouteDefinitions() {
        //即轮训所有RouteDefinitionLocator的市现率调用getRouteDefinitions，这样就把所有RouteDefinition整合到一起了
        return this.delegates.flatMap(RouteDefinitionLocator::getRouteDefinitions);
    }
    
    //接着看GatewayAutoConfiguration，刚才的bean RouteDefinitionLocator 作为参数注入到routeDefinitionLocator
    @Bean
    public RouteLocator routeDefinitionRouteLocator(GatewayProperties properties,
                                                   List GatewayFilters,
                                                   List predicates,
                                                   RouteDefinitionLocator routeDefinitionLocator) {
        return new RouteDefinitionRouteLocator(routeDefinitionLocator, predicates, GatewayFilters, properties);
    }

 //看RouteDefinitionRouteLocator类：
public class RouteDefinitionRouteLocator implements RouteLocator, BeanFactoryAware, ApplicationEventPublisherAware {
    ······

    public RouteDefinitionRouteLocator(RouteDefinitionLocator routeDefinitionLocator,
                                       List predicates,
                                       List gatewayFilterFactories,
                                       GatewayProperties gatewayProperties) {
        this.routeDefinitionLocator = routeDefinitionLocator;
        //RoutePredicateFactory放到map里,去掉RoutePredicateFactory后缀，所以配置时就可以写成
        //predicates:
        //    - Path=/abc/*
        //的形式而不用写完整的PathRoutePredicateFactory    
        initFactories(predicates);
        //把bean名字里的GatewayFilterFactory去掉，所以我们配置文件里配置时也要把GatewayFilterFactory去掉，不然会找不到
        gatewayFilterFactories.forEach(factory -> this.gatewayFilterFactories.put(factory.name(), factory));
        this.gatewayProperties = gatewayProperties;
    }
    ······ 

    @Override
    public Flux getRoutes() {
        return this.routeDefinitionLocator.getRouteDefinitions()
                .map(this::convertToRoute)//获取所有的RouteDefinition后转为Route
                //TODO: error handling
                .map(route -> {
                    if (logger.isDebugEnabled()) {
                        logger.debug("RouteDefinition matched: " + route.getId());
                    }
                    return route;
                });
 
    }

    private Route convertToRoute(RouteDefinition routeDefinition) {
        //获取所有匹配规则，所有的规则都满足才走对应Route
        AsyncPredicate predicate = combinePredicates(routeDefinition);
        //获取全部过滤器
        List gatewayFilters = getFilters(routeDefinition);

        return Route.async(routeDefinition)
                .asyncPredicate(predicate)
                .replaceFilters(gatewayFilters)
                .build();
    }
 

    private List getFilters(RouteDefinition routeDefinition) {
        List filters = new ArrayList<>();

        //把全局过滤器添加到当前路由，loadGatewayFilters调用GatewayFilterFactory里的apply配置类里面的静态Config类，并且把没实现Ordered接口的类用OrderedGatewayFilter代理一下，方便下面排序
        if (!this.gatewayProperties.getDefaultFilters().isEmpty()) {
            filters.addAll(loadGatewayFilters("defaultFilters",
                    this.gatewayProperties.getDefaultFilters()));
        }
        //添加本条路由定义的过滤器
        if (!routeDefinition.getFilters().isEmpty()) {
            filters.addAll(loadGatewayFilters(routeDefinition.getId(), routeDefinition.getFilters()));
        }
        //排序
        AnnotationAwareOrderComparator.sort(filters);
        return filters;
    }

    private AsyncPredicate combinePredicates(RouteDefinition routeDefinition) { 
        //获取路由的判断条件，比如我们大多是根据url判断，用的是PathRoutePredicateFactory
        List predicates = routeDefinition.getPredicates();
        AsyncPredicate predicate = lookup(routeDefinition, predicates.get(0));

        for (PredicateDefinition andPredicate : predicates.subList(1, predicates.size())) {
            AsyncPredicate found = lookup(routeDefinition, andPredicate);
            predicate = predicate.and(found);//如果有多个匹配规则就要满足所有的才可以
        }
        //返回的结果会在RoutePredicateHandlerMapping类里使用apply方法调用 
        return predicate;
    }

    @SuppressWarnings("unchecked")
    private AsyncPredicate lookup(RouteDefinition route, PredicateDefinition predicate) {
        RoutePredicateFactory