SpringGateway转发过程

为什么写？

就想看看springgateway的限流咋做的？但是看着看着就想知道转发过程，然后就写了，总之：转发是通过重组请求头header、uri等信息建立netty客户端连接的访问过程。

Lettuce相较于Jedis有哪些优缺点？

Lettuce 和 Jedis 的定位都是Redis的client，所以他们当然可以直接连接redis server。

Jedis在实现上是直接连接的redis server，如果在多线程环境下是非线程安全的，这个时候只有使用连接池，为每个Jedis实例增加物理连接

Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，应为StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

SpringBoot2.0后之前的jedis已经改成Lettuce了

参见：org.springframework.boot.autoconfigure.data.redis.LettuceConnectionConfiguration，

生效注解：@ConditionalOnClass(RedisClient.class)

RedisURI采用静态内部类Builder进行建造者模式构建ip端口等连接参数，builder.build()实例化RedisURI，之后使用RedisClient.create（redisUri）进行RedisClient客户端实例化，但还未建立连接，之后在RedisClient调用connect方法的时候建立连接。

 lettuce超级链接

一些常用条件注解总结

参考：https://fangjian0423.github.io/2017/05/16/springboot-condition-annotation/

路由分析

​​路由信息：

GatewayProperties成员变量private List<RouteDefinition> routes = new ArrayList<>();存储配置文件的基本路由信息，配置类GatewayAutoConfiguration实例化CachingRouteLocator，将路由信息routeLocators注入到CompositeRouteLocator中，CompositeRouteLocator构造参数是Fluw的Iterable创建的数据流，是反应是编程创建的一种，这里可以想到的是方便遍历路由信息，反应式编程常用操作。需要说明的是CachingRouteLocator是一个RefreshRoutesEvent的事件监听器。

@Bean
public RouteLocator cachedCompositeRouteLocator(List<RouteLocator> routeLocators) {
		return new CachingRouteLocator(
				new CompositeRouteLocator(Flux.fromIterable(routeLocators)));
	}

在Applicationcontext的refresh最后一步finishRefresh()过程中，调用监听器（观察者模式），而后触发了RefreshRoutesEvent事件，调用CachingRouteLocator的onApplicationEvent方法转换路由信息。保存到成员变量Flux<Route> routes中。

HadlerMapping信息：

把路由RouteLocator注入到HadlerMapping中，目的值当客户端访问的时候，通过路由信息匹配lookupRoute

@Bean
	public RoutePredicateHandlerMapping routePredicateHandlerMapping(
			FilteringWebHandler webHandler, RouteLocator routeLocator,
			GlobalCorsProperties globalCorsProperties, Environment environment) {
		return new RoutePredicateHandlerMapping(webHandler, routeLocator,
				globalCorsProperties, environment);
	}

访问过程：

访问的第一站是DispatcherHandler类，执行其中的getHandler获取合适的执行器执行invokeHandler方法

@Override
	public Mono<Void> handle(ServerWebExchange exchange) {
		if (this.handlerMappings == null) {
			return createNotFoundError();
		}
		return Flux.fromIterable(this.handlerMappings)
				.concatMap(mapping -> mapping.getHandler(exchange))
				.next()
				.switchIfEmpty(createNotFoundError())
				.flatMap(handler -> invokeHandler(exchange, handler))
				.flatMap(result -> handleResult(exchange, result));
	}

getHandler匹配路由信息

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
		return this.routeLocator.getRoutes()
				// individually filter routes so that filterWhen error delaying is not a
				// problem
				.concatMap(route -> Mono.just(route).filterWhen(r -> {
					// add the current route we are testing
					exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
					return r.getPredicate().apply(exchange);
				})
						// instead of immediately stopping main flux due to error, log and
						// swallow it
						.doOnError(e -> logger.error(
								"Error applying predicate for route: " + route.getId(),
								e))
						.onErrorResume(e -> Mono.empty()))
				// .defaultIfEmpty() put a static Route not found
				// or .switchIfEmpty()
				// .switchIfEmpty(Mono.<Route>empty().log("noroute"))
				.next()
				// TODO: error handling
				.map(route -> {
					if (logger.isDebugEnabled()) {
						logger.debug("Route matched: " + route.getId());
					}
					validateRoute(route, exchange);
					return route;
				});

	}

限流过滤器：


转发属性设置RouteToRequestUrlFilter，将执行exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, mergedUrl);
把转发的url设置的exchange属性里边，目的是执行到转发过滤器的时候，取出来重新赋值到request url。

@Override
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
		if (route == null) {
			return chain.filter(exchange);
		}
		log.trace("RouteToRequestUrlFilter start");
		URI uri = exchange.getRequest().getURI();
		boolean encoded = containsEncodedParts(uri);
		URI routeUri = route.getUri();

		// 省略。。。

		URI mergedUrl = UriComponentsBuilder.fromUri(uri)
				// .uri(routeUri)
				.scheme(routeUri.getScheme()).host(routeUri.getHost())
				.port(routeUri.getPort()).build(encoded).toUri();
		exchange.getAttributes().put(GATEWAY_REQUEST_URL_ATTR, mergedUrl);
		return chain.filter(exchange);
	}

转发路由NettyRoutingFilter：

@Override
	@SuppressWarnings("Duplicates")
	public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
		URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR);

		// 省略。。。。
		final String url = requestUrl.toASCIIString();

		HttpHeaders filtered = filterRequest(getHeadersFilters(), exchange);

		final DefaultHttpHeaders httpHeaders = new DefaultHttpHeaders();
		filtered.forEach(httpHeaders::set);
 
		Flux<HttpClientResponse> responseFlux = getHttpClient(route, exchange)
				.headers(headers -> {
					headers.add(httpHeaders);
					// Will either be set below, or later by Netty
					headers.remove(HttpHeaders.HOST);
					if (preserveHost) {
						String host = request.getHeaders().getFirst(HttpHeaders.HOST);
						headers.add(HttpHeaders.HOST, host);
					}
				}).request(method)
                    // 重新设置uri
                .uri(url).send((req, nettyOutbound) -> {
					// 省略。。。。
		return responseFlux.then(chain.filter(exchange));
	}

时序图：