【源码系列】Spring Cloud Gateway

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          uri: lb://${serviceName}		# http://localhost:8080/
          predicates:
            - Path= /api/**
          filters:
            - StripPrefix=1

2020-06-19T15:55:02.698+0800 [INFO] dataworks/dataworks-gateway-service o.s.b.w.e.netty.NettyWebServer 
	- - Netty started on port(s): 6300

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - After=2020-06-01T24:00:00.000+08:00[Asia/Shanghai]
            # 日期格式必须满足 ZonedDateTime
            # - Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Cookie=mode, test			# cookie 中携带 mode=test ，test 支持正则匹配

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Header=X-Request-Id, \d+    # header 中携带 X-Request-Id 为数字，支持正则匹配

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Host=**.host1.com,**.host2.com	 
            # 支持多个 host 匹配，路径命名规则支持 Ant Path，* 匹配任意字符 ** 匹配任意目录 ? 匹配单字符

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Method=GET,POST          # 路由 GET 和 POST 请求

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Path= /api/**,/api/v2/**         # 支持多个 Path 匹配，路径命名规则支持 Ant Path

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - RemoteAddr=192.168.1.1/24				# 设置某个 ip 区间号段的请求才会路由

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          predicates:
            - Query=baz								# 包含了请求参数 baz的都将被匹配

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          filters:
            - AddRequestParameter=foo, bar        # 请求增加 foo=bar 这个参数

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          filters:
            - AddResponseHeader=X-Response-Foo, bar   
            # Response Header 添加 key=X-Response-Foo, Valuebar

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          filters:
            - name: Retry
              args: 
                retries: 3				# 重试次数
                status: 503				# 针对 HTTP 请求返回状态码进行重试

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          filters:
            - name: RequestRateLimiter
              args: 
                redis-rate-limiter.replenishRate: 10				
                   # 令牌桶的令牌填充速度，代表允许每秒执行的请求数
                redis-rate-limiter.burstCapacity: 20				
                   # 令牌桶的容量，表示每秒用户最大能够执行的请求数量

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          uri: lb://example_service

@Component
public class SSOFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // ...
    }
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }	 
}

@Service
public class XXXGatewayFilterFactory extends AbstractGatewayFilterFactory<XXXConfig> {
  
    @Override
    public GatewayFilter apply(final XXXConfig config) {
        return (((exchange, chain) -> {
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // ...
            }));
        }));
    }
    @Data
    public static class XXXConfig {
        private String name;
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: ${serviceId}
          filter:
            - name: XXX
              args: 
                name: ${name}

@Service
public class XXXGatewayFilterFactory extends AbstractGatewayFilterFactory<XXXConfig> {
  
    @Override
    public GatewayFilter apply(final XXXConfig config) {
        return (((exchange, chain) -> {
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                // ...
            }));
        }));
    }
    @Data
    public static class XXXConfig {
        private String name;
    }
}

public class Route implements Ordered {
    private final String id;
    private final URI uri;				// 路由指向的目的地 uri
    private final int order;			// 多个 Route 之间的排序，数值越小排序越靠前
    private final AsyncPredicate<ServerWebExchange> predicate;		// 匹配 Route 的条件
    private final List<GatewayFilter> gatewayFilters;							// 应用于 Route 的过滤器
}

public interface AsyncPredicate<T> extends Function<T, Publisher<Boolean>> {
    default AsyncPredicate<T> and(AsyncPredicate<? super T> other) {
        // 两个 Predicate 同时满足
    }
    default AsyncPredicate<T> negate() {
        // 对 Predicate 匹配结果取反
    }
    default AsyncPredicate<T> or(AsyncPredicate<? super T> other) {
        // 两个 Predicate 只需满足其一
    }
}

public interface GatewayFilter extends ShortcutConfigurable {
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}
public interface GatewayFilterChain {
    Mono<Void> filter(ServerWebExchange exchange);
}

public class RouteDefinition {
    private String id = UUID.randomUUID().toString();
    private List<PredicateDefinition> predicates = new ArrayList();    // Predicate 定义、描述
    private List<FilterDefinition> filters = new ArrayList();    // Filter 定义、描述
    private URI uri;    // 路由目标 URI
}
public class FilterDefinition {			
    private String name;    // 定义了 Filter 名称，命名规范：为对应的工厂名称前缀
    private Map<String, String> args = new LinkedHashMap();    // 解析配置
}
public class PredicateDefinition {
    private String name;    // 定义了 Predicate 名称，命名规范：为对应的工厂名称
    private Map<String, String> args = new LinkedHashMap();    // 解析配置
}

public interface RoutePredicateFactory<C> extends ShortcutConfigurable, Configurable<C> {
    default Predicate<ServerWebExchange> apply(Consumer<C> consumer) {
    }
    default AsyncPredicate<ServerWebExchange> applyAsync(Consumer<C> consumer) {
    }
}
public interface GatewayFilterFactory<C> extends ShortcutConfigurable, Configurable<C> {
    default GatewayFilter apply(Consumer<C> consumer) {
    }
}

public interface RouteLocator {
    Flux<Route> getRoutes();
}
public class RouteDefinitionRouteLocator implements RouteLocator, 
        BeanFactoryAware, ApplicationEventPublisherAware {
	
    private final RouteDefinitionLocator routeDefinitionLocator;
    // RoutePredicateFactory 列表
    private final Map<String, RoutePredicateFactory> predicates = new LinkedHashMap();
    // GatewayFilterFactory 列表
    private final Map<String, GatewayFilterFactory> gatewayFilterFactories = new HashMap();
                                                      
    public Flux<Route> getRoutes() {
        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) {
        AsyncPredicate<ServerWebExchange> predicate = this.combinePredicates(routeDefinition);
        List<GatewayFilter> gatewayFilters = this.getFilters(routeDefinition);
        return ((AsyncBuilder)Route
                    .async(routeDefinition)
                    .asyncPredicate(predicate)
                    .replaceFilters(gatewayFilters))
                .build();
    }
}

public class DispatcherHandler implements WebHandler, ApplicationContextAware {
    private List<HandlerMapping> handlerMappings;
    private List<HandlerAdapter> handlerAdapters;
    public Mono<Void> handle(ServerWebExchange exchange) {
        // 顺序使用 handlerMappings 获得对应的 WebHandler，invoke 执行
        return Flux.fromIterable(this.handlerMappings)
            // RoutePredicateHandlerMapping
            .concatMap((mapping) -> { return mapping.getHandler(exchange); })
            .next()
            .switchIfEmpty(this.createNotFoundError())
            // SimpleHandlerAdapter
            .flatMap((handler) -> { return this.invokeHandler(exchange, handler); })
            .flatMap((result) -> { return this.handleResult(exchange, result); });
    }
}

public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
    private final FilteringWebHandler webHandler;
    private final RouteLocator routeLocator;
 	
    // mapping.getHandler(exchange); 会调用至此
    protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
        return this.lookupRoute(exchange)    // 匹配 Route
            .flatMap((r) -> {
                // ...
                return Mono.just(this.webHandler);
            })
            .switchIfEmpty(/**未匹配到 Route**/);
    }
}

public class SimpleHandlerAdapter implements HandlerAdapter {
    public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) {
        WebHandler webHandler = (WebHandler)handler;
        Mono<Void> mono = webHandler.handle(exchange);
        return mono.then(Mono.empty());
    }
}
public class FilteringWebHandler implements WebHandler {
    public Mono<Void> handle(ServerWebExchange exchange) {
        Route route = (Route)exchange.getRequiredAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
        List<GatewayFilter> gatewayFilters = route.getFilters();
        List<GatewayFilter> combined = new ArrayList(this.globalFilters);
        // 合并 GlobalFilter 和 GatewayFilter，整体排序
        combined.addAll(gatewayFilters);
        AnnotationAwareOrderComparator.sort(combined);
			
        // 创建 GatewayFilterChain 处理请求
        return (new FilteringWebHandler.DefaultGatewayFilterChain(combined))
          .filter(exchange);
    }
}