gateway - 启动

我们从spring.factories开始，主要是GatewayAutoConfiguration，这里主要加载CompositeRouteDefinitionLocator、RouteDefinitionRouteLocator、FilteringWebHandler、RoutePredicateHandlerMapping、RouteRefreshListener、CachingRouteLocator等。
RouteLocator和RouteDefinitionLocator的作用在上一篇已经提过了，FilteringWebHandler、RoutePredicateHandlerMapping这两个等调用的时候讲，这边先知道他们会在这里加载。我们主要看看RouteRefreshListener和CachingRouteLocator。

RouteRefreshListener

RouteRefreshListener实现了ApplicationListener接口，所以他会调用onApplicationEvent方法，在符合某些条件下，会调用reset方法，这个思路和zuul是一样的。所以动态的刷新也可以调用他的事件来触发。

public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ContextRefreshedEvent
            || event instanceof RefreshScopeRefreshedEvent
            || event instanceof InstanceRegisteredEvent) {
        reset();
    }
    else if (event instanceof ParentHeartbeatEvent) {
        ParentHeartbeatEvent e = (ParentHeartbeatEvent) event;
        resetIfNeeded(e.getValue());
    }
    else if (event instanceof HeartbeatEvent) {
        HeartbeatEvent e = (HeartbeatEvent) event;
        resetIfNeeded(e.getValue());
    }
}

我们看看reset方法，他其实就是发布了一个RefreshRoutesEvent事件。

private void reset() {
    this.publisher.publishEvent(new RefreshRoutesEvent(this));
}

CachingRouteLocator

CachingRouteLocator就是用来接收RefreshRoutesEvent事件的，他实现了ApplicationListener接口。我们看看他的onApplicationEvent方法。

public void onApplicationEvent(RefreshRoutesEvent event) {
    try {
        fetch().collect(Collectors.toList()).subscribe(list -> Flux.fromIterable(list)
                .materialize().collect(Collectors.toList()).subscribe(signals -> {
                    applicationEventPublisher
                            .publishEvent(new RefreshRoutesResultEvent(this));
                    cache.put(CACHE_KEY, signals);
                }, throwable -> handleRefreshError(throwable)));
    }
    catch (Throwable e) {
        handleRefreshError(e);
    }
}

他先会调用fetch方法，这里实际上就是调用CompositeRouteLocator#getRoutes，最后再调用RouteDefinitionRouteLocator#getRoutes。

private Flux fetch() {
    return this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE);
}

RouteDefinitionRouteLocator#getRoutes

这个方法可以看到他是获取RouteDefinition的集合，然后再调用convertToRoute方法，在这个方法里，把RouteDefinition转为Route。

@Override
public Flux getRoutes() {
    Flux routes = this.routeDefinitionLocator.getRouteDefinitions()
            .map(this::convertToRoute);

    // 其他略
}

RouteDefinitionRouteLocator#convertToRoute

在这里把RouteDefinition转为Route，主要是解析Predicate和GatewayFilter，我们在上一篇已经知道了他会通过工厂类来处理。combinePredicates方法就是处理Predicate的，getFilters是处理Filter的。

private Route convertToRoute(RouteDefinition routeDefinition) {
    AsyncPredicate predicate = combinePredicates(routeDefinition);
    List gatewayFilters = getFilters(routeDefinition);

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

RouteDefinitionRouteLocator#combinePredicates

在这里就是把RouteDefinition的predicate转为Route需要的Predicate。这里首先会创建一个Predicate，然后再把剩余的合并，形成了一个left、right的结构。结构图在上一篇已经说过了。
lookup方法就是通过工厂类创建Predicate的地方。

private AsyncPredicate combinePredicates(
        RouteDefinition routeDefinition) {
    List predicates = routeDefinition.getPredicates();
    if (predicates == null || predicates.isEmpty()) {
        // this is a very rare case, but possible, just match all
        return AsyncPredicate.from(exchange -> true);
    }
    // 创建第一个Predicate
    AsyncPredicate predicate = lookup(routeDefinition,
            predicates.get(0));
    // 把剩余的进行合并
    for (PredicateDefinition andPredicate : predicates.subList(1,
            predicates.size())) {
        AsyncPredicate found = lookup(routeDefinition,
                andPredicate);
        predicate = predicate.and(found);
    }

    return predicate;
}

RouteDefinitionRouteLocator#lookup

这个方法里，首先先通过配置的名称，获取对应的RoutePredicateFactory，然后组装config信息，最后通过factory.applyAsync创建Predicate。

private AsyncPredicate lookup(RouteDefinition route,
        PredicateDefinition predicate) {
    RoutePredicateFactory