Gateway基础

描述/介绍

Gateway基于WebFlux响应式编程,用于网络请求的转发，可使用定义好的拦截器或自定义拦截器进行请求的过滤。
网关的过滤不会影响接口原有功能。

WebFlux:

Spring WebFlux是Spring Framework 5.0中引入的新的反应式Web框架。 与Spring MVC不同，它不需要Servlet API，完全异步和非阻塞， 并通过Reactor项目实现Reactive Streams规范。 并且可以在诸如Netty，Undertow和Servlet 3.1+容器的服务器上运行。
Flux 和 Mono 是 Reactor 中的两个基本概念。Flux 表示的是包含 0 到 N 个元素的异步序列。 在该序列中可以包含三种不同类型的消息通知：正常的包含元素的消息、序列结束的消息和序列出错的消息。 当消息通知产生时，订阅者中对应的方法 onNext(), onComplete()和 onError()会被调用。Mono 表示的是包含 0 或者 1 个元素的异步序列。 该序列中同样可以包含与 Flux 相同的三种类型的消息通知。Flux 和 Mono 之间可以进行转换。 对一个 Flux 序列进行计数操作，得到的结果是一个 Mono对象。把两个 Mono 序列合并在一起，得到的是一个 Flux 对象。

与Zuul的对比

• Gateway建立于Spring Framework 5，Project Reactor和Spring Boot 2之上使用的是非阻塞API，支持WebSocket长连接；
  Zuul基于Servlet2.5（使用3.x）使用的是阻塞API，不支持任何长连接。
• 低并发情况下，Gateway与Zuul性能差距不会很大，但是在高并发的情况下，Gateway的吞吐量高于Zuul；
• Gateway是Spring开源的；Zuul是Netflix开源的

关键词

• Route：路由，转发的入口，只有路由匹配成功，网关才能进行请求的转发。
• Predicate：谓词，客户端请求的匹配规则，可多个组合，形成匹配逻辑，常用的有：Path（地址路径匹配）、Between（在某个时间段内）等。
• Filter：拦截器，可以修改发送的请求和返回的响应，可自定义。

Predicate 和 Filter 组成完整的路由信息。

工作流程

• 客户端发送请求到网关（Gateway）；
• 根据请求匹配路由（Route），匹配路由是根据谓词（Predicate）进行匹配的，Predicate可以是一个或多个，使用And方式组合；
• 根据网关定义的拦截器（Filter）进行相关拦截，拦截可在发送具体请求到Web服务器前后（修改发送的请求和返回的响应结果），同时亦可自定义拦截器进行某些特殊的处理，如：统计、黑白名单校验、限次等等；

应用场景

• Gateway 使用在并发要求相对较高或者需要支持长连接的场景下。
  • 异步，提高吞吐量
  • 支持长连接

源码解析-Route初始化

• GatewayAutoConfiguration 实现自动装配

public class GatewayAutoConfiguration {
    /**
     * 创建一个根据RouteDefinition转换的路由定位器
     */
    @Bean
    public RouteLocator routeDefinitionRouteLocator(GatewayProperties properties,
                                                   List<GatewayFilterFactory> GatewayFilters,
                                                   List<RoutePredicateFactory> predicates,
                                                   RouteDefinitionLocator routeDefinitionLocator) {
        return new RouteDefinitionRouteLocator(routeDefinitionLocator, predicates, GatewayFilters, properties);
    }

    /**
     * 创建一个缓存路由的路由定位器
     * @param routeLocators
     * @return
     */
    @Bean
    @Primary//意思是在众多相同的bean中，优先使用用@Primary注解的bean.
    //TODO: property to disable composite?
    public RouteLocator cachedCompositeRouteLocator(List<RouteLocator> routeLocators) {
        //1.创建组合路由定位器，根据(容器)已有的路由定位器集合
        //2.创建缓存功能的路由定位器
        return new CachingRouteLocator(new CompositeRouteLocator(Flux.fromIterable(routeLocators)));
    }
}

• RouteDefinitionLocator 负责读取路由配置
  • PropertiesRouteDefinitionLocator ，从配置文件( 例如，YML / Properties 等 ) 读取。
  • RouteDefinitionRepository 从存储器( 例如，内存 / Redis / MySQL 等 )读取。
  • DiscoveryClientRouteDefinitionLocator ，从注册中心( 例如，Eureka / Consul / Zookeeper / Etcd 等 )读取。
  • CompositeRouteDefinitionLocator ，组合多种 RouteDefinitionLocator 的实现，为 RouteDefinitionRouteLocator 提供统一入口（整合PropertiesRouteDefinitionLocator 、RouteDefinitionRepository 、DiscoveryClientRouteDefinitionLocator 等读取到的路由信息）。
  • CachingRouteLocator 从内存中读取。

从初始化配置类中可以路由定位器的创建流程

• RouteDefinitionRouteLocator
• CompositeRouteLocator
• CachingRouteLocator

其中 RouteDefinitionRouteLocator 是获取路由的主要地方，CompositeRouteLocator，CachingRouteLocator对路由定位器做了附加功能的包装，最终使用的是CachingRouteLocator对外提供服务

RouteLocator 接口源码:有且只有一个获取路由的方法，专门用来获取路由

/**
 * 路由定位器，服务获取路由信息
 * 1.可以通过 RouteDefinitionRouteLocator 获取 RouteDefinition ，并转换成 Route
 * @author Spencer Gibb
 */
//TODO: rename to Routes?
public interface RouteLocator {
    /**
     * 获取路由
     * @return
     */
    Flux<Route> getRoutes();
}

通过类图我们可以发现，有三个类实现了RouteLocator接口

RouteLocator-->|缓存功能实现|CachingRouteLocator
RouteLocator-->|组合功能实现|CompositeRouteLocator
RouteLocator-->|通过路由定义转换路由实现|RouteDefinitionRouteLocator

• CachingRouteLocator：

1. 将路由信息缓存在内存中(Map cache);
2. 实现ApplicationListener接口，监听RefreshRoutesEvent事件实现对缓存的动态刷新。
3. 动态刷新可调用GatewayControllerEndpoint中的refresh刷新接口或者自己发布事件来实现路由缓存的动态刷新

/** 
 * 路由定位器的包装类，实现了路由的本地缓存功能,实现事件监听接口，刷新路由缓存
 * @author Spencer Gibb
 */
public class CachingRouteLocator implements RouteLocator, ApplicationListener<RefreshRoutesEvent> {
    /**
     * 目标路由定位器
     */
	private final RouteLocator delegate;
    /**
     * 路由信息
     * Flux 相当于一个 RxJava Observable，
     * 能够发出 0~N 个数据项，然后（可选地）completing 或 erroring。处理多个数据项作为stream
     */
	private final Flux<Route> routes;
    /**
     * 本地缓存，用于缓存路由定位器获取的路由集合
     */
	private final Map<String, List> cache = new HashMap<>();
	
	public CachingRouteLocator(RouteLocator delegate) {
		this.delegate = delegate;
		routes = CacheFlux.lookup(cache, "routes", Route.class)
				.onCacheMissResume(() -> this.delegate.getRoutes().sort(AnnotationAwareOrderComparator.INSTANCE));
	}
	@Override
	public Flux<Route> getRoutes() {
		return this.routes;
	}
	 /**
      * 刷新路由：清除缓存，保存新的路由信息
      */
	public Flux<Route> refresh() {
		this.cache.clear();
		return this.routes;
	}
    /**
     * 事件监听，刷新路由
     */
	@Override
	public void onApplicationEvent(RefreshRoutesEvent event) {
		refresh();
	}

	@Deprecated
	/* for testing */ void handleRefresh() {
		refresh();
	}
}

• CompositeRouteLocator

/**
 * 组合多个 RouteLocator 的实现，为Route提供统一获取入口
 * @author Spencer Gibb
 */
public class CompositeRouteLocator implements RouteLocator {
	/**
     * 能够发出 0~N 个数据项(RouteLocator)，然后（可选地）completing 或 erroring。处理多个数据项作为stream
     */
	private final Flux<RouteLocator> delegates;

	public CompositeRouteLocator(Flux<RouteLocator> delegates) {
		this.delegates = delegates;
	}

	@Override
	public Flux<Route> getRoutes() {
		return this.delegates.flatMap(RouteLocator::getRoutes);
	}
}

• RouteDefinitionRouteLocator 路由加载核心类，通过路由定义（RouteDefinition）转换路由（Route）

/**
 * {@link RouteLocator} that loads routes from a {@link RouteDefinitionLocator}
 * @author Spencer Gibb
 */
public class RouteDefinitionRouteLocator implements RouteLocator, BeanFactoryAware, ApplicationEventPublisherAware {

	public RouteDefinitionRouteLocator(RouteDefinitionLocator routeDefinitionLocator,
									   List<RoutePredicateFactory> predicates,
									   List<GatewayFilterFactory> gatewayFilterFactories,
									   GatewayProperties gatewayProperties,
									   ConversionService conversionService) {
		this.routeDefinitionLocator = routeDefinitionLocator;
		this.conversionService = conversionService;
		initFactories(predicates);
		gatewayFilterFactories.forEach(factory -> this.gatewayFilterFactories.put(factory.name(), factory));
		this.gatewayProperties = gatewayProperties;
	}

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


		/* TODO: trace logging
			if (logger.isTraceEnabled()) {
				logger.trace("RouteDefinition did not match: " + routeDefinition.getId());
			}*/
	}

• RouteDefinitionRouteLocator： RouteDefinition转换

private Route convertToRoute(RouteDefinition routeDefinition) {
    	// 获取routeDefinition中的Predicate信息，返回的是一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND
		AsyncPredicate<ServerWebExchange> predicate = combinePredicates(routeDefinition);
    	// 获取routeDefinition中的GatewayFilter信息
		List<GatewayFilter> gatewayFilters = getFilters(routeDefinition);
		// 构建路由信息
		return Route.async(routeDefinition)
				.asyncPredicate(predicate)
				.replaceFilters(gatewayFilters)
				.build();
	}