文章目录

一、简介
- [1.1 术语](#1.1 术语)
[1.3 特性](#1.3 特性)
- [1.4 Spring Cloud Gateway与Spring Cloud Zuul](#1.4 Spring Cloud Gateway与Spring Cloud Zuul)
- - [Spring Cloud Zuul](#Spring Cloud Zuul)
  - Webflux模型
- [1.5 如何集成Gateway](#1.5 如何集成Gateway)
二、工作原理
- [2.2 Gateway类图](#2.2 Gateway类图)
三、配置路由谓词工厂和网关过滤工厂
- [3.1 两种不同的配置路由方式](#3.1 两种不同的配置路由方式)
- - 通过yml文件来配置
  - [通过Java Bean来配置](#通过Java Bean来配置)
- [3.2 Route Predicate 的使用](#3.2 Route Predicate 的使用)
- - [3.2.1 根据datetime 匹配](#3.2.1 根据datetime 匹配)
  - [3.2.2 根据Cookie匹配](#3.2.2 根据Cookie匹配)
- [3.2.3 Header Route Predicate](#3.2.3 Header Route Predicate)
- [3.2.4 Host Route Predicate](#3.2.4 Host Route Predicate)
- [3.2.5 Method Route Predicate](#3.2.5 Method Route Predicate)
- [3.2.5 Path Route Predicate](#3.2.5 Path Route Predicate)
- [3.2.6 Query Route Predicate](#3.2.6 Query Route Predicate)
- [3.2.7 RemoteAddr Route Predicate](#3.2.7 RemoteAddr Route Predicate)
- [3.3 Route Filter 的使用](#3.3 Route Filter 的使用)
- [3.4 Global Filters 全局过滤器](#3.4 Global Filters 全局过滤器)
[四、结合注册中心和配置中心使用](#四、结合注册中心和配置中心使用)
- [4.1 使用动态路由](#4.1 使用动态路由)
- - [4.1.1 基本配置](#4.1.1 基本配置)
  - [4.1.2 使用Route Predicate Factory过滤器实现通过指定path访问服务](#4.1.2 使用Route Predicate Factory过滤器实现通过指定path访问服务)
  - [4.1.3 使用Nacos数据源动态加载和刷新路由配置](#4.1.3 使用Nacos数据源动态加载和刷新路由配置)
- [4.2 基于网关+nacos配置中心实现灰度路由](#4.2 基于网关+nacos配置中心实现灰度路由)
- - [4.2.1 定义GatewayStrategyAutoConfiguration 网关路由自定义配置入口类](#4.2.1 定义GatewayStrategyAutoConfiguration 网关路由自定义配置入口类)
- [4.2.2 网关路由策略发布](#4.2.2 网关路由策略发布)

一、简介

Spring Cloud Gateway 是Spring Cloud 生态全新项目，基于Spring 5、Spring Boot 2.X、Project Reactor实现的API网关，旨在为微服务提供简单高效的API路由管理方法。

Spring Cloud Gateway 作为Spring Cloud 生态中的网关，目标是代替Zuul 1.X。Spring Cloud 2.X版本目前仍未对Zuul 2.X高性能版本进行集成，仍使用的是非Reactor的老版本Zuul网关。

目前Spring Cloud dependencies 最新版本Hoxton.SR8 仍使用的是Zuul 1.3.1

Zuul 2.x 高性能Reactor版本本身与18年5月开源，目前最新版本2.1.9

为了提高网关性能，Spring Cloud Gateway基于WebFlux框架实现，而WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty。

1.1 术语

Route: Gateway的基本构建模块，由ID、目标URL、谓词集合和过滤器集合定义。
Predicate: Java8 Funciton Predicate，输入类型是 SpringFramework ServerWebExchange，可以匹配HTTP请求的所有内容，比如标头或参数。
Filter：使用特定工厂构造的Spring FrameworkGatewayFilter实例，可以在发送下游请求之前或之后修改请求或响应。

1.3 特性

动态路由：能够匹配任何请求属性；
可以对路由指定 Predicate（断言）和 Filter（过滤器）；
集成Hystrix的断路器功能；
集成 Spring Cloud 服务发现功能；
易于编写的 Predicate（断言）和 Filter（过滤器）；
请求限流功能；
支持路径重写

1.4 Spring Cloud Gateway与Spring Cloud Zuul

Spring Cloud Zuul

Springcloud 2.x 版本到目前为止中所集成的Zuul版本（1.x），采用的是Tomcat容器，使用的是传统的Servlet IO处理模型。

servlet由servlet container进行生命周期管理。container启动时构造servlet对象并调用servlet init()进行初始化；container关闭时调用servlet destory()销毁servlet；container运行时接受请求，并为每个请求分配一个线程（一般从线程池中获取空闲线程）然后调用service()。

弊端：servlet是一个简单的网络IO模型，当请求进入servlet container时，servlet container就会为其绑定一个线程，在并发不高的场景下这种模型是适用的，但是一旦并发上升，线程数量就会上涨，而线程资源代价是昂贵的（上线文切换，内存消耗大）严重影响请求的处理时间。在一些简单的业务场景下，不希望为每个request分配一个线程，只需要1个或几个线程就能应对极大并发的请求，这种业务场景下servlet模型没有优势。

所以Springcloud Zuul 是基于servlet之上的一个阻塞式处理模型，即spring实现了处理所有request请求的一个servlet（DispatcherServlet），并由该servlet阻塞式处理处理。所以Springcloud Zuul无法摆脱servlet模型的弊端。

Webflux模型

Webflux模式替换了旧的Servlet线程模型。用少量的线程处理request和response io操作，这些线程称为Loop线程，而业务交给响应式编程框架处理，响应式编程是非常灵活的，用户可以将业务中阻塞的操作提交到响应式框架的work线程中执行，而不阻塞的操作依然可以在Loop线程中进行处理，大大提高了Loop线程的利用率。官方结构图：

Webflux虽然可以兼容多个底层的通信框架，但是一般情况下，底层使用的还是Netty，毕竟，Netty是目前业界认可的最高性能的通信框架。而Webflux的Loop线程，正好就是著名的Reactor 模式IO处理模型的Reactor线程，如果使用的是高性能的通信框架Netty，这就是Netty的EventLoop线程。

1.5 如何集成Gateway

使用Gateway只需要简单引入依赖：

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

二、工作原理

处理流程：

Gateway接受客户端请求；
网关处理程序映射确定请求与路由匹配，匹配成功则将其发送到网关Web处理程序；
Web处理程序处理程序通过特定于请求的过滤器链运行请求：
- 请求经过 Filter 过滤器链，执行 pre 处理逻辑，如修改请求头信息等。
- 发出代理请求，请求被转发至下游服务并返回响应。
响应经过 Filter 过滤器链，执行 post 处理逻辑。
向客户端响应应答。

注意，在没有端口的路由中定义的URI，HTTP和HTTPS URI的默认端口值分别为80和443。

DispatcherHandler：所有请求的调度器，负载请求分发

public class DispatcherHandler implements WebHandler, ApplicationContextAware {
@Nullable
private List<HandlerMapping> handlerMappings;
@Nullable
private List<HandlerAdapter> handlerAdapters;
@Nullable
private List<HandlerResultHandler> resultHandlers;

public DispatcherHandler() {
}

public DispatcherHandler(ApplicationContext applicationContext) {
  this.initStrategies(applicationContext);
}

@Nullable
public final List<HandlerMapping> getHandlerMappings() {
  return this.handlerMappings;
}

public void setApplicationContext(ApplicationContext applicationContext) {
  this.initStrategies(applicationContext);
}

# 初始、校验HandlerMapping并按order排序
protected void initStrategies(ApplicationContext context) {
  Map<String, HandlerMapping> mappingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
  ArrayList<HandlerMapping> mappings = new ArrayList(mappingBeans.values());
  AnnotationAwareOrderComparator.sort(mappings);
  this.handlerMappings = Collections.unmodifiableList(mappings);
  Map<String, HandlerAdapter> adapterBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
  this.handlerAdapters = new ArrayList(adapterBeans.values());
  AnnotationAwareOrderComparator.sort(this.handlerAdapters);
  Map<String, HandlerResultHandler> beans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerResultHandler.class, true, false);
  this.resultHandlers = new ArrayList(beans.values());
  AnnotationAwareOrderComparator.sort(this.resultHandlers);
}

//遍历handlerMappings ，根据exchange找到对应的handler
// 对于Gateway 会找到对应的RoutePredicateHandlerMapping
public Mono<Void> handle(ServerWebExchange exchange) {
return this.handlerMappings == null ? this.createNotFoundError() : Flux.fromIterable(this.handlerMappings).concatMap((mapping) -> {
return mapping.getHandler(exchange);
}).next().switchIfEmpty(this.createNotFoundError())如果遍历不到结果，则切换到错误处理
.flatMap((handler) -> {
//通过HandlerAdapter调用handler，
//gateway使用的 SimpleHandlerAdapter
return this.invokeHandler(exchange, handler);
}).flatMap((result) -> {//对响应进行处理
return this.handleResult(exchange, result);
});
}

private <R> Mono<R> createNotFoundError() {
  return Mono.defer(() -> {
    Exception ex = new ResponseStatusException(HttpStatus.NOT_FOUND, "No matching handler");
    return Mono.error(ex);
  });
}

private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) {
  if (this.handlerAdapters != null) {
    Iterator var3 = this.handlerAdapters.iterator();

    while(var3.hasNext()) {
      HandlerAdapter handlerAdapter = (HandlerAdapter)var3.next();
      if (handlerAdapter.supports(handler)) {
      //调用handler的handle方法处理请求
        return handlerAdapter.handle(exchange, handler);
      }
    }
  }

  return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
}

//根据result获取对应的结果处理handler并处理结果
private Mono<Void> handleResult(ServerWebExchange exchange, HandlerResult result) {
return this.getResultHandler(result).handleResult(exchange, result).checkpoint("Handler " + result.getHandler() + " [DispatcherHandler]").onErrorResume((ex) -> {
return result.applyExceptionHandler(ex).flatMap((exResult) -> {
String text = "Exception handler " + exResult.getHandler() + ", error="" + ex.getMessage() + "" [DispatcherHandler]";
return this.getResultHandler(exResult).handleResult(exchange, exResult).checkpoint(text);
});
});
}

private HandlerResultHandler getResultHandler(HandlerResult handlerResult) {
  if (this.resultHandlers != null) {
    Iterator var2 = this.resultHandlers.iterator();

    while(var2.hasNext()) {
      HandlerResultHandler resultHandler = (HandlerResultHandler)var2.next();
      if (resultHandler.supports(handlerResult)) {
        return resultHandler;
      }
    }
  }

  throw new IllegalStateException("No HandlerResultHandler for " + handlerResult.getReturnValue());
}

}

RoutePredicateHandlerMapping:路由谓语匹配器，用于路由的查找，以及找到路由后返回对应的WebHandler，DispatcherHandler会依次遍历HandlerMapping集合进行处理

public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
private final FilteringWebHandler webHandler;
private final RouteLocator routeLocator;
private final Integer managementPort;
private final RoutePredicateHandlerMapping.ManagementPortType managementPortType;

public RoutePredicateHandlerMapping(FilteringWebHandler webHandler, RouteLocator routeLocator, GlobalCorsProperties globalCorsProperties, Environment environment) {
  this.webHandler = webHandler;
  this.routeLocator = routeLocator;
  this.managementPort = getPortProperty(environment, "management.server.");
  this.managementPortType = this.getManagementPortType(environment);
  //设置排序字段1，此处的目的是Spring Cloud Gateway 的 GatewayWebfluxEndpoint 提供 HTTP API ，不需要经过网关
 //它通过 RequestMappingHandlerMapping 进行请求匹配处理。RequestMappingHandlerMapping 的 order = 0 ，需要排在 RoutePredicateHandlerMapping 前面。所有，RoutePredicateHandlerMapping 设置 order = 1 。
  this.setOrder(1);
  this.setCorsConfigurations(globalCorsProperties.getCorsConfigurations());
}

private RoutePredicateHandlerMapping.ManagementPortType getManagementPortType(Environment environment) {
  Integer serverPort = getPortProperty(environment, "server.");
  if (this.managementPort != null && this.managementPort < 0) {
    return RoutePredicateHandlerMapping.ManagementPortType.DISABLED;
  } else {
    return this.managementPort != null && (serverPort != null || !this.managementPort.equals(8080)) && (this.managementPort == 0 || !this.managementPort.equals(serverPort)) ? RoutePredicateHandlerMapping.ManagementPortType.DIFFERENT : RoutePredicateHandlerMapping.ManagementPortType.SAME;
  }
}

private static Integer getPortProperty(Environment environment, String prefix) {
  return (Integer)environment.getProperty(prefix + "port", Integer.class);
}

//设置mapping到上下文环境
protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
if (this.managementPortType == RoutePredicateHandlerMapping.ManagementPortType.DIFFERENT && this.managementPort != null && exchange.getRequest().getURI().getPort() == this.managementPort) {
return Mono.empty();
} else {
exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_HANDLER_MAPPER_ATTR, this.getSimpleName());
// 查找路由
return this.lookupRoute(exchange).flatMap((r) -> {
exchange.getAttributes().remove(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Mapping [" + this.getExchangeDesc(exchange) + "] to " + r);
}

       //将查找到的路由设置到上下文环境

exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR, r);
//返回mapping对应的WebHandler即FilteringWebHandler
return Mono.just(this.webHandler);
}).switchIfEmpty(Mono.empty().then(Mono.fromRunnable(() -> {
//当前未找到路由时返回空，并移除GATEWAY_PREDICATE_ROUTE_ATTR exchange.getAttributes().remove(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR);
if (this.logger.isTraceEnabled()) {
this.logger.trace("No RouteDefinition found for [" + this.getExchangeDesc(exchange) + "]");
}

    })));
  }
}

protected CorsConfiguration getCorsConfiguration(Object handler, ServerWebExchange exchange) {
  return super.getCorsConfiguration(handler, exchange);
}

private String getExchangeDesc(ServerWebExchange exchange) {
  StringBuilder out = new StringBuilder();
  out.append("Exchange: ");
  out.append(exchange.getRequest().getMethod());
  out.append(" ");
  out.append(exchange.getRequest().getURI());
  return out.toString();
}

//通过路由定位器获取路由信息
protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
return this.routeLocator.getRoutes().concatMap((route) -> {
return Mono.just(route).filterWhen((r) -> {
exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
return (Publisher)r.getPredicate().apply(exchange);//通过谓词过滤路由
}).doOnError((e) -> {
this.logger.error("Error applying predicate for route: " + route.getId(), e);
}).onErrorResume((e) -> {
return Mono.empty();
});
}).next().map((route) -> {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Route matched: " + route.getId());
}

    this.validateRoute(route, exchange);
    return route;
  });
}

protected void validateRoute(Route route, ServerWebExchange exchange) {
}

protected String getSimpleName() {
  return "RoutePredicateHandlerMapping";
}

public static enum ManagementPortType {
  DISABLED,
  SAME,
  DIFFERENT;

  private ManagementPortType() {
  }
}

}

FilteringWebHandler : 使用Filter链表处理请求的WebHandler，RoutePredicateHandlerMapping找到路由后返回对应的FilteringWebHandler对请求进行处理，FilteringWebHandler负责组装Filter链表并调用链表处理请求。

通过过滤器处理web请求的处理器

public class FilteringWebHandler implements WebHandler {
protected static final Log logger = LogFactory.getLog(FilteringWebHandler.class);

全局过滤器

private final List<GatewayFilter> globalFilters;

public FilteringWebHandler(List<GlobalFilter> globalFilters) {
  this.globalFilters = loadFilters(globalFilters);
}

private static List<GatewayFilter> loadFilters(List<GlobalFilter> filters) {
  return (List)filters.stream().map((filter) -> {
    FilteringWebHandler.GatewayFilterAdapter gatewayFilter = new FilteringWebHandler.GatewayFilterAdapter(filter);
    if (filter instanceof Ordered) {
      int order = ((Ordered)filter).getOrder();
      return new OrderedGatewayFilter(gatewayFilter, order);
    } else {
      return gatewayFilter;
    }
  }).collect(Collectors.toList());
}

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);
  combined.addAll(gatewayFilters);
  AnnotationAwareOrderComparator.sort(combined);
  if (logger.isDebugEnabled()) {
    logger.debug("Sorted gatewayFilterFactories: " + combined);
  }

创建过滤器链表对其进行链式调用

  return (new FilteringWebHandler.DefaultGatewayFilterChain(combined)).filter(exchange);
}

private static class GatewayFilterAdapter implements GatewayFilter {
  private final GlobalFilter delegate;

  GatewayFilterAdapter(GlobalFilter delegate) {
    this.delegate = delegate;
  }

  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    return this.delegate.filter(exchange, chain);
  }

  public String toString() {
    StringBuilder sb = new StringBuilder("GatewayFilterAdapter{");
    sb.append("delegate=").append(this.delegate);
    sb.append('}');
    return sb.toString();
  }
}

private static class DefaultGatewayFilterChain implements GatewayFilterChain {
  private final int index;
  private final List<GatewayFilter> filters;

  DefaultGatewayFilterChain(List<GatewayFilter> filters) {
    this.filters = filters;
    this.index = 0;
  }

  private DefaultGatewayFilterChain(FilteringWebHandler.DefaultGatewayFilterChain parent, int index) {
    this.filters = parent.getFilters();
    this.index = index;
  }

  public List<GatewayFilter> getFilters() {
    return this.filters;
  }

  public Mono<Void> filter(ServerWebExchange exchange) {
    return Mono.defer(() -> {
      if (this.index < this.filters.size()) {
        GatewayFilter filter = (GatewayFilter)this.filters.get(this.index);
        FilteringWebHandler.DefaultGatewayFilterChain chain = new FilteringWebHandler.DefaultGatewayFilterChain(this, this.index + 1);
        return filter.filter(exchange, chain);
      } else {
        return Mono.empty();
      }
    });
  }
}

}

2.2 Gateway类图

根据DispatcherHandler入口整理的Gateway类图

Spring Cloud Gateway的配置由一系列RouteDefinitionLocator实例驱动。以下清单显示了RouteDefinitionLocator接口的定义：

RouteDefinitionLocator.java
public interface RouteDefinitionLocator {
    Flux<RouteDefinition> getRouteDefinitions();
}

默认情况下，PropertiesRouteDefinitionLocator使用Spring Boot的@ConfigurationProperties机制来加载属性。

三、配置路由谓词工厂和网关过滤工厂

3.1 两种不同的配置路由方式

Gateway 提供了两种不同的方式用于配置路由，一种是通过yml文件来配置，另一种是通过Java Bean来配置。

通过yml文件来配置

service-url:
  user-service: http://localhost:8201
spring:
  cloud:
    gateway:
      routes:
        - id: path_route #路由的ID
          uri: ${service-url.user-service}/user/{id} #匹配后路由地址
          predicates: # 断言，路径相匹配的进行路由
            - Path=/user/{id}

通过Java Bean来配置

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("path_route2", r -> r.path("/user/getByUsername")
                        .uri("http://localhost:8201/user/getByUsername"))
                .build();
    }
}

3.2 Route Predicate 的使用

Spring Cloud Gateway将路由匹配作为Spring WebFluxHandlerMapping基础架构的一部分。Spring Cloud Gateway包括许多内置的路由谓词工厂。所有这些谓词都与HTTP请求的不同属性匹配。可以将多个路由谓词工厂与逻辑and语句结合使用。

Predicate 来源于 Java 8，是 Java 8 中引入的一个函数，Predicate 接受一个输入参数，返回一个布尔值结果。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。可以用于接口请求参数校验、判断新老数据是否有变化需要进行更新操作。

在 Spring Cloud Gateway 中 Spring 利用 Predicate 的特性实现了各种路由匹配规则，有通过 Header、请求参数等不同的条件来进行作为条件匹配到对应的路由。

下图为 Spring Cloud Gateway内置的几种常见谓词路由器：

3.2.1 根据datetime 匹配

After Route Predicate

在指定时间之后的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
        - id: after_route
          uri: ${service-url.user-service}
          predicates:
            - After=2019-09-24T16:30:00+08:00[Asia/Shanghai]

Before Route Predicate

在指定时间之前的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
        - id: before_route
          uri: ${service-url.user-service}
          predicates:
            - Before=2019-09-24T16:30:00+08:00[Asia/Shanghai]

Between Route Predicate

在指定时间区间内的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
        - id: before_route
          uri: ${service-url.user-service}
          predicates:
            - Between=2019-09-24T16:30:00+08:00[Asia/Shanghai], 2019-09-25T16:30:00+08:00[Asia/Shanghai]

3.2.2 根据Cookie匹配

带有指定Cookie的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
        - id: cookie_route
          uri: ${service-url.user-service}
          predicates:
            - Cookie=username,macro

带有指定请求头的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: ${service-url.user-service}
        predicates:
        - Header=X-Request-Id, \d+

3.2.4 Host Route Predicate

带有指定Host的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: https://example.org
        predicates:
        - Host=**.qt.com

3.2.5 Method Route Predicate

发送指定方法的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: ${service-url.user-service}
        predicates:
        - Method=GET

3.2.5 Path Route Predicate

发送指定路径的请求会匹配该路由。

spring:
  cloud:
    gateway:
      routes:
        - id: path_route
          uri: ${service-url.user-service}/user/{id}
          predicates:
            - Path=/user/{id}

3.2.6 Query Route Predicate

带指定查询参数的请求可以匹配该路由。

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: ${service-url.user-service}/user/getByUsername
        predicates:
        - Query=username

3.2.7 RemoteAddr Route Predicate

从指定远程地址发起的请求可以匹配该路由。

spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: ${service-url.user-service}
        predicates:
        - RemoteAddr=192.168.1.1/24

3.3 Route Filter 的使用

根据Gateway工作原理，我们知道Gateway实际是由路由匹配到的一系列Filter过滤链来处理请求的，Spring Cloud Gateway包括许多内置的GatewayFilter工厂。具体详情参考官网：
https://docs.spring.io/spring-cloud-gateway/docs/2.2.5.RELEASE/reference/html/#gatewayfilter-factories

3.4 Global Filters 全局过滤器

当请求与路由匹配时，过滤Web处理程序会将的所有实例GlobalFilter和所有特定GatewayFilter于路由的实例添加到过滤器链中。该组合的过滤器链按org.springframework.core.Ordered接口排序，可以通过实现该getOrder()方法进行设置。

Spring Cloud Gateway区分了执行过滤器逻辑的"前"和"后"阶段，因此优先级最高的过滤器是"前"阶段的第一个，而"后"阶段的最后一个是优先级最低的一个。

例如，下面程序配置了一个过滤器链：

@Bean
public GlobalFilter customFilter() {
    return new CustomGlobalFilter();
}

public class CustomGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        log.info("custom global filter");
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -1;
    }
}

四、结合注册中心和配置中心使用

Gateway会根据注册中心注册的服务列表，以服务名为路径创建动态路由。这里主要使用Nacos作为注册中心和配置中心

4.1 使用动态路由

4.1.1 基本配置

引入依赖

    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
      <groupId>com.alibaba.cloud</groupId>
      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

启用DiscoveryClient网关集成

# spring.cloud.gateway.discovery.locator.enabled=true
spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true #开启从注册中心动态创建路由的功能
          lower-case-service-id: true #使用小写服务名，默认是大写

使用网关访问服务：

C:\Users\liangbodlz\.ssh>curl 192.168.132.49:1500/nacos-provider/index
Hello!

4.1.2 使用Route Predicate Factory过滤器实现通过指定path访问服务

在实际生产环境中，我们往往不会通过服务的application-name来访问服务，而是通过某个固定的url path来访问，比如xx.xxx/user/login，来访问用户服务的接口

通过Spring Cloud Gateway 内置 Path Route Predicate Factory 可以实现该目标：

spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true #开启从注册中心动态创建路由的功能
          lower-case-service-id: true #使用小写服务名，默认是大写
      routes:
      - id: nacos-provider
        uri: lb://nacos-provider
        predicates:
          - Path=/nprovider/**
        filters:
          - StripPrefix=1

使用指定path访问服务

C:\Users\liangbodlz\.ssh>curl 192.168.132.49:1500/nprovider/index
Hello!
C:\Users\liangbodlz\.ssh>

4.1.3 使用Nacos数据源动态加载和刷新路由配置

通常我们将微服务的Route Predicate Path和Gateway应用本身的配置放在一起，但是随着微服务的扩展，Route Predicate Path会逐渐增加导致Gateway 服务配置会变得臃肿，且Route Predicate Path配置会随着服务的增减进行变更，而更新的路由配置生效需要重启Gateway，这都是实际线上环境不可忍受的。因此独立管理Route Predicate Path配置且支持动态刷新配置变得必要起来。

基于上述需求，我们可以考虑将Gateway 路由配置存储到内存或者其他介质中。

从源码分析中可以知道Gateway路由配置信息由RouteDefinitionLocator 接口完成。

RouteDefinitionLocator 是Gateway路由配置读取的顶级接口，提供从缓存、配置文件、服务注册中心、组合等不同方式读取配置，以及提供RouteDefinitionRepository 接口方式对RouteDefinition进行增、删、查操作。要自定义路由配置实现可以考虑从上述接口着手实现。
这里主要基于Nacos配置中心+RouteDefinitionRepository 自定义路由配置加载，并参考，CachingRouteLocator实现路由配置的动态刷新
核心源码清单

//自定义路由配置加载核心接口
public interface RouteDefinitionRepository extends RouteDefinitionLocator, RouteDefinitionWriter {
}

//查询路由
public interface RouteDefinitionLocator {
  //返回自定义路由配置加载
  Flux<RouteDefinition> getRouteDefinitions();
}

//路由增、删
public interface RouteDefinitionWriter {
  Mono<Void> save(Mono<RouteDefinition> route);

  Mono<Void> delete(Mono<String> routeId);
}
//动态路由刷新实现
public class CachingRouteLocator implements Ordered, RouteLocator, ApplicationListener<RefreshRoutesEvent>, ApplicationEventPublisherAware {
....//省略
  private ApplicationEventPublisher applicationEventPublisher;
.....//省略
  public void onApplicationEvent(RefreshRoutesEvent event) {
    try {
      this.fetch().collect(Collectors.toList()).subscribe((list) -> {
        Flux.fromIterable(list).materialize().collect(Collectors.toList()).subscribe((signals) -> {
          this.applicationEventPublisher.publishEvent(new RefreshRoutesResultEvent(this));
          this.cache.put("routes", signals);
        }, (throwable) -> {
          this.handleRefreshError(throwable);
        });
      });
    } catch (Throwable var3) {
      this.handleRefreshError(var3);
    }

  }

  private void handleRefreshError(Throwable throwable) {
    if (log.isErrorEnabled()) {
      log.error("Refresh routes error !!!", throwable);
    }

    this.applicationEventPublisher.publishEvent(new RefreshRoutesResultEvent(this, throwable));
  }

代码实现

//实现RouteDefinitionRepository接口
package com.easy.mall.route;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.nacos.api.exception.NacosException;
import com.easy.mall.config.GatewayConfig;
import com.easy.mall.operation.NacosConfigOperation;
import com.easy.mall.operation.NacosSubscribeCallback;
import com.google.common.collect.Lists;
import java.util.List;
import java.util.Optional;
import javax.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cloud.gateway.event.RefreshRoutesEvent;
import org.springframework.cloud.gateway.route.RouteDefinition;
import org.springframework.cloud.gateway.route.RouteDefinitionRepository;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * @description: 基于Nacos配置中心实现Gateway 动态路由配置
 * @author: liangbo
 * @create 2020-12-15 19:29
 * @Version 1.0
 **/
@Slf4j
@DependsOn(value= {"gatewayConfig","nacosAutoConfiguration"})
@Configuration
@ConditionalOnProperty(prefix = "global.gateway.dynamicRoute", name = "enabled", havingValue = "true")
public class NacosDynamicRouteDefinitionRepository implements RouteDefinitionRepository {

  @Autowired
  private NacosConfigOperation nacosConfigOperation;

  @Autowired
  private ApplicationEventPublisher publisher;


  @Override
  public Flux<RouteDefinition> getRouteDefinitions() {

    //从Nacos配置中心读取路由配置
    try {
      String dynamicRouteStr = nacosConfigOperation.getConfig(GatewayConfig.NACOS_ROUTE_GROUP, GatewayConfig.NACOS_ROUTE_DATA_ID);
      log.info("init dynamicRoute success.:{}", dynamicRouteStr);
      List<RouteDefinition> routeDefinitions = Optional.ofNullable(dynamicRouteStr)
          .map(str -> JSONObject.parseArray(str, RouteDefinition.class))
          .orElse(Lists.newArrayList());
      return Flux.fromIterable(routeDefinitions);
    } catch (NacosException e) {
      log.error("load gateway dynamicRoute config error:{}", e);
    }

    return Flux.fromIterable(Lists.newArrayList());
  }

  @Override
  public Mono<Void> save(Mono<RouteDefinition> route) {
    return null;
  }

  @Override
  public Mono<Void> delete(Mono<String> routeId) {
    return null;
  }

  /**
   * 侦听nacos config 实时刷新路由配置
   */
  @PostConstruct
  public void subscribeConfigRefresh()  {
    try {
      nacosConfigOperation.subscribeConfig(GatewayConfig.NACOS_ROUTE_GROUP,
          GatewayConfig.NACOS_ROUTE_DATA_ID, null, new NacosSubscribeCallback () {

            @Override
            public void callback(String config) {
              publisher.publishEvent(new RefreshRoutesEvent(this));
            }
          });
    } catch (NacosException e) {
      log.error("nacos-addListener-error", e);
    }
  }

}

动态路由配置清单

[
   {
      "id": "easy-mall-auth",
      "predicates": [{
          "name": "Path",
          "args": {
              "pattern": "/emallauth/**"
          }
      }],
      "uri": "lb://easy-mall-auth",
      "filters": [{
          "name": "StripPrefix",
          "args": {
              "parts": "1"
          }
      }]
  } 
]

4.2 基于网关+nacos配置中心实现灰度路由

实现思路见Nacos安装及Spring Cloud 集成 3.4

4.2.1 定义GatewayStrategyAutoConfiguration 网关路由自定义配置入口类

@Configuration
@AutoConfigureBefore(RibbonClientConfiguration.class)
//通过注解@RibbonClient声明附加配置，此处声明的配置会覆盖配置文件中的配置
@RibbonClients(defaultConfiguration = { GatewayStrategyLoadBalanceConfiguration.class })
@ConditionalOnProperty(value = StrategyConstant.SPRING_APPLICATION_STRATEGY_CONTROL_ENABLED, matchIfMissing = true)
public class GatewayStrategyAutoConfiguration {
//省略......

通过入口类，加载自定义全局过滤器、Ribbon自定义负载均衡配置、元数据处理适配器等。

自定义Ribbon 负载均衡实现

自定义Ribbon 负载均衡实现分别对PredicateBasedRule和ZoneAvoidanceRule进行了扩展

//通过注解@RibbonClient声明附加配置，此处声明的配置会覆盖配置文件中的配置
@RibbonClients(defaultConfiguration = { GatewayStrategyLoadBalanceConfiguration.class })


@Bean
public IRule ribbonRule(IClientConfig config) {

    if (this.propertiesFactory.isSet(IRule.class, serviceId)) {
        return this.propertiesFactory.get(IRule.class, config, serviceId);
    }

    //开启和关闭Ribbon默认的ZoneAvoidanceRule负载均衡策略。一旦关闭，则使用RoundRobin简单轮询负载均衡策略。缺失则默认为true
    boolean zoneAvoidanceRuleEnabled = environment.getProperty(StrategyConstant.SPRING_APPLICATION_STRATEGY_ZONE_AVOIDANCE_RULE_ENABLED, Boolean.class, Boolean.TRUE);
    if (zoneAvoidanceRuleEnabled) {
        DiscoveryEnabledZoneAvoidanceRule discoveryEnabledRule = new DiscoveryEnabledZoneAvoidanceRule();
        discoveryEnabledRule.initWithNiwsConfig(config);

        DiscoveryEnabledZoneAvoidancePredicate discoveryEnabledPredicate = discoveryEnabledRule.getDiscoveryEnabledPredicate();
        discoveryEnabledPredicate.setPluginAdapter(pluginAdapter);
        discoveryEnabledPredicate.setDiscoveryEnabledAdapter(discoveryEnabledAdapter);

        return discoveryEnabledRule;
    } else {
        DiscoveryEnabledBaseRule discoveryEnabledRule = new DiscoveryEnabledBaseRule();

        DiscoveryEnabledBasePredicate discoveryEnabledPredicate = discoveryEnabledRule.getDiscoveryEnabledPredicate();
        discoveryEnabledPredicate.setPluginAdapter(pluginAdapter);
        discoveryEnabledPredicate.setDiscoveryEnabledAdapter(discoveryEnabledAdapter);

        return discoveryEnabledRule;
    }
}

DiscoveryEnabledZoneAvoidanceRule：

DiscoveryEnabledBaseRule

自定义全局过滤器实现将网关路由配置以及Http Header加载到请求ServerWebExchange中

@Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // 把ServerWebExchange放入ThreadLocal中
    GatewayStrategyContext.getCurrentContext().setExchange(exchange);

    // 通过过滤器设置路由Header头部信息，并全链路传递到服务端
    ServerHttpRequest.Builder requestBuilder = exchange.getRequest().mutate();

    if (gatewayCoreHeaderTransmissionEnabled) {
      // 内置Header预先塞入
      Map<String, String> headerMap = strategyWrapper.getHeaderMap();
      if (MapUtils.isNotEmpty(headerMap)) {
        for (Map.Entry<String, String> entry : headerMap.entrySet()) {
          String key = entry.getKey();
          String value = entry.getValue();

          GatewayStrategyFilterResolver.setHeader(requestBuilder, key, value, gatewayHeaderPriority);
        }
      }

      //获取网关配置的路由规则
      String routeVersion = getRouteVersion();
      String routeVersionWeight = getRouteVersionWeight();
      String routeIdBlacklist = getRouteIdBlacklist();
      String routeAddressBlacklist = getRouteAddressBlacklist();

      if (StringUtils.isNotEmpty(routeVersion)) {
        GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_VERSION, routeVersion, gatewayHeaderPriority);
      } else {
        GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_VERSION, gatewayHeaderPriority, gatewayOriginalHeaderIgnored);
      }

      if (StringUtils.isNotEmpty(routeVersionWeight)) {
        GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_VERSION_WEIGHT, routeVersionWeight, gatewayHeaderPriority);
      } else {
        GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_VERSION_WEIGHT, gatewayHeaderPriority, gatewayOriginalHeaderIgnored);
      }

      if (StringUtils.isNotEmpty(routeIdBlacklist)) {
        GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_ID_BLACKLIST, routeIdBlacklist, gatewayHeaderPriority);
      } else {
        GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_ID_BLACKLIST, gatewayHeaderPriority, gatewayOriginalHeaderIgnored);
      }
      if (StringUtils.isNotEmpty(routeAddressBlacklist)) {
        GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_ADDRESS_BLACKLIST, routeAddressBlacklist, gatewayHeaderPriority);
      } else {
        GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_ADDRESS_BLACKLIST, gatewayHeaderPriority, gatewayOriginalHeaderIgnored);
      }
    } else {
      GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_VERSION);
      GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_VERSION_WEIGHT);
      GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_ID_BLACKLIST);
      GatewayStrategyFilterResolver.ignoreHeader(requestBuilder, DiscoveryConstant.N_D_ADDRESS_BLACKLIST);
    }

    // 对于服务A -> 网关 -> 服务B调用链
    // 域网关下(zuulHeaderPriority=true)，只传递网关自身的group，不传递服务A的group，起到基于组的网关端服务调用隔离
    // 非域网关下(zuulHeaderPriority=false)，优先传递服务A的group，基于组的网关端服务调用隔离不生效，但可以实现基于相关参数的熔断限流等功能
    GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_GROUP, pluginAdapter.getGroup(), gatewayHeaderPriority);
    // 网关只负责传递服务A的相关参数（例如：serviceId），不传递自身的参数，实现基于相关参数的熔断限流等功能
    GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_TYPE, pluginAdapter.getServiceType(), false);
    String serviceAppId = pluginAdapter.getServiceAppId();
    if (StringUtils.isNotEmpty(serviceAppId)) {
      GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_APP_ID, serviceAppId, false);
    }
    GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_ID, pluginAdapter.getServiceId(), false);
    GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_VERSION, pluginAdapter.getVersion(), false);
    GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.N_D_SERVICE_ENVIRONMENT, pluginAdapter.getEnvironment(), false);

    ServerHttpRequest newRequest = requestBuilder.build();
    ServerWebExchange newExchange = exchange.mutate().request(newRequest).build();

    ServerWebExchange extensionExchange = extendFilter(newExchange, chain);

    ServerWebExchange finalExchange = extensionExchange != null ? extensionExchange : newExchange;

    // 把新的ServerWebExchange放入ThreadLocal中
    GatewayStrategyContext.getCurrentContext().setExchange(newExchange);

    String path = finalExchange.getRequest().getPath().toString();
    if (path.contains(DiscoveryConstant.INSPECTOR_ENDPOINT_URL)) {
      GatewayStrategyFilterResolver.setHeader(requestBuilder, DiscoveryConstant.INSPECTOR_ENDPOINT_HEADER, pluginAdapter.getPluginInfo(null), true);
    }

    return chain.filter(finalExchange);
  }

自定义DefaultDiscoveryEnabledAdapter封装实例过滤规则

Ribbon负载均衡器执行默认过滤后会执行该规则

  protected boolean apply(Server server) {
        if (discoveryEnabledAdapter == null) {
            return true;
        }

        return discoveryEnabledAdapter.apply(server);
    }
//自定义过滤规则
  @Override
    public boolean apply(Server server) {
      boolean enabled = applyEnvironment(server);
      if (!enabled) {
        return false;
      }

      enabled = applyVersion(server);
      if (!enabled) {
        return false;
      }

      enabled = applyIdBlacklist(server);
      if (!enabled) {
        return false;
      }

      enabled = applyAddressBlacklist(server);
      if (!enabled) {
        return false;
      }

      return applyStrategy(server);
    }

4.2.2 网关路由策略发布

基于nacos配置实现网关策略动态发布，根据网关元数据组以及serviceId创建路由策略配置:

配置通过网关的请求都走版本xx

<?xml version="1.0" encoding="UTF-8"?>
<rule>
    <strategy>
        <version>1.0</version>
    </strategy>
</rule>

step1 启动网关以及2个服务实例

mvn spring-boot:run -Dspring-boot.run.arguments="--server.port=1100 --spring.cloud.nacos.discovery.metadata.version=1.0"
mvn spring-boot:run -Dspring-boot.run.arguments="--server.port=1101 --spring.cloud.nacos.discovery.metadata.version=1.1"

step2 通过网关调用服务，可以验证到请求始终访问到version为1.0 的服务实例

192.168.132.49:1500/nacos-provider/index

配置网关路由权重

<?xml version="1.0" encoding="UTF-8"?>
<rule>
    <strategy>
        <version>1.0;1.1</version>
        <version-weight>1.0=90;1.1=10</version-weight>
    </strategy>
</rule>

灰度策略信息基于Nacos Client以及异步事件处理，动态更新，无需重启网关。

通过网关访问多次服务，请求基本按照9：1的比例命中服务。

配置IP地址和端口屏蔽策略，实现服务流量无损策略下线

服务下线场景中，由于Ribbon负载均衡组件存在着缓存机制，当被调用的服务实例已经下线，而调用的服务实例还暂时缓存着它，直到下个心跳周期才会把已下线的服务实例剔除，在此期间，会造成流量有损

框架提供流量的实时性的绝对无损。采用下线之前，把服务实例添加到屏蔽名单中，负载均衡不会去寻址该服务实例。

代码清单:

//省略
enabled = applyIdBlacklist(server);
 if (!enabled) {
    return false;
 }
//省略

//过滤黑名单IP，框架会将黑名单中IP从Ribbon负载实例中移除
public boolean applyIdBlacklist(Server server) {
      String ids = pluginContextHolder.getContextRouteIdBlacklist();
      if (StringUtils.isEmpty(ids)) {
        return true;
      }

      String serviceUUId = pluginAdapter.getServerServiceUUId(server);

      List<String> idList = StringUtil.splitToList(ids, DiscoveryConstant.SEPARATE);
      if (idList.contains(serviceUUId)) {
        return false;
      }

      return true;
    }

配置Ip黑名单

<?xml version="1.0" encoding="UTF-8"?>
<rule>
    //此处省略
    <strategy-blacklist>
        <!-- 单个Address形式。如果多个用";"分隔，不允许出现空格 -->
        <address value="192.168.132.49:1100"/>
    </strategy-blacklist>
</rule>

发布配置后，访问服务可以发现请求屏蔽了端口为1100的服务，确保1100服务下线，请求不会命中到1100服务。
源码地址

Spring-Cloud-Gateway--源码分析及应用