SpringCloud服务网关Gateway如何使用

1. 引言

在现代微服务架构中，服务网关（API Gateway）扮演着至关重要的角色。它作为系统的入口，负责请求的路由、负载均衡、安全控制、限流熔断等功能。Spring Cloud Gateway 是 Spring Cloud 生态中的一个重要组件，它基于 Spring 5、Spring Boot 2 和 Project Reactor 构建，旨在为微服务架构提供一种简单而有效的方式来路由请求。

本文将详细介绍 Spring Cloud Gateway 的使用方法，包括其核心概念、配置方式、路由规则、过滤器、限流熔断、安全控制等内容。通过本文的学习，读者将能够掌握如何在微服务架构中使用 Spring Cloud Gateway 来构建高效、可靠的服务网关。

2. Spring Cloud Gateway 概述

2.1 什么是 Spring Cloud Gateway

Spring Cloud Gateway 是 Spring Cloud 生态系统中的一个 API 网关服务，它基于 Spring 5、Spring Boot 2 和 Project Reactor 构建。Spring Cloud Gateway 旨在为微服务架构提供一种简单而有效的方式来路由请求，并且支持多种高级功能，如路由、过滤、限流、熔断等。

2.2 Spring Cloud Gateway 的核心概念

• Route（路由）：路由是网关的基本构建块，它由一个 ID、一个目标 URI、一组断言和一组过滤器组成。如果断言为真，则匹配该路由。
• Predicate（断言）：断言是 Java 8 中的 Predicate 接口，用于匹配 HTTP 请求中的任何内容，例如请求头、请求参数等。
• Filter（过滤器）：过滤器是 GatewayFilter 的实例，可以在请求被路由之前或之后对请求和响应进行修改。

2.3 Spring Cloud Gateway 的优势

• 高性能：基于 Reactor 模型，支持异步非阻塞 I/O，性能优异。
• 灵活的路由配置：支持多种路由规则配置方式，包括配置文件、Java 代码等。
• 强大的过滤器机制：内置多种过滤器，支持自定义过滤器，满足各种业务需求。
• 集成 Spring Cloud 生态：与 Spring Cloud 其他组件（如 Eureka、Hystrix 等）无缝集成。

3. Spring Cloud Gateway 的快速入门

3.1 环境准备

在开始使用 Spring Cloud Gateway 之前，需要确保以下环境已经准备好：

• JDK 1.8 或更高版本
• Maven 3.2+ 或 Gradle 4.x+
• Spring Boot 2.x
• Spring Cloud 2020.x 或更高版本

3.2 创建 Spring Boot 项目

首先，使用 Spring Initializr 创建一个 Spring Boot 项目，选择以下依赖：

• Spring Web
• Spring Cloud Gateway

生成项目后，使用 IDE 打开项目。

3.3 配置 Spring Cloud Gateway

在 application.yml 或 application.properties 文件中配置 Spring Cloud Gateway 的基本信息。以下是一个简单的配置示例：

server:
  port: 8080

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
        - id: service2
          uri: http://localhost:8082
          predicates:
            - Path=/service2/**

在这个配置中，我们定义了两个路由：

• service1：匹配路径 /service1/**，并将请求转发到 http://localhost:8081。
• service2：匹配路径 /service2/**，并将请求转发到 http://localhost:8082。

3.4 启动项目

配置完成后，启动 Spring Boot 项目。启动后，Spring Cloud Gateway 将会监听 8080 端口，并根据配置的路由规则将请求转发到相应的服务。

3.5 测试路由

使用 curl 或 Postman 等工具测试路由是否正常工作。例如：

curl http://localhost:8080/service1/hello

如果配置正确，请求将会被转发到 http://localhost:8081/hello，并返回相应的响应。

4. Spring Cloud Gateway 的路由配置

4.1 路由的基本配置

Spring Cloud Gateway 的路由配置可以通过 application.yml 或 application.properties 文件进行定义。每个路由由以下几个部分组成：

• id：路由的唯一标识符。
• uri：目标服务的 URI。
• predicates：一组断言，用于匹配请求。
• filters：一组过滤器，用于修改请求或响应。

以下是一个简单的路由配置示例：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
        - id: service2
          uri: http://localhost:8082
          predicates:
            - Path=/service2/**

4.2 路由的动态配置

除了在配置文件中静态定义路由外，Spring Cloud Gateway 还支持通过 Java 代码动态配置路由。以下是一个动态配置路由的示例：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("service1", r -> r.path("/service1/**")
            .uri("http://localhost:8081"))
        .route("service2", r -> r.path("/service2/**")
            .uri("http://localhost:8082"))
        .build();
}

在这个示例中，我们使用 RouteLocatorBuilder 动态创建了两个路由，分别匹配 /service1/** 和 /service2/** 路径，并将请求转发到相应的服务。

4.3 路由的优先级

当多个路由的断言都匹配同一个请求时，Spring Cloud Gateway 会根据路由的优先级来决定使用哪个路由。路由的优先级可以通过 order 属性来设置，值越小优先级越高。以下是一个设置路由优先级的示例：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          order: 1
        - id: service2
          uri: http://localhost:8082
          predicates:
            - Path=/service2/**
          order: 2

在这个示例中，service1 路由的优先级高于 service2 路由，因此当请求同时匹配这两个路由时，service1 路由将会被优先使用。

5. Spring Cloud Gateway 的断言

5.1 断言的基本概念

断言（Predicate）是 Spring Cloud Gateway 中用于匹配请求的条件。每个路由可以包含多个断言，只有当所有断言都匹配时，路由才会被选中。Spring Cloud Gateway 提供了多种内置的断言工厂，用于创建常见的断言。

5.2 内置断言工厂

Spring Cloud Gateway 提供了多种内置的断言工厂，以下是一些常用的断言工厂：

• Path：匹配请求路径。
• Method：匹配请求方法（GET、POST 等）。
• Header：匹配请求头。
• Query：匹配请求参数。
• Cookie：匹配请求中的 Cookie。
• Host：匹配请求的 Host 头。
• RemoteAddr：匹配请求的远程地址。

以下是一个使用多种断言的示例：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
            - Method=GET
            - Header=X-Request-Id, \d+
            - Query=name, zhangsan
            - Cookie=sessionId, abc123
            - Host=**.example.com
            - RemoteAddr=192.168.1.1/24

在这个示例中，service1 路由只有在请求路径为 /service1/**、请求方法为 GET、请求头中包含 X-Request-Id 且值为数字、请求参数中包含 name=zhangsan、请求中包含 sessionId=abc123 的 Cookie、Host 头为 **.example.com、远程地址为 192.168.1.1/24 时才会被匹配。

5.3 自定义断言

除了使用内置的断言工厂外，Spring Cloud Gateway 还支持自定义断言。自定义断言需要实现 RoutePredicateFactory 接口，并在配置中使用自定义的断言工厂。

以下是一个自定义断言的示例：

public class CustomRoutePredicateFactory extends AbstractRoutePredicateFactory<CustomRoutePredicateFactory.Config> {

    public CustomRoutePredicateFactory() {
        super(Config.class);
    }

    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            String header = exchange.getRequest().getHeaders().getFirst(config.getHeaderName());
            return header != null && header.equals(config.getHeaderValue());
        };
    }

    public static class Config {
        private String headerName;
        private String headerValue;

        // getters and setters
    }
}

在配置中使用自定义断言：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Custom=headerName:X-Request-Id, headerValue:12345

在这个示例中，我们定义了一个自定义断言工厂 CustomRoutePredicateFactory，并在配置中使用该断言工厂来匹配请求头 X-Request-Id 的值为 12345 的请求。

6. Spring Cloud Gateway 的过滤器

6.1 过滤器的基本概念

过滤器（Filter）是 Spring Cloud Gateway 中用于修改请求或响应的组件。过滤器可以在请求被路由之前或之后执行，并且可以应用于单个路由或全局路由。Spring Cloud Gateway 提供了多种内置的过滤器工厂，用于创建常见的过滤器。

6.2 内置过滤器工厂

Spring Cloud Gateway 提供了多种内置的过滤器工厂，以下是一些常用的过滤器工厂：

• AddRequestHeader：添加请求头。
• AddResponseHeader：添加响应头。
• RemoveRequestHeader：移除请求头。
• RemoveResponseHeader：移除响应头。
• SetStatus：设置响应状态码。
• RewritePath：重写请求路径。
• Retry：重试请求。
• Hystrix：集成 Hystrix 熔断器。
• RateLimiter：限流过滤器。

以下是一个使用多种过滤器的示例：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - AddRequestHeader=X-Request-Id, 12345
            - AddResponseHeader=X-Response-Id, 67890
            - RemoveRequestHeader=X-Secret-Header
            - RemoveResponseHeader=X-Secret-Response
            - SetStatus=401
            - RewritePath=/service1/(?<segment>.*), /$\{segment}
            - Retry=3
            - Hystrix=myCommandKey
            - RateLimiter=10, 20, 60

在这个示例中，service1 路由使用了多种过滤器：

• AddRequestHeader：添加请求头 X-Request-Id，值为 12345。
• AddResponseHeader：添加响应头 X-Response-Id，值为 67890。
• RemoveRequestHeader：移除请求头 X-Secret-Header。
• RemoveResponseHeader：移除响应头 X-Secret-Response。
• SetStatus：设置响应状态码为 401。
• RewritePath：重写请求路径，将 /service1/ 替换为空。
• Retry：重试请求 3 次。
• Hystrix：集成 Hystrix 熔断器，使用 myCommandKey 作为命令键。
• RateLimiter：限流过滤器，允许每秒 10 个请求，最大 20 个请求，时间窗口为 60 秒。

6.3 自定义过滤器

除了使用内置的过滤器工厂外，Spring Cloud Gateway 还支持自定义过滤器。自定义过滤器需要实现 GatewayFilter 接口，并在配置中使用自定义的过滤器工厂。

以下是一个自定义过滤器的示例：

public class CustomGatewayFilterFactory extends AbstractGatewayFilterFactory<CustomGatewayFilterFactory.Config> {

    public CustomGatewayFilterFactory() {
        super(Config.class);
    }

    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest().mutate()
                .header(config.getHeaderName(), config.getHeaderValue())
                .build();
            return chain.filter(exchange.mutate().request(request).build());
        };
    }

    public static class Config {
        private String headerName;
        private String headerValue;

        // getters and setters
    }
}

在配置中使用自定义过滤器：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - Custom=headerName:X-Request-Id, headerValue:12345

在这个示例中，我们定义了一个自定义过滤器工厂 CustomGatewayFilterFactory，并在配置中使用该过滤器工厂来添加请求头 X-Request-Id，值为 12345。

7. Spring Cloud Gateway 的限流与熔断

7.1 限流

在高并发场景下，为了防止服务被过多的请求压垮，通常需要对请求进行限流。Spring Cloud Gateway 提供了 RateLimiter 过滤器来实现限流功能。

7.1.1 使用 Redis 实现限流

Spring Cloud Gateway 默认使用 Redis 来实现限流功能。首先，需要在项目中引入 Redis 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

然后，在 application.yml 中配置 Redis 连接信息：

spring:
  redis:
    host: localhost
    port: 6379

接下来，配置限流过滤器：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
                redis-rate-limiter.requestedTokens: 1

在这个配置中，redis-rate-limiter.replenishRate 表示每秒允许的请求数，redis-rate-limiter.burstCapacity 表示允许的最大请求数，redis-rate-limiter.requestedTokens 表示每个请求消耗的令牌数。

7.1.2 自定义限流策略

除了使用 Redis 实现限流外，Spring Cloud Gateway 还支持自定义限流策略。自定义限流策略需要实现 RateLimiter 接口，并在配置中使用自定义的限流策略。

以下是一个自定义限流策略的示例：

public class CustomRateLimiter implements RateLimiter {

    @Override
    public Mono<Response> isAllowed(String routeId, String id) {
        // 自定义限流逻辑
        return Mono.just(new Response(true, -1));
    }

    public static class Response {
        private final boolean allowed;
        private final long tokensRemaining;

        public Response(boolean allowed, long tokensRemaining) {
            this.allowed = allowed;
            this.tokensRemaining = tokensRemaining;
        }

        public boolean isAllowed() {
            return allowed;
        }

        public long getTokensRemaining() {
            return tokensRemaining;
        }
    }
}

在配置中使用自定义限流策略：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - name: RequestRateLimiter
              args:
                rate-limiter: "#{@customRateLimiter}"

在这个示例中，我们定义了一个自定义限流策略 CustomRateLimiter，并在配置中使用该限流策略来实现限流功能。

7.2 熔断

在微服务架构中，服务之间的调用可能会因为网络问题或服务故障而失败。为了防止故障扩散，通常需要对服务进行熔断处理。Spring Cloud Gateway 提供了 Hystrix 过滤器来实现熔断功能。

7.2.1 使用 Hystrix 实现熔断

首先，需要在项目中引入 Hystrix 依赖：

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

然后，在 application.yml 中配置 Hystrix 过滤器：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - name: Hystrix
              args:
                name: myCommandKey
                fallbackUri: forward:/fallback

在这个配置中，name 表示 Hystrix 命令键，fallbackUri 表示熔断后的降级处理 URI。

7.2.2 自定义熔断策略

除了使用 Hystrix 实现熔断外，Spring Cloud Gateway 还支持自定义熔断策略。自定义熔断策略需要实现 GatewayFilter 接口，并在配置中使用自定义的熔断策略。

以下是一个自定义熔断策略的示例：

public class CustomCircuitBreakerFilter implements GatewayFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        return chain.filter(exchange)
            .onErrorResume(e -> {
                // 自定义熔断逻辑
                return Mono.empty();
            });
    }
}

在配置中使用自定义熔断策略：

spring:
  cloud:
    gateway:
      routes:
        - id: service1
          uri: http://localhost:8081
          predicates:
            - Path=/service1/**
          filters:
            - name: CustomCircuitBreaker
              args:
                fallbackUri: forward:/fallback

在这个示例中，我们定义了一个自定义熔断策略