devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Spring Cloud Gateway面试题_spring cloud gateway 面试

作者：IT小白 | 2024-05-28 02:36:26

赞

踩

spring cloud gateway 面试

Spring Cloud Gateway面试题

序号内容链接地址
1Java面试题https://blog.csdn.net/golove666/article/details/137360180
2JVM面试题 https://blog.csdn.net/golove666/article/details/137245795
3Servlet面试题 https://blog.csdn.net/golove666/article/details/137395779
4Maven面试题 https://blog.csdn.net/golove666/article/details/137365977
5Git面试题https://blog.csdn.net/golove666/article/details/137368870
6Gradle面试题https://blog.csdn.net/golove666/article/details/137368172
7Jenkins 面试题 https://blog.csdn.net/golove666/article/details/137365214
8Tomcat面试题 https://blog.csdn.net/golove666/article/details/137364935
9Docker面试题 https://blog.csdn.net/golove666/article/details/137364760
10多线程面试题 https://blog.csdn.net/golove666/article/details/137357477
11Mybatis面试题 https://blog.csdn.net/golove666/article/details/137351745
12Nginx面试题 https://blog.csdn.net/golove666/article/details/137349465
13Spring面试题 https://blog.csdn.net/golove666/article/details/137334729
14Netty面试题https://blog.csdn.net/golove666/article/details/137263541
15SpringBoot面试题https://blog.csdn.net/golove666/article/details/137192312
16SpringBoot面试题1 https://blog.csdn.net/golove666/article/details/137383473
17Mysql面试题 https://blog.csdn.net/golove666/article/details/137261529
18Redis面试题 https://blog.csdn.net/golove666/article/details/137267922
19PostgreSQL面试题 https://blog.csdn.net/golove666/article/details/137385174
20Memcached面试题 https://blog.csdn.net/golove666/article/details/137384317
21Linux面试题https://blog.csdn.net/golove666/article/details/137384729
22HTML面试题 https://blog.csdn.net/golove666/article/details/137386352
23JavaScript面试题 https://blog.csdn.net/golove666/article/details/137385994
24Vue面试题https://blog.csdn.net/golove666/article/details/137341572
25Ajax面试题https://blog.csdn.net/golove666/article/details/137421929
26Python面试题 https://blog.csdn.net/golove666/article/details/137385635
27Spring Cloud Alibaba面试题 https://blog.csdn.net/golove666/article/details/137372112
28SpringCloud面试题 https://blog.csdn.net/golove666/article/details/137345465
29RabbitMQ面试题 https://blog.csdn.net/golove666/article/details/137344188
30Dubbo面试题 https://blog.csdn.net/golove666/article/details/137346834
31Elasticsearch面试题https://blog.csdn.net/golove666/article/details/137348184
32Oracle面试题https://blog.csdn.net/golove666/article/details/137350452
33Android面试题https://blog.csdn.net/golove666/article/details/137358253
34Kafka面试题 https://blog.csdn.net/golove666/article/details/137358607
35ZooKeeper面试题 https://blog.csdn.net/golove666/article/details/137359255
36Kubernetes面试题 https://blog.csdn.net/golove666/article/details/137365540
37Flink面试题 https://blog.csdn.net/golove666/article/details/137369555
38Hadoop面试题https://blog.csdn.net/golove666/article/details/137370194
39Hive面试题https://blog.csdn.net/golove666/article/details/137371835
40Hbase面试题 https://blog.csdn.net/golove666/article/details/137381853
41Spark面试题https://blog.csdn.net/golove666/article/details/137382815
42Golang面试题 https://blog.csdn.net/golove666/article/details/137395486
43Solr面试题 https://blog.csdn.net/golove666/article/details/137420799
44Vue Router面试题https://blog.csdn.net/golove666/article/details/137451302
45Axios面试题https://blog.csdn.net/golove666/article/details/137435251
46Npm面试题https://blog.csdn.net/golove666/article/details/137453790
47MongoDB面试题https://blog.csdn.net/golove666/article/details/137383946
48云原生面试题https://blog.csdn.net/golove666/article/details/137492832
49Nacos面试题https://blog.csdn.net/golove666/article/details/137534990
50Seata面试题https://blog.csdn.net/golove666/article/details/137580504
51Sentinel面试题https://blog.csdn.net/golove666/article/details/137623642
52Seluth面试题https://blog.csdn.net/golove666/article/details/137690943
53SkyWalking面试题https://blog.csdn.net/golove666/article/details/137721955
54Spring Cloud Bus面试题https://blog.csdn.net/golove666/article/details/137739136
55Spring Cloud Stream面试题https://blog.csdn.net/golove666/article/details/137789910

1. Spring Cloud Gateway基本概念

1.1 什么是Spring Cloud Gateway？

Spring Cloud Gateway 是一个构建于 Spring Framework 5、Project Reactor 和 Spring Boot 2 之上的动态、可编程的API网关。它用于提供一种简单有效的方式来对API请求进行路由、转发和处理，并且与Spring生态系统紧密集成，提供了对Spring Cloud Discovery Client的支持，从而能够实现服务发现和负载均衡的功能。

Spring Cloud Gateway 的主要特点包括：

  1. 基于路由的API网关：它可以根据一系列预定义的路由来转发请求到不同的后端微服务。每个路由都由一个ID、一个目标URI、一组断言和一组过滤器定义。

  2. 集成断言和过滤器机制：网关的行为可以通过断言和过滤器来控制。断言用于匹配请求是否满足某些条件，而过滤器用于在请求发送到下游服务之前或后执行一些操作。

  3. 响应式编程支持：内部使用WebFlux，是响应式编程模式的API网关，保持高吞吐量和低延迟。

  4. 服务发现集成：能够与Eureka、Consul等服务发现工具结合，自动从服务注册中心获取路由的目标地址。

  5. 断路器集成：可以集成Hystrix断路器或Resilience4J来提供降级和熔断机制，提升API的健壮性。

  6. 安全集成：可以与Spring Security集成，为API网关提供OAuth2、JWT等认证和授权支持。

  7. 跨域资源共享（CORS）支持：提供CORS的配置和处理能力，方便构建跨域的Web应用。

  8. 全局过滤器：支持全局过滤器，可对所有的路由统一执行如日志记录、请求限流等功能。

  9. 动态路由：提供了接口和事件模型，可以在不重启Gateway的情况下动态更新路由规则。

Spring Cloud Gateway 的设计目标是替代Netflix的Zuul 1.x网关，其使用的是异步非阻塞模型，适用于处理更加琐碎、更高频次的请求。由于使用了最新的Spring框架，Spring Cloud Gateway 提供了更好的性能和更灵活的编程模型，非常适合现代微服务架构中对API网关的需求。

1.2 Spring Cloud Gateway和Zuul有什么区别？

Spring Cloud Gateway 和 Netflix’s Zuul 是两个可以在微服务架构中作为API网关使用的Spring Cloud项目，但是它们在架构、性能和功能上有一些关键差异。以下是它们之间的一些主要区别：

  1. 底层框架：

    • Spring Cloud Gateway 基于非阻塞和异步的网络库Netty以及Spring WebFlux框架构建，它是为了充分利用现代Java平台的新特性、响应式编程和高并发而设计的。
    • Zuul 1.x 是基于阻塞IO的Servlet API和Tomcat容器构建的。它没有提供对长连接或WebSocket等非HTTP协议的原声支持。

  2. 性能：

    • Spring Cloud Gateway 因为其基于Netty非阻塞和异步的IO操作模型，通常提供了更好的性能和更高的吞吐量。
    • Zuul 1.x 因其设计为阻塞架构，当面对大量并发请求时可能无法非常有效地利用系统资源。

  3. 路由方式：

    • Spring Cloud Gateway 提供了基于Predicate和Filter的强大路由功能，允许开发者以声明性的方式来定义路由规则。
    • Zuul 1.x 提供了一套默认的路由和过滤器API，但在灵活性和动态路由能力方面，不如Spring Cloud Gateway。

  4. 响应式编程模型支持：

    • Spring Cloud Gateway 支持响应式编程模型，可以与Spring WebFlux等响应式组件无缝集成。
    • Zuul 1.x 虽然可以与Spring MVC结合使用，但它本身不支持响应式编程模型。

  5. 维护状态：

    • Spring Cloud Gateway 是Spring推出的下一代API网关，受到持续的支持和积极的开发。
    • Zuul 1.x 已被标记为进入维护模式，未来不太可能有新的功能添加。而Netflix已经推出了Zuul 2，但Spring Cloud没有为Zuul 2提供一级的Spring Boot集成。

  6. WebSockets：

    • Spring Cloud Gateway 原生支持WebSockets。
    • Zuul 1.x 对WebSockets的支持并不完整，通常需要额外的自定义开发。

  7. 开放性和扩展性：

    • Spring Cloud Gateway 提供了更开放和更易于扩展的API，方便用户根据需要定制和扩展功能。
    • Zuul 1.x 限于其架构和性能，扩展性较Spring Cloud Gateway差。

在选择合适的API网关时，应该综合考虑网络架构、性能要求、特定的功能需求以及团队对技术的熟悉度。对于新的微服务项目或准备对网关进行升级的项目，一般推荐使用Spring Cloud Gateway，因为它在灵活性、性能和长期支持方面提供了更多的优势。

1.3 Spring Cloud Gateway的核心组件有哪些？

Spring Cloud Gateway 是构建在 Spring Framework 5、Project Reactor 和 Spring Boot 2 之上的API Gateway。它提供了对微服务架构中请求路由、过滤和监控的支持。这里是 Spring Cloud Gateway 的一些核心组件：

  1. Route（路由）：
    路由是Gateway构建的基本模块，它由一个ID、一个目标URI、一组谓词（Predicate）和一组过滤器（Filter）构成。如果聚合的谓词是真，就代表请求的目标URI。

  2. Predicate（谓词）：
    谓词是一个Java 8 Function，输入类型是ServerWebExchange。可以使用它来匹配来自HTTP请求的不同属性，如路径、方法或头部信息。

  3. Filter（过滤器）：
    这用于修改请求和响应。过滤器可以在发送代理请求之前或之后执行某些操作。它们可以被分为GatewayFilter（作用于单个路由）和GlobalFilter（影响所有路由）。

  4. GatewayHandlerMapping：
    负责匹配连接到Gateway的每个请求，并且为这些请求指定路由。

  5. GatewayWebHandler：
    负责处理通过GatewayHandlerMapping匹配到的请求。它将请求发送到路由指定的URI。

  6. RouteLocator：
    负责提供一份路由定义。可以配置静态路由定义（如在配置文件中定义）或通过RouteLocatorBuilder动态构建路由。

  7. ProxyExchange：
    用于处理代理请求的帮助类。如果需要在Filter中构造代理请求，可以使用此组件。

  8. Actuator API：
    提供对Gateway进行实时监控和管理的功能。你可以通过actuator端点看到路由信息、过滤器、监控等。

  9. Gateway Controller Endpoint：
    一个基于Web的Endpoint，用来动态地添加、删除和修改路由信息。

Spring Cloud Gateway 使用这些组件提供强大的路由能力，并通过过滤器链来提供对请求和响应的微妙控制。这些组件共同工作以确保Gateway是高可扩展、易于维护和部署的。它为微服务架构中的路由转发、请求过滤和服务鉴权提供了丰富的功能支持。

1.4 为何需要使用API网关？

API网关在现代微服务架构中扮演着核心角色，原因如下：

  1. 请求路由：
    API网关可以将客户端的请求路由到正确的微服务实例，无需让客户端关心微服务的具体位置。

  2. 负载均衡：
    通过API网关分发请求，可以实现跨多个微服务实例的负载均衡，提高系统的可用性和弹性。

  3. 认证和授权：
    在API网关层统一进行用户认证和授权校验，可以简化各个微服务的安全实现，也可作为防护的第一道门槛。

  4. 协议转换与适配：
    处理从外部应用到微服务之间协议转换的问题，例如将外部HTTP/REST请求转换为内部RPC调用等。

  5. 服务发现集成：
    API网关通常和服务发现机制集成，能够动态地发现服务实例的变化并调整路由。

  6. 请求聚合：
    对于需要聚合多个微服务调用以返回一个统一响应的情况，API网关可以减少客户端的网络请求次数和复杂度。

  7. 限流和熔断：
    API网关可以对流量进行控制，包括请求的限流和熔断，以防止系统过载和故障蔓延。

  8. 跨域资源共享（CORS）处理：
    在网关层统一处理CORS问题，避免在各个微服务中重复配置。

  9. API版本管理：
    管理API的多个版本和维护向后兼容性，甚至可以实现平滑过渡和弃用计划。

  10. 缓存：
    提供响应缓存功能，减少对后端微服务的请求次数，提升响应速度和减轻后端服务的负载。

  11. 监控和日志：
    集中记录请求日志并提供统计数据，有助于监控API的使用情况和性能。

  12. 错误处理和统一的错误返回：
    在API网关层统一处理和格式化微服务可能返回的各种错误响应。

  13. 安全性增强：
    作为防护层，对数据进行预处理，如过滤、验证等，有助于保护后端微服务不受攻击。

  14. 链路追踪：
    网关是实施链路追踪的理想位置，可以为进出的请求加上追踪标识。

API网关作为微服务架构中的中心节点，简化了服务消费者和服务提供者的交互，提升了架构的整体安全性、可维护性和可伸缩性。在选择API网关解决方案时，重要的是要考虑具体的业务需求、技术栈、性能和可维护性。常见的API网关解决方案包括Netflix Zuul、Spring Cloud Gateway、Kong和Amazon API Gateway。

2. 路由和过滤器

2.1 如何在Spring Cloud Gateway中配置路由？

在 Spring Cloud Gateway 中，配置路由通常涉及将外部请求映射到对应的微服务端点。你可以使用两种方法来配置路由：一种是声明性的，在配置文件（例如 application.yml）中定义；另一种是编程式的，直接在 Java 代码中定义。以下是这两种配置方式的基本步骤：

声明性配置

  1. 添加依赖
    在你的 pom.xml 或 build.gradle 文件中添加 Spring Cloud Gateway 的起步依赖。

对于 Maven 项目，在 pom.xml 添加：

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

对于 Gradle 项目，在 build.gradle 添加：

dependencies {
    implementation 'org.springframework.cloud:spring-cloud-starter-gateway'
}

  • 1
  • 2
  • 3
  1. 配置路由
    在 application.yml 或 application.properties 文件里，添加路由定义。以下是 application.yml 中的一个配置示例：
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://USER-SERVICE
          predicates:
            - Path=/user/**
          filters:
            - StripPrefix=1
        - id: order-service
          uri: lb://ORDER-SERVICE
          predicates:
            - Path=/order/**

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

在这个例子中，创建了两个路由规则。对于以 /user/ 开头的路径，请求将被路由到 USER-SERVICE，并且 StripPrefix=1 会将原始请求的 /user 部分去除后再进行转发。对于以 /order/ 开头的路径，请求将被路由到 ORDER-SERVICE。

lb:// 表示使用 Spring Cloud 的负载均衡器。

编程式配置

  1. 添加依赖
    和上面声明性配置中相同。

  2. Java 配置
    创建一个配置类并定义 RouteLocator Bean。你可以使用 Spring Cloud Gateway 的 RouteLocatorBuilder 来构建路由。

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            .route("user-service", r -> r.path("/user/**")
                .uri("lb://USER-SERVICE"))
            .route("order-service", r -> r.path("/order/**")
                .uri("lb://ORDER-SERVICE"))
            .build();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这段代码将创建与上述声明性配置中相同的两个路由规则。

在这两种方法中，id 字段是给定路由规则的唯一标识符。predicates 定义了路由匹配的条件，例如按照路径进行匹配。filters 允许你定义一系列过滤器，用于修改进出的请求和响应。

注意

确保服务名称（如 USER-SERVICE）匹配注册到服务发现（如 Eureka、Consul）中的微服务名称。lb:// 表示通过服务发现获取服务实例，并执行负载均衡。如果还没有使用服务发现，可以替换为具体的 URL。

完成配置后，Spring Cloud Gateway 将基于这些定义来处理入站请求，并根据配置将请求路由到对应的微服务。

2.2 什么是Predicates和Filters？

在 Spring Cloud Gateway 等 API 网关或路由框架中，Predicates（谓词）和 Filters（过滤器）是用来定义和控制路由行为的关键概念。

Predicates（谓词）

Predicates 是逻辑条件，用来判断一个给定的 HTTP 请求是否与某个路由匹配。如果请求满足路由配置中指定的谓词条件，那么 API 网关就会将该请求路由到相应的服务。常见的谓词包括请求路径匹配、请求方法匹配、请求头匹配等。

例如，一个路径匹配谓词可以如下定义：

routes:
  - id: route-1
    uri: http://example.org
    predicates:
      - Path=/api/service/**

  • 1
  • 2
  • 3
  • 4
  • 5

在上述示例中，仅当请求的路径以 /api/service/ 开头时，谓词 Path 才匹配，并且请求将会被转发到 http://example.org。

Filters（过滤器）

Filters 是在请求路由之前或之后运行的逻辑组件，可以对请求和响应实施修改、检查或增强处理。过滤器可以用来修改请求头、改变目的服务、添加响应头等操作。

过滤器分为两种类型：

  • Pre-filters：在请求路由到指定服务之前执行。
  • Post-filters：在请求路由到指定服务之后执行。

Filters 可以实现很多复杂的功能，如添加认证头、收集统计信息、限流、熔断等。例如，添加一个在请求转发前修改请求路径的 filter：

routes:
  - id: route-2
    uri: http://example.org
    predicates:
      - Path=/service/**
    filters:
      - RewritePath=/service/(?<segment>.*), /$\{segment}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

上述示例中，一个请求的路径如果以 /service/ 开头，将会被路由到 http://example.org。同时，一个 RewritePath 过滤器会将路径中的 /service/ 去除。

谓词和过滤器的结合

在定义路由时，谓词和过滤器常常被一起使用以实现细粒度的路由控制。谓词决定了请求是否应该被路由，而过滤器则定义了在请求被路由前后应该执行哪些逻辑。每个路由可以根据需要组合使用多个谓词和过滤器，来匹配各种复杂的条件和业务场景。

在实际应用中，Predicates 和 Filters 的组合为 API 网关的管理者提供了强大且灵活的路由规则定义能力，使得流量管理、服务聚合及微服务架构的治理成为可能。

2.3 如何自定义过滤器？

在Spring Cloud Gateway中，自定义过滤器允许您对API请求和响应执行自定义的逻辑处理操作。这些自定义过滤器可以用来修改请求头、增加响应头、设置路径重写、增加日志记录等等。

以下是创建和应用自定义过滤器的大致步骤：

步骤 1：创建过滤器类

创建一个实现GatewayFilter和Ordered接口的Java类。通过实现Ordered接口，您可以为过滤器定义一个特定的执行顺序。

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public class CustomFilter implements GatewayFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 在这里编写自定义过滤逻辑
        // 例如，在请求前后打印日志
        System.out.println("Pre-processing logic here");
        
        return chain.filter(exchange).then(Mono.fromRunnable(() -> {
            System.out.println("Post-processing logic here");
        }));
    }

    @Override
    public int getOrder() {
        // 定义过滤器顺序（数值越小优先级越高）
        return -1;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

步骤 2：注册自定义过滤器

将您的过滤器注册为一个Spring Bean，并在路由配置中使用这个过滤器。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;

@Configuration
public class CustomFilterConfig {

    @Bean
    public CustomFilter customFilter() {
        return new CustomFilter();
    }

    @Bean
    public RouteLocator routes(RouteLocatorBuilder builder, CustomFilter filter) {
        return builder.routes()
                .route(r -> r.path("/custom-filter")
                             .filters(f -> f.filter(filter))
                             .uri("http://example.org"))
                .build();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

在上面的配置中，CustomFilter是应用到所有符合/custom-filter路径的请求的自定义过滤器。它会在请求被路由到http://example.org之前和之后执行定义的逻辑。

步骤 3：通过工厂创建过滤器（可选）

您也可以通过创建GatewayFilterFactory的实现来创建更为灵活的自定义过滤器。

import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;

public class CustomFilterFactory extends AbstractGatewayFilterFactory<CustomFilterFactory.Config> {
    public static class Config {
        // 自定义过滤器配置属性
    }

    // 实现过滤器逻辑和自定义配置逻辑
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

注意事项

  • 当自定义过滤器时，需要确保考虑并发性和状态管理，因为这些过滤器将在多个请求之间共享。
  • 需要测试自定义过滤器以确保它们在各种情景下按预期工作。
  • 自定义过滤器可能影响请求/响应的性能和时序，使用时需谨慎。

通过这些步骤，您可以为Spring Cloud Gateway自定义一系列的过滤器，以满足API网关层面的各种需求。

2.4 Spring Cloud Gateway支持哪些内置的路由匹配断言？

Spring Cloud Gateway 提供了多种内置的路由匹配断言（Predicates），可以基于HTTP请求的不同属性来定义路由的行为。这些断言可以组合起来，以根据复杂的逻辑来匹配进入的请求。下面是一些常用的内置路由匹配断言：

  1. After Route Predicate：
    匹配所有在指定日期（或时间）之后发起的请求。

  2. Before Route Predicate：
    匹配所有在指定日期（或时间）之前发起的请求。

  3. Between Route Predicate：
    匹配所有在指定的开始时间和结束时间之间发起的请求。

  4. Cookie Route Predicate：
    基于请求中的某个cookie的存在和值来匹配请求。

  5. Header Route Predicate：
    基于请求头的存在和值进行匹配。

  6. Host Route Predicate：
    根据请求的Host头（即请求的域名或主机名）来匹配。

  7. Method Route Predicate：
    根据HTTP请求的方法（如GET、POST等）来匹配。

  8. Path Route Predicate：
    根据请求的路径和路径模式（支持Ant样式的路径模式）来匹配。

  9. Query Route Predicate：
    基于请求的查询参数进行匹配。

  10. RemoteAddr Route Predicate：
    基于请求的源IP地址来匹配，可以支持CIDR范围。

  11. Weight Route Predicate：
    根据权重（例如，流量分配）来匹配请求。

  12. CloudFoundry Route Predicate：
    专为Cloud Foundry设计的路由断言。

  13. ReadBody Predicate：
    对请求体进行读取并进行评估的路由断言。这允许基于请求正文的内容制定路由逻辑，但它可能会带来性能的消耗。

除了内置的断言，Spring Cloud Gateway 还提供了强大的可扩展性，使开发者能够创建自定义的路由断言。这与过滤器（Filters）相结合，允许创建非常强大和灵活的路由逻辑。

举个例子，下面是一个路由配置，它使用了Path和Method断言，以匹配满足特定路径模式且请求方法为GET的所有请求：

spring:
  cloud:
    gateway:
      routes:
        - id: example-route
          uri: http://example.org
          predicates:
            - Path=/get/**
            - Method=GET

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

在这个配置文件中，任何路径以/get/开头且HTTP方法为GET的请求都会被转发到http://example.org。

3. 动态路由和配置

3.1 Spring Cloud Gateway如何实现动态路由？

Spring Cloud Gateway 允许您动态地添加、修改和删除路由，这在微服务架构中非常有用，因为服务可能会动态变化或需要在不同版本和环境之间切换。以下是 Spring Cloud Gateway 实现动态路由的一些主要方法：

  1. 利用Spring Cloud Config：
    如果你的路由配置存储在Spring Cloud Config Server中，当配置仓库中的路由配置改变时，Gateway可以通过监听配置更改事件自动刷新路由。

配置例子：

spring:
  cloud:
    gateway:
      routes:
        - id: myservice
          uri: lb://myservice
          predicates:
            - Path=/api/myservice/**

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

当你提交并推送更新到配置仓库（如Git），Config Server 会通知 Gateway 重新加载配置。结合 Spring Cloud Bus，可以实现配置的集群广播和自动刷新。

  1. 监听应用程序事件：
    Gateway可以监听特定的Spring Application Events（比如RefreshRoutesEvent），以动态刷新路由配置。

这可以通过代码示例来实现：

@Autowired
RouteDefinitionLocator locator;

@Autowired
RoutesRefresher refresher;

public void refreshRoutes() {
    this.refresher.refresh();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  1. 使用Actuator端点：
    Spring Cloud Gateway暴露了一些管理和监控用的Actuator端点，其中一个是 /actuator/gateway/refresh。通过调用这个端点可以强制Gateway刷新路由。

HTTP 请求示例：
POST http://localhost:8080/actuator/gateway/refresh

  1. 编程方式动态操作：
    你也可以通过编写自定义代码，直接与Gateway API交云，来动态添加或删除路由：
@Autowired
InMemoryRouteDefinitionRepository routeDefinitionRepository;

public void addNewRoute() {
    RouteDefinition routeDefinition = new RouteDefinition();
    routeDefinition.setId("new-route");
    routeDefinition.setUri("http://example.com");
    routeDefinition.setPredicates(
        Arrays.asList(new PredicateDefinition("Path=/new/**"))
    );

    routeDefinitionRepository.save(Mono.just(routeDefinition)).subscribe();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

  1. API 运行时间动态更新：
    Spring Cloud Gateway 提供相应的 API，可以在运行时对特定的路由进行修改。通过制定合适的API，可以实时进行路由的增、删、改操作。

  2. 自定义路由定位器：
    通过定义自己的RouteLocator的Bean，可以实现完全自定义的动态路由逻辑。

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    //@formatter:off
    return builder.routes()
        .route("path_route", r -> r.path("/get")
            .uri("http://httpbin.org"))
        .build();
    //@formatter:on
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

使用任何一种以上方法，Spring Cloud Gateway 都可以在不停机的情况下更改路由配置，并且无需重启服务。这使得管理大量路由变得更加灵活和容易。

3.2 如何使用DiscoveryClient进行路由？

在Spring Cloud生态中，DiscoveryClient接口为应用程序提供了从服务发现机制中获取所有注册服务详细信息的能力。服务发现机制可以是Eureka、Consul、Zookeeper等。通过DiscoveryClient，你可以实现基于服务发现的动态路由，确保请求转发到正确的服务实例。

以下是使用DiscoveryClient进行路由的基本步骤：

  1. 添加服务发现客户端依赖：

根据你使用的服务发现机制，添加相应的Spring Cloud Starter依赖。例如，如果你使用的是Eureka，则添加：

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

  • 1
  • 2
  • 3
  • 4
  1. 启用服务发现客户端：

通过在应用的主类上添加@EnableDiscoveryClient（或者@EnableEurekaClient如果是Eureka）注解启用服务发现客户端。

@SpringBootApplication
@EnableDiscoveryClient
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  1. 配置应用使用服务发现：

确保application.yml或application.properties中配置了服务发现客户端。以下是使用Eureka时的配置例子。

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

  • 1
  • 2
  • 3
  • 4
  1. 注入DiscoveryClient：

在你的代码中注入DiscoveryClient，以便获取服务实例。

@RestController
public class ServiceInstanceRestController {

    @Autowired
    private DiscoveryClient discoveryClient;

    public String serviceUrl() {
        List<ServiceInstance> list = discoveryClient.getInstances("STORES");
        if (list != null && list.size() > 0 ) {
            // 这里只是个例子。实际应用中可能需要更复杂的负载均衡逻辑
            return list.get(0).getUri().toString();
        }
        return null;
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  1. 创建路由：

现在你可以使用DiscoveryClient提供的服务实例信息来创建自定义的路由逻辑。对于入站请求，可以根据服务名对请求做动态路由处理。

@GetMapping("/route-to/{applicationName}")
public String routeToService(@PathVariable String applicationName) {
    List<ServiceInstance> instances = discoveryClient.getInstances(applicationName);
    if (instances.isEmpty()) {
        return "No instances available for " + applicationName;
    }
    // Perform load-balancing with the available instances and create a route
    URI serviceUri = instances.get(0).getUri();
    // Here, for example, we just forwards the request to the first instance
    return "Routing to " + serviceUri;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

这只是一种非常简单的路由逻辑示例，实际情况应该使用更复杂的负载均衡策略。Spring Cloud有一些工具可以帮助简化这个过程，比如Netflix Ribbon可以提供客户端负载均衡，Spring Cloud Gateway可以提供更高级的路由功能。

需要注意的是，直接使用DiscoveryClient进行路由，意味着你将需要编写更多的手动代码来处理请求转发、错误处理、重试逻辑等。现代的API网关（例如Spring Cloud Gateway）或者已集成负载均衡的客户端（例如Feign）会是更好的选择，因为它们提供了封装良好的高级功能来管理这些问题。

3.3 Spring Cloud Gateway中Route Locator是什么？

在 Spring Cloud Gateway 中，RouteLocator 是一个接口，负责定义和创建路由信息。每个路由都包含有识别请求并将其转发到正确目的地的逻辑。RouteLocator 最终提供一组 Route 对象，这些对象包含了路由ID、目标URI、一组断言（Predicates）和一组过滤器（Filters）。

路由断言用于判断请求是否匹配该路由。例如，你可以基于请求路径、请求头信息、请求参数等构建断言。如果一个请求满足路由的所有断言条件，那么它将被该路由处理。

过滤器可用于修改请求和响应。它们在断言确定请求匹配某个路由后执行，允许开发者在请求到达目标服务之前或从目标服务返回给客户端之前修改请求或响应。

在 Spring Cloud Gateway 中配置路由可以通过两种主要方式：

  1. 声明式配置：
    在配置文件（例如 application.yml 或 application.properties）中声明路由规则。

  2. 编程式配置:
    在 Java 代码中通过 RouteLocatorBuilder 构建器创建一个 RouteLocator Bean。在该 Bean 中，你可以使用流式 API 来自定义路由规则。

下面是一个使用 Java 编程式配置 RouteLocator 的简单示例：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route(r -> r.path("/user/**") // 匹配请求路径
            .uri("lb://user-service") // 转发请求地址，使用负载均衡器（lb）将请求转发到注册了的user-service服务
            .id("user-service-route")) // 路由ID
        .route(r -> r.host("*.widget.com") // 匹配请求域名
            .uri("http://widgets.com") // 转发请求地址
            .id("widget-route")) // 路由ID
        .build();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

在这个例子中，定义了两个路由，并为其设置了匹配条件。第一个路由将所有匹配 /user/** 路径的请求转发到 user-service，该服务已经注册到了服务发现系统中。第二个路由将所有来自 *.widget.com 域的请求转发到了 http://widgets.com。

通过编程式配置 RouteLocator，开发人员可以更灵活地定义路由逻辑，比如可以在运行时动态地添加、删除或修改路由规则。这在处理复杂的路由需求或要求动态路由改变的场景下非常有用。

3.4 如何结合配置中心实现路由动态刷新？

在微服务架构中，配合配置中心实现路由动态刷新允许你在不中断服务的情况下，实时更新路由配置。以下是结合 Spring Cloud Config 配置中心来实现 Spring Cloud Gateway 路由动态刷新的步骤：

1. 配置 Spring Cloud Config Server

首先，需要设置并启动 Spring Cloud Config Server。你需要指定配置文件的仓库位置，比如 Git URL。

@EnableConfigServer
@SpringBootApplication
public class ConfigServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

并在 application.yml 文件中配置版本控制信息：

spring:
  cloud:
    config:
      server:
        git:
          uri: https://path-to-your-git-repository
          clone-on-start: true

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2. 设置 Spring Cloud Gateway 配置

在网关服务的 bootstrap.yml 或 bootstrap.properties 配置文件中，添加对 Config Server 的引用，并将网关应用程序与 Config Server 连接：

spring:
  application:
    name: gateway
  cloud:
    config:
      uri: http://localhost:8888

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

这里 spring.cloud.config.uri 指向你已经设置并启动的 Config Server。

3. 在 Config 配置文件中定义路由

在配置中心所管理的配置仓库中，为你的网关服务定义或更新路由配置，例如 gateway.yml 文件：

spring:
  cloud:
    gateway:
      routes:
        - id: myservice
          uri: lb://MY-SERVICE      # 使用服务发现中的服务ID
          predicates:
            - Path=/my-service/**  # 路由匹配逻辑
          filters:
            - AddRequestHeader=X-Request-Color, Blue

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

4. 使 Spring Cloud Gateway 感知配置变化

在网关的主类中增加 @RefreshScope 注解，这使得你可以触发 /actuator/refresh 端点来刷新配置：

@RefreshScope
@SpringBootApplication
public class GatewayApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

并确保依赖了 spring-boot-starter-actuator，以便暴露 /actuator/refresh 端点。

5. 动态刷新路由

当你更新了配置中心中的路由配置后，可以通过发送 HTTP POST 请求到网关的 /actuator/refresh 端点来刷新配置。请求成功响应后，Spring Cloud Gateway 将重新加载新的路由配置。

curl -X POST http://localhost:8080/actuator/refresh

  • 1

6.（可选）使用 Spring Cloud Bus 自动化刷新

如果你的系统中有多个实例需要同时刷新配置，可以使用 Spring Cloud Bus 来广播 refresh 事件。配合消息中间件（如 RabbitMQ 或 Apache Kafka），当 Config Server 的配置发生变化时，Spring Cloud Bus 会自动触发所有服务实例的 /actuator/refresh 端点。

注意事项

当前版本的 Spring Cloud Config Server 在使用文件系统（native profile）时不支持监测文件变化自动刷新配置，但可以在 git 等版本控制系统中实现这一功能。对于跨越多个服务的配置更改，建议使用 Spring Cloud Bus 来自动触发刷新。在生产环境中，确保访问 /actuator/refresh 端点的操作是安全和有控制的，避免未授权的刷新操作。

4. 安全和认证

4.1 如何在Spring Cloud Gateway中实现OAuth2认证？

在Spring Cloud Gateway中实现OAuth2认证通常涉及整合Spring Security以提供标准的认证和授权机制。通过使用Spring Security的OAuth2资源服务器支持，你可以要求所有经过Gateway的请求都必须通过OAuth2令牌进行验证。以下是实现OAuth2认证的步骤：

1. 添加依赖

首先，将Spring Security OAuth2资源服务器的依赖添加到你的项目中。如果使用Maven，添加以下依赖：

<dependencies>
    <!-- 添加 Spring Cloud Gateway 和 Spring Security 依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
</dependencies>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

如果使用的是Gradle，则在build.gradle文件中添加相应的依赖。

2. 配置资源服务器

在Spring Boot应用中，配置一个资源服务器，这个资源服务器将负责检查传入的OAuth2令牌。这通常在一个配置类中完成，这个配置类标注@EnableWebFluxSecurity和@EnableReactiveMethodSecurity。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableReactiveMethodSecurity;
import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
import org.springframework.security.config.web.server.ServerHttpSecurity;
import org.springframework.security.oauth2.jwt.ReactiveJwtDecoder;
import org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder;
import org.springframework.security.web.server.SecurityWebFilterChain;

@Configuration
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
public class ResourceServerConfig {

    @Bean
    public ReactiveJwtDecoder jwtDecoder() {
        return NimbusReactiveJwtDecoder.withJwkSetUri("https://idp.example.com/.well-known/jwks.json").build();
    }

    @Bean
    public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
        http
            .csrf().disable()
            .authorizeExchange()
                .pathMatchers("/actuator/**").permitAll()
                .anyExchange().authenticated()
                .and()
                .oauth2ResourceServer()
                .jwt();
        return http.build();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

在上面的配置中，我们使用了JWT解码器(ReactiveJwtDecoder)来验证签名和令牌的有效性。以及指定了JWK Set URI。这个URI是你的ID提供者（如Auth0、Okta、Keycloak等）公开的地址，包含用于验证JWT签名的公钥信息。

3. 使用JWT令牌验证

设置JWT令牌验证后，Spring Security会自动验证HTTP请求头中的Authorization值（通常是"Bearer 令牌"）。如果令牌有效且授权正确，请求就可以访问对应的资源；否则，Spring Security会返回一个错误（通常是401 Unauthorized）。

4. 配置OAuth2 Scope

在你的安全配置中，你还可以指定OAuth2中的特定范围(scope)，进一步限制对特定资源的访问。

注意事项

进行OAuth2集成和配置时，还需要确保你的OAuth2提供者（如认证服务器）已经正确地设置，并且已经定义了所有必要的客户端和范围。还要确保你的应用配置中已经包含了正确的提供者详情，如发行人URI和JWK Set URI。

通过这些步骤，Spring Cloud Gateway就能够验证通过Gateway的请求是否具有有效的OAuth2令牌，从而为微服务架构中的资源访问提供了安全保障。

4.2 Spring Cloud Gateway如何进行权限控制？

在Spring Cloud Gateway中整合JWT（JSON Web Tokens）涉及到在请求处理流程中添加一个自定义的全局过滤器，该过滤器将负责校验和解析JWT。以下是在Spring Cloud Gateway中整合JWT的基本步骤：

  1. 添加JWT库依赖：
    你需要添加一个能够处理JWT的库到你项目的依赖中。一个流行的Java库是java-jwt，它提供了解码和验证JWT的功能。

    在pom.xml添加依赖：

    <dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>VERSION</version>
</dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

  2. 创建自定义Filter：
    创建一个GlobalFilter的实现，用于拦截所有请求并校验JWT。

    @Component
public class JwtAuthenticationFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        
        // 校验并解析JWT
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            
            try {
                // 使用JWT库来验证token
                DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret"))
                         .withIssuer("issuer")
                         .build()
                         .verify(token);
            } catch (JWTVerificationException e) {
                // token验证失败，我们可以拒绝访问。
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
        }
        
        // 如果JWT校验没有通过，就提前结束请求处理
        return chain.filter(exchange);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

  3. 配置JWT Filter：
    将你的自定义JWT过滤器以Bean的形式注册到Spring上下文中，或者直接使用@Cmmonent注解将其声明为组件。

  4. 处理请求：
    当一个HTTP请求被发送到Gateway时，它将会通过此过滤器。过滤器将会检查请求的Authorization头部来找到JWT，并使用预定义的规则（如密钥和发布者）对其进行验证。

  5. 异常处理：
    如果JWT无效，比如过期或签名不匹配，过滤器将返回HTTP 401 Unauthorized状态。这避免了请求进一步发送到下游服务。

  6. 转发请求：
    如果JWT校验成功，请求则会继续按照定义的路由规则流转到下游服务。

这个基本的流程实现了一个简单的JWT校验机制。在两个关键点进行了校验：首先在Gateway层阻止了无效的JWT请求，并确保下游的每个服务不需要处理JWT验证逻辑；其次可以选择性地将解析出来的身份证明信息添加到请求头部，以便下游服务可以获取用户的身份信息。

整合JWT时，我们需要确保考虑到所有的安全方面，比如HTTPS用于通信，合适的密钥管理和误差时间的处理等。此外，根据具体情况，可能还需要实现更多的安全逻辑，如刷新令牌（Refresh Tokens）或动态密钥解析等。

4.3 如何在Spring Cloud Gateway中整合JWT？

在Spring Cloud Gateway中整合JWT（JSON Web Tokens）涉及到在请求处理流程中添加一个自定义的全局过滤器，该过滤器将负责校验和解析JWT。以下是在Spring Cloud Gateway中整合JWT的基本步骤：

  1. 添加JWT库依赖：
    你需要添加一个能够处理JWT的库到你项目的依赖中。一个流行的Java库是java-jwt，它提供了解码和验证JWT的功能。

    在pom.xml添加依赖：

    <dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>VERSION</version>
</dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

  2. 创建自定义Filter：
    创建一个GlobalFilter的实现，用于拦截所有请求并校验JWT。

    @Component
public class JwtAuthenticationFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
        
        // 校验并解析JWT
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            
            try {
                // 使用JWT库来验证token
                DecodedJWT jwt = JWT.require(Algorithm.HMAC256("secret"))
                         .withIssuer("issuer")
                         .build()
                         .verify(token);
            } catch (JWTVerificationException e) {
                // token验证失败，我们可以拒绝访问。
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
        }
        
        // 如果JWT校验没有通过，就提前结束请求处理
        return chain.filter(exchange);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

  3. 配置JWT Filter：
    将你的自定义JWT过滤器以Bean的形式注册到Spring上下文中，或者直接使用@Cmmonent注解将其声明为组件。

  4. 处理请求：
    当一个HTTP请求被发送到Gateway时，它将会通过此过滤器。过滤器将会检查请求的Authorization头部来找到JWT，并使用预定义的规则（如密钥和发布者）对其进行验证。

  5. 异常处理：
    如果JWT无效，比如过期或签名不匹配，过滤器将返回HTTP 401 Unauthorized状态。这避免了请求进一步发送到下游服务。

  6. 转发请求：
    如果JWT校验成功，请求则会继续按照定义的路由规则流转到下游服务。

这个基本的流程实现了一个简单的JWT校验机制。在两个关键点进行了校验：首先在Gateway层阻止了无效的JWT请求，并确保下游的每个服务不需要处理JWT验证逻辑；其次可以选择性地将解析出来的身份证明信息添加到请求头部，以便下游服务可以获取用户的身份信息。

整合JWT时，我们需要确保考虑到所有的安全方面，比如HTTPS用于通信，合适的密钥管理和误差时间的处理等。此外，根据具体情况，可能还需要实现更多的安全逻辑，如刷新令牌（Refresh Tokens）或动态密钥解析等。

4.4 Spring Cloud Gateway中的跨域配置是如何实现的？

在Spring Cloud Gateway中，跨域配置可以通过定义一个特定路由的跨域资源共享（CORS）配置来实现。当浏览器执行跨站点HTTP请求时，CORS配置允许你指定哪些来源可以访问资源、哪些HTTP方法和头部被允许，以及其他安全相关的设置。

以下是在Spring Cloud Gateway中配置CORS的基本步骤：

  1. 添加路由CORS配置：

在你的路由配置中，可以为每个路由设置特定的CORS配置。这是在Java配置代码中通过RouteLocatorBuilder实现的一个示例：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
            .route(r -> r.path("/api/service/**")
                .filters(f -> f.cors(c -> c.allowedOrigins("http://allowed-origin.com")
                                           .allowedMethods("GET", "POST")
                                           .allowedHeaders("X-Custom-Header")
                                           .exposedHeaders("X-Response-Header")
                                           .allowCredentials(true)))
                .uri("http://backend-service")
            )
            .build();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

在这个例子中，对于匹配/api/service/**路径的请求，设置了CORS策略：

  • allowedOrigins定义了允许的来源列表。
  • allowedMethods定义了允许的HTTP请求方法。
  • allowedHeaders指定了允许的HTTP请求头。
  • exposedHeaders指定了允许暴露给浏览器的响应头。
  • allowCredentials定义了是否允许携带证书（如Cookies）。
  1. 全局CORS配置：

如果你需要为所有的路由应用同一CORS策略，可以定义一个全局的CORS配置。这可以在application.yml或application.properties文件中完成，或者通过配置一个WebFilter来实现：

@Bean
public CorsWebFilter corsWebFilter() {
    CorsConfiguration config = new CorsConfiguration();
    config.setAllowCredentials(true);
    config.addAllowedOrigin("*");
    config.addAllowedMethod("*");
    config.addAllowedHeader("*");
    config.addExposedHeader("X-Response-Header");
    config.setMaxAge(3600L); // 设置预检请求的有效期

    UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
    source.registerCorsConfiguration("/**", config);

    return new CorsWebFilter(source);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

以上两种方法都可以实现Spring Cloud Gateway中的CORS配置，但请注意，通常不推荐在生产环境中将所有来源（*）设置为允许，这可能会带来安全风险。你应当尽量指定明确的允许来源。

为了测试和应用CORS策略，你可能需要清除浏览器缓存或使用不同的测试工具（如Postman，CURL等），因为浏览器会缓存CORS的预检请求（preflight request）的结果。

CORS配置是浏览器安全策略的一部分，旨在防止CSRF（Cross-Site Request Forgery）攻击。因此，在配置CORS时，务必慎重考虑允许的来源和方法，确保既满足跨域访问需求，又不降低应用的安全性。

5. 性能和压力测试

5.1 如何评估Spring Cloud Gateway的性能？

评估 Spring Cloud Gateway 的性能涉及到测试和监控网关在处理请求时的各项指标，包括延迟、吞吐量、资源使用和错误率等。以下是评估性能的几个重要步骤：

压力测试和基准测试

使用压力测试工具，如 JMeter、Gatling、Ab（ApacheBench）或 wrk，对 Spring Cloud Gateway 进行测试。进行压力测试时，你需要：

  1. 定义测试场景：确定你想模拟的请求模式，包括请求的类型、payload 大小、请求间隔等。

  2. 设定测试参数：配置并发用户数、请求速率、测试持续时间等参数。

  3. 执行压力测试：在足够长的时间跨度内运行测试，同时逐步增加流量，直到找到断点。

  4. 监控资源使用：监控测试过程中的资源使用情况，包括 CPU、内存、磁盘 IO 和网络使用情况。

  5. 收集测试结果：记录每种测试场景的平均响应时间、请求处理速率（QPS）、成功和错误响应的比例。

实时监控和诊断

配置适当的监控工具，如 Prometheus 和 Grafana，或其他 APM 工具，如 New Relic、Dynatrace、Datadog 等，对网关的性能指标进行实时监控。重点监控以下指标：

  1. 响应时间：成功响应客户端请求所需的时间。

  2. 路由延迟：处理和转发请求到下游服务的时间。

  3. 吞吐量：单位时间内网关可以处理的请求数。

  4. 并发连接数：网关同时处理的连接数。

  5. 系统资源使用情况：CPU 使用率、内存消耗、GC（垃圾收集）次数和耗时。

  6. 错误率：请求失败的比率，这可能包括网络问题、下游服务失败或配置错误造成的问题。

性能优化

根据压力测试和实时监控的结果，进行性能优化。这可能涉及到：

  1. 调优线程池：根据系统能力和测试结果优化线程池大小。

  2. 优化路由配置：简化路由条件和过滤器链，删除不必要的过滤器。

  3. 增强硬件资源：如果发现网关因资源不足而性能受限，可以考虑增加更多的 CPU 或内存资源。

  4. 调整 JVM 参数：基于应用性能和资源使用情况调整 JVM 相关参数，如堆大小、GC 策略等。

  5. 分布式部署：在多个服务器或容器中部署 Spring Cloud Gateway 实例，以实现负载均衡和更高的容错能力。

  6. 使用缓存：如果可能和适用，增加缓存策略来减少对后端服务的冗余请求。

  7. 采用非阻塞 I/O：Spring Cloud Gateway 基于 WebFlux，已经是非阻塞的，确保下游服务也能以非阻塞方式操作，最大化性能。

进行性能评估和优化是一个持续的过程，往往需要基于不断变化的系统负载和业务需求调整。通过反复测试和系统调整，可以确保 Spring Cloud Gateway 中性能指标得到优化，从而满足你的应用需求。

5.2 在高并发下，Spring Cloud Gateway需要哪些性能优化？

在高并发环境下，为了提高 Spring Cloud Gateway 的性能和系统资源利用率，可能需要实施一系列针对性的优化措施。以下是针对 Spring Cloud Gateway 在面对高并发流量时的一些性能优化建议：

1. 资源和配置优化

  • 调整实例大小和数量：根据负载需求，适当调整 gateway 实例的大小（CPU, 内存）和数量（横向扩展）。
  • 限制并发线程数：网关背后使用的 Web 容器（如 Netty）的线程模型决定了资源分配。可以通过调整如 reactor.netty.ioWorkerCount 的参数来配置 Event Loop 线程的数量。

2. 限流和熔断

  • 启用限流：防止过载和拒绝服务（DoS）攻击，使用 Request Rate Limiter 等限流插件限制每秒处理的请求数。
  • 熔断与回退：对下游服务调用添加断路器，以保护系统在高负载下的稳定性，并为异常提供回退逻辑。

3. 负载均衡

  • 使用云服务负载均衡器：在多个 gateway 实例之前使用云服务商的负载均衡器，如 AWS ELB 或 Azure Load Balancer。
  • 优化负载均衡策略：利用 Ribbon、Reactor Load Balancer 等对负载均衡策略进行设计和优化。

4. 异步和非阻塞

  • 异步处理：网关中的过滤器和路由应使用异步非阻塞 API，避免长时间占用线程和响应延迟。
  • 提高下游服务性能：确保下游服务（如微服务实例）也能够支持非阻塞和高性能处理，以免成为瓶颈。

5. 缓存优化

  • 响应缓存：对静态资源和可缓存的 API 响应使用缓存，减少对下游服务的请求次数。
  • Gateway 路由缓存：为常用的路由规则和路径启用缓存，减少正则表达式等计算开销。

6. 网络优化

  • 合理配置超时：针对下游服务调整连接和响应超时设置，以避免资源无谓的占用。
  • 调整 TCP 参数：优化相关的 TCP/IP 栈参数，如最大并发连接数、keep-alive 设置等，来提高网络性能。

7. 监控和诊断

  • 实时监控：使用 Micrometer、Prometheus、Grafana 等工具监控网关的性能指标，及时响应潜在问题。
  • 日志和跟踪：勒索记录详细日志，并整合 Zipkin、Sleuth 等进行分布式跟踪，方便故障排查和性能分析。

8. 代码和依赖关系优化

  • 代码审查：对自定义过滤器和路由代码进行审查，移除不必要的逻辑和资源密集型操作。
  • 减少依赖：尽量减少对不必要组件的依赖，避免过度的技术栈负担。

高并发环境下的优化是一个持续过程，应根据流量模式和系统表现不断调整配置和资源，确保最优的服务质量。所有优化措施应在测试环境进行充分测试和评估，以验证其对性能的影响，确保不会对业务功能造成负面影响。

5.3 Spring Cloud Gateway的反压力机制是什么？

Spring Cloud Gateway 的反压力（backpressure）机制是基于反应式编程模型，尤其是使用了 Project Reactor 框架来处理请求和响应流。反压力是响应式流（Reactive Streams）规范的核心概念之一，允许消费者（subscriber）控制数据流的速率，确保它不会被快速生产者（publisher）淹没。

在Spring Cloud Gateway中，反压力通过以下几种方式实现：

1. 限流（Rate Limiting）

Spring Cloud Gateway 可以集成限流库，如 Resilience4j 或 RequestRateLimiter GatewayFilter 的功能，来限制对API的调用速率。这些限流机制可以基于多种策略，比如根据来源IP、用户、请求路径等来制定限制。

2. 背压控制（Backpressure Control）

由于Spring Cloud Gateway基于WebFlux，它内部使用了响应式流来处理请求。Reactor提供的Flux和Mono类型在处理元素时内置背压支持。这意味着当下游服务无法处理更多的请求时，可以通过请求更少的数据来通知生产者减慢发送的速率。

3. 可配置的请求超时

Spring Cloud Gateway 允许你配置路由的请求超时时间。这可以防止系统中的一些慢响应调用消耗过多资源并影响整体性能。

4. 消息大小限制

Spring Cloud Gateway 允许限制请求和响应的大小，超过最大值的将被拒绝，并向客户端返回合适的HTTP状态码。这样可以防止大型请求淹没系统。

5. 响应式编程模型

Spring Cloud Gateway 的反应式编程模型可以自然地为请求处理提供弹性。例如，如果一个服务实例变得缓慢或不响应，Gateway可以通过响应式流的操作符来实现超时、重试或转发到备用实例。

总之，Spring Cloud Gateway 的反压力机制通过集成的限流策略和响应式编程原则来控制数据流，以防止系统过载。由于基于响应式流，这些机制可以比较优雅地处理大量并发请求，并提供了一种更加可扩展和可控的方法来维护API网关的性能和稳定性。如果进行微调配置，这些机制也可以帮助提高系统资源的合理利用。

5.4 如何在Spring Cloud Gateway中限制请求率？

在Spring Cloud Gateway中可以使用请求限流（Rate Limiting）来限制访问频率，以减轻后端服务的压力并防止过多的请求达到微服务，甚至防御某种程度的分布式拒绝服务攻击（DDoS）。Spring Cloud Gateway可以集成与 RequestRateLimiter GatewayFilter 工厂配合特定的限流算法。以下是如何配置的详细步骤：

1. 添加Redis限流依赖

Spring Cloud Gateway集成了Redis来允许分布式限流。因此，确保你的项目已经添加了对Spring Data Redis Reactive的依赖：

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

  • 1
  • 2
  • 3
  • 4

2. 配置限流规则

在Spring Cloud Gateway中配置限流规则通常是在 application.yml 或 application.properties 文件中定义：

spring:
  cloud:
    gateway:
      routes:
        - id: example-service
          uri: http://example.org
          predicates:
            - Path=/service/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
                key-resolver: "#{@userKeyResolver}"

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

在上面的配置中：

  • replenishRate 是用户在一个时间单位内恢复的令牌数，这里设置为每秒10个请求。
  • burstCapacity 是令牌桶的容量，它决定了在一秒钟内最多允许的请求数，这里设置为20个。
  • key-resolver 是Spring Bean名称引用，用于确定用户的唯一标识符，如用户的IP地址或身份标识，对此我们需要创建对应的Key Resolver Bean。

3. 实现Key Resolver

实现 KeyResolver 接口定义的 Bean，它将决定如何从每个请求中获取限流的键值（用户标识）。例如，您可以使用用户的 IP 地址作为限流键值：

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import reactor.core.publisher.Mono;
import org.springframework.web.server.ServerWebExchange;

@Configuration
public class RateLimiterConfig {
    @Bean(value = "userKeyResolver")
    KeyResolver userKeyResolver() {
        return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

4. 配置Redis

确保你的Redis服务器已经运行，并在 application.yml 或 application.properties 中配置了Redis的连接信息。

spring:
  redis:
    host: localhost
    port: 6379

  • 1
  • 2
  • 3
  • 4

确保Redis Server与你的Spring Cloud Gateway实例网络互通。

5. 自定义限流响应

如果你希望自定义限流导致的拒绝请求的返回内容，你可以编写一个自定义的 GatewayFilter：

import org.springframework.cloud.gateway.support.HttpStatusHolder;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.web.server.ServerWebExchange;

@Bean
public GatewayFilter customRateLimiterFilter(RedisRateLimiter rateLimiter, KeyResolver resolver) {
    return (exchange, chain) -> resolver.resolve(exchange).flatMap(key ->
        rateLimiter.isAllowed(routeId, key).flatMap(response -> {
            if (response.isAllowed()) {
                return chain.filter(exchange);
            }
            // Here you can provide a custom response
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }));
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

以上步骤配置了Spring Cloud Gateway以使用Redis限流器算法。除了使用Spring Data Redis，还有其他方法可以实现限流，比如使用Bucket4j库或自定义过滤器实现。请根据您的具体应用场景和技术栈选择最适合您的解决方案。请注意，在分布式系统中，使用集中式存储（如Redis）为限流提供了更一致的行为。

6. 高可用和容灾

6.1 如何提高Spring Cloud Gateway的可用性？

提高 Spring Cloud Gateway 的可用性关键在于设计弹性架构和实施最佳实践，确保即使在部分系统故障时，依然能够为用户提供服务。以下是一些提高 Spring Cloud Gateway 可用性的策略和建议：

  1. 多实例部署：
    避免单点故障（SPOF），通过在多个服务器或多个区域部署多个 Gateway 实例，可以在一个实例失败时由其他实例接手请求。

  2. 负载均衡：
    使用云提供商的负载均衡器或像Nginx这样的开源负载均衡器来分发流量到多个 Gateway 实例，确保均匀分配流量，和高可用的服务。

  3. 断路器模式：
    在路由到下游服务前，使用 Hystrix、Resilience4J 等断路器库提供的断路器和降级机制，减少单个服务的故障对整体系统的影响。

  4. 超时和重试策略：
    为服务调用配置合理的超时和重试策略，确保故障重试不会导致系统资源耗尽。

  5. 持续监控与健康检查：
    调用Actuator端点进行持续监控和周期性健康检查，及时发现和响应可能的服务问题。

  6. 动态路由配置：
    使用 Spring Cloud Config Server 等配置服务来动态更改路由配置，减少重启服务和部署延迟。

  7. 集群和编排工具：
    使用 Kubernetes 或 Docker Swarm 等容器编排平台自动管理实例，包括自动重启失败的实例、水平扩展和自我修复。

  8. 部署蓝绿或金丝雀：
    实施蓝绿或金丝雀部署策略，以无中断地更新 Gateway 和其它服务，减少升级时的不稳定性。

  9. 持久化配置状态：
    将路由等配置存储在持久性存储系统中保证在服务重启之后配置不会丢失。

  10. 灾难恢复计划：
    制定详细的灾难恢复计划并定期进行演习，以确保能够快速响应和处理大规模故障。

要实现高可用性需要健全的架构和周到的运维管控，Spring Cloud Gateway 的高可用性不仅来源于自身设计，还依赖于整个基础设施和环境的可靠性和弹性。使用自动化、监控、测试和不断优化，可以进一步增强微服务架构的健壮性。

6.2 在Spring Cloud Gateway中如何实现熔断？

在Spring Cloud Gateway中实现熔断通常是通过集成断路器（如Hystrix或Resilience4J）来实现。这样，当下游服务不可用或反应时间过长时，Gateway可以提供备用的响应方式，从而避免级联故障。Spring Cloud Gateway自身集成了Hystrix来提供熔断器的功能，尽管Hystrix已经进入维护模式，并且Spring Cloud已开始推荐使用Resilience4J。

以下是使用Hystrix在Spring Cloud Gateway中实现熔断的基本步骤：

  1. 添加Hystrix依赖：

    • 如果项目中还没有Hystrix依赖，请添加它：
    <!-- Maven -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

  2. 配置路由与熔断规则：

    • 在路由配置中，使用Hystrix过滤器定义熔断规则：
    @Bean
public RouteLocator routes(RouteLocatorBuilder builder) {
    return builder.routes()
            .route(r -> r.path("/my-service/**")
                    .filters(f -> f.hystrix(config -> config.setName("my-service")
                                                             .setFallbackUri("forward:/fallback")))
                    .uri("lb://MY-SERVICE"))
            .build();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    在这个配置中，对于通过/my-service/**路径访问的请求，熔断器名字设置为my-service。如果请求失败，将使用setFallbackUri指定的备用URI来返回响应。

  3. 添加熔断器的备用逻辑：

    • 创建一个回退的端点，处理熔断时的替代逻辑：
    @RestController
public class FallbackController {
    
    @RequestMapping("/fallback")
    public Mono<String> fallback() {
        return Mono.just("This is a fallback message");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    当/my-service/**的路由失败时，用户将会看到返回的"This is a fallback message"信息。

请注意，Hystrix已经处于维护模式，并不推荐在新的项目中使用。相反，推荐使用Resilience4J作为其替代，它为断路器模式提供了丰富的配置和定制功能。

使用Resilience4j时，你将需要添加其依赖，并使用Spring Cloud CircuitBreaker框架的spring-cloud-starter-circuitbreaker-reactor-resilience4j依赖来集成到Spring Cloud Gateway中。

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder, CircuitBreakerFactory circuitBreakerFactory) {

    final String myCircuitBreakerId = "myCircuitBreakerId";

    return builder.routes()
            .route("my_route", r -> r.path("/my-service/**")
                    .filters(f -> f.circuitBreaker(c -> c.setName(myCircuitBreakerId).setFallbackUri("forward:/fallback")))
                    .uri("lb://MY-SERVICE"))
            .build();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

在这个示例中，我们使用CircuitBreakerFactory来配置断路器，并指定fallback的URI，类似于Hystrix的方式。forward:/fallback表明当断路器打开时，请求将被转发到本地的/fallback端点。这个端点可以定义在Controller中，提供当断路器打开时的替代逻辑。

6.3 Spring Cloud Gateway是否支持集群部署？

是的，Spring Cloud Gateway 支持集群部署。集群部署是云原生和微服务架构的一个关键特性，它增强了应用程序的可伸缩性和可靠性。部署 Spring Cloud Gateway 集群可以帮助在多个实例中分摊流量负载，还可以提供故障隔离和快速恢复。

在集群部署中，每个 Spring Cloud Gateway 的实例都可以处理入站请求，并执行配置好的路由和过滤逻辑。为了实现集群部署，你需要考虑以下几个关键点：

  1. 服务发现和注册:
    Gateway 实例应当注册到服务发现系统中（例如 Eureka、Consul 或 Zookeeper）。这样，每个实例都可以被发现，并且你可以使用内置的负载均衡机制来将请求分发到所有的网关实例。

  2. 负载均衡:
    在网关前使用一个负载均衡器（如 NGINX、HAProxy 或云提供商的负载均衡服务 Amazon ELB、Azure Load Balancer）来将外部流量均等地分发到各个网关实例。

  3. 配置共享:
    确保所有网关实例共享相同的路由和过滤器配置。这可以通过远程配置中心（如 Spring Cloud Config Server）实现，或通过版本控制系统（如 Git）从统一的配置仓库拉取。

  4. 持久化会话:
    如果你需要维护和管理用户会话，在集群环境下可以利用外部存储来持久化会话状态，比如使用 Redis 或数据库。

  5. 高可用性:
    为了确保高可用性，你需要使用足够的网关实例数量，并部署在不同的服务器、虚拟机或容器中。这为了将不同实例的宕机风险隔离，并确保单点故障不会影响整个系统。

  6. 监控和日志:
    在集群环境中，需要有一个中心化的监控和日志系统来聚合和分析来自所有实例的指标和日志信息。

  7. 自动缩放:
    根据流量的变化和系统负载动态添加或移除网关实例。在云环境中，这可以利用如 Kubernetes 的 HPA（Horizontal Pod Autoscaler）或云服务提供商的自动缩放服务来实现。

  8. 统一管理:
    使用像 Kubernetes 这样的容器编排工具，可以方便地部署和管理网关的集群。

通过采用这些策略和做好适当的配置，Spring Cloud Gateway 可以以集群方式部署以支持大规模、高吞吐量的微服务架构。集群部署不仅提高了网关层的稳定性和故障容忍性，还有助于提供更加平稳和可预测的响应时间。

6.4 如何配置Spring Cloud Gateway以支持服务降级？

在 Spring Cloud Gateway 中支持服务降级通常涉及到在路由配置中定义回退逻辑，以在下游服务不可用或响应超时时提供备用响应。这样的配置有助于提高系统的健壮性，确保即使单个服务失败，整个应用也可以继续提供有限的功能。以下是配置 Spring Cloud Gateway 支持服务降级的步骤：

步骤一：定义路由和回退URI

在 Spring Cloud Gateway 的配置文件中（通常是 application.yml 或 application.properties），为需要服务降级的路由指定一个自定义的回退 URI。这个 URI 应该定义一个静态资源、本地端点或另一服务地址，用于在服务降级时返回备用数据。

例如，在 application.yml 中配置：

spring:
  cloud:
    gateway:
      routes:
        - id: myservice_route
          uri: lb://MY-SERVICE  # 假设使用服务发现和负载均衡
          predicates:
            - Path=/myservice/**
          filters:
            - name: CircuitBreaker
              args:
                name: myservice_cb
                fallbackUri: forward:/fallback/myservice

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

步骤二：实现回退端点

在 Gateway 应用中实现一个控制器，以处理在回退 URI 指定的路径上的服务降级请求。

@RestController
public class FallbackController {

    @GetMapping("/fallback/myservice")
    public ResponseEntity<Map<String, String>> myserviceFallback() {
        Map<String, String> response = new HashMap<>();
        response.put("message", "My Service is unavailable. Please try again later.");
        response.put("status", "Service Down");
        return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(response);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

上面代码中定义的 /fallback/myservice 路径是在路由配置中的 fallbackUri 指定的，用于处理 myservice_route 的降级逻辑。

步骤三：引入断路器依赖

确保你已经引入了 Spring Cloud CircuitBreaker 相关的依赖，以便在网关中使用类似断路器的功能。可以添加如下依赖到项目中：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-reactor-resilience4j</artifactId>
</dependency>

  • 1
  • 2
  • 3
  • 4

步骤四：配置断路器规则

可以使用 Resilience4J 来定义断路器的配置规则。Resilience4J 允许你配置断路器的参数，如失败比例、失败计数等。

resilience4j:
  circuitbreaker:
    instances:
      myservice_cb:
        slidingWindowSize: 10
        minimumNumberOfCalls: 5
        permittedNumberOfCallsInHalfOpenState: 3
        automaticTransitionFromOpenToHalfOpenEnabled: true
        waitDurationInOpenState: 5000
        failureRateThreshold: 50
        recordExceptions:
          - org.springframework.web.client.HttpServerErrorException
          - java.io.IOException
          - java.util.concurrent.TimeoutException
          - org.springframework.cloud.gateway.support.TimeoutException

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

步骤五：测试服务降级

一旦配置完成，启动 Spring Cloud Gateway 应用并验证降级逻辑。尝试访问代理的 service，模拟失败情况（如关闭下游服务或设置规则导致断路器打开），确保服务降级正常工作并返回定义的回退响应。

务必记得，服务降级是应对故障的备选方案，不能替代服务的高可用性策略。服务降级配置应根据实际业务需求和系统设计来调优和测试。

7. 监控和日志

7.1 Spring Cloud Gateway支持哪些监控工具？

Spring Cloud Gateway 支持与多种监控工具整合，使得你可以实现对网关以及通过它路由的请求的性能监控和度量。这包括但不限于以下工具：

Actuator 监控端点

Spring Boot Actuator 提供了一系列监控端点，例如 /actuator/gateway 能够显示 Spring Cloud Gateway 的路由信息，/actuator/metrics 能够提供度量信息，/actuator/health 显示健康检查状态等。

Micrometer

Micrometer 是一个应用度量的抽象库，适用于 Spring Boot 应用程序，可以集成多个监控系统的后端，如 Prometheus、Atlas、Datadog、Graphite、New Relic等。

通过 Micrometer，你可以将 Gateway 的度量数据暴露到这些系统中，以实现对请求延迟、失败率、吞吐量等关键性能指标的收集和可视化。

Prometheus

结合上述的 Micrometer 可以轻松地将度量数据推送至 Prometheus，后者是一个强大的开源监控和报警工具集，经常用于云原生应用的监控。

Grafana

Grafana 是一个开源的度量分析和可视化套件。它通常与 Prometheus 结合使用，用于展示收集的度量数据。Grafana 提供丰富的仪表盘定制选项，是展示度量和创建分析图表的理想选择。

Sleuth 和 Zipkin

Spring Cloud Sleuth 可用于追踪，并且可以与 Zipkin 整合。Zipkin 是一个分布式追踪系统，通过 Sleuth 可以在请求经过 Gateway 的每个微服务上报追踪信息到 Zipkin，Zipkin 允许你追踪请求的整个流程，并可视化展示。

Spring Cloud Hystrix

Hystrix 提供了对服务调用的熔断和隔离保护，其仪表盘提供实时监控。尽管如此，当使用 Spring Cloud Gateway 时，通常推荐使用 Resilience4J，它提供了类似的功能和更好的集成性能。

集成 ELK Stack (Elasticsearch, Logstash, Kibana)

ELK Stack 可用于日志处理和收集，使开发者能够通过 Logstash 将日志收集和聚合，存储在 Elasticsearch 中，并最终用 Kibana 可视化和分析日志数据。

以上这些工具可以结合使用，为Spring Cloud Gateway 提供多维度的监控，有助于实现对整个微服务架构可用性、性能和健康状态的有效追踪和监督。在使用时，始终确保合理配置监控系统以避免引入额外的性能开销。

7.2 如何收集和查看Spring Cloud Gateway的日志？

收集和查看Spring Cloud Gateway的日志涉及到日志配置、日志收集工具或服务以及监控和分析工具的使用。以下是具体步骤：

  • 1

1. 配置日志级别

您可以通过配置文件（如application.properties或application.yml）或通过编程方式来设置日志级别，以便收集不同级别的日志信息。

在application.yml中设置日志级别的示例：

logging:
  level:
    # 设置Spring Cloud Gateway的日志级别
    org.springframework.cloud.gateway: DEBUG
    # 如果需要，设置Netty的详细日志级别
    reactor.netty: DEBUG

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

在application.properties中的相应配置：

logging.level.org.springframework.cloud.gateway=DEBUG
logging.level.reactor.netty=DEBUG

  • 1
  • 2

2. 使用日志框架

确保在Spring Cloud Gateway项目中包含了日志框架的依赖，如Logback、Log4j2或SLF4J等。可以通过logback-spring.xml或相应的配置文件来进一步定制日志的行为。

3. 定制日志格式

您可以定制日志输出格式，如包含时间戳、线程信息、日志级别、类名等信息。

4. 将日志写入文件

将日志输出到文件中，可以是本地文件系统或网络文件系统、日志卷等。

logging.file.name=logs/gateway.log
logging.file.path=/path/to/logs

  • 1
  • 2

5. 日志轮转策略

如果使用Logback，可以配置轮转策略以防日志文件占用过多磁盘空间。

6. 集成日志收集工具

集成如Elasticsearch、Logstash和Kibana（ELK栈）、Splunk或Fluentd等日志收集工具，将日志从Spring Cloud Gateway的实例传输到中心日志管理系统。

7. 使用外部监控服务

服务如DataDog、New Relic、Dynatrace等可以集成对日志数据的收集、分析和可视化支持。

8. 查看Gateway日志

使用查看日志的工具，如tail、grep命令行工具，或更复杂的图形界面分析工具。

9. 使用Spring Boot Actuator

通过 Spring Boot Actuator 暴露的 /actuator/gateway/routes 和 /actuator/gateway/globalfilters 端点，可以查看Spring Cloud Gateway中定义的路由和全局过滤器信息。

10. 分布式追踪系统

集成如Zipkin、Jaeger等分布式追踪系统，以跟踪请求在微服务之间的流转情况，Gateways通常在请求头中携带追踪信息。

11. 日志分析

通过日志分析工具对日志数据进行实时分析和告警，确保及时发现问题并作出响应。

确保这些步骤在符合您的监控策略和性能要求的同时执行。另外，要避免在生产应用程序中使用DEBUG或TRACE级别的日志，因为它们会大量增加日志的输出并可能对性能产生影响。考虑在开发和问题解决环境中使用更高的日志级别。

7.3 Spring Cloud Gateway的跟踪日志如何配置？

在 Spring Cloud Gateway 中配置跟踪日志通常涉及两个方面：配置日志级别以及集成分布式跟踪系统（如 Spring Cloud Sleuth 和 Zipkin）。以下是如何配置跟踪日志的步骤：

  1. 配置日志级别：
    在应用的配置文件中（通常是 application.yml 或 application.properties），可以通过指定日志级别来获取更详细的路由和过滤器日志。例如，要增加日志级别：

    logging:
  level:
    org.springframework.cloud.gateway: DEBUG
    reactor.netty.http.client: DEBUG

    • 1
    • 2
    • 3
    • 4

    这将设置 Spring Cloud Gateway 相关类和 Reactor Netty HTTP 客户端的日志记录级别为 DEBUG，已获取网关的更详细调试信息。

  2. 集成 Spring Cloud Sleuth：
    Spring Cloud Sleuth 提供了服务跟踪的功能，它能够为通过 Gateway 的请求添加跟踪信息，用于了解请求在系统中的整个流转路径。

    首先添加 Spring Cloud Sleuth 的依赖：

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

    • 1
    • 2
    • 3
    • 4

    Spring Cloud Sleuth 与 Logback 结合可以自动添加跟踪和跨度ID到日志输出，用于关联请求处理的不同部分。

  3. 集成 Zipkin：
    Zipkin 是一种分布式跟踪系统，可以与 Spring Cloud Sleuth 结合使用，将跟踪数据发送到 Zipkin 服务器用于详细分析。

    添加 Zipkin 依赖：

    <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

    • 1
    • 2
    • 3
    • 4

    然后在配置文件中配置 Zipkin 服务的位置：

    spring:
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
      probability: 1.0  # 设置为1.0表示采样所有请求，根据需求调整

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

  4. 自定义过滤器进行日志记录：
    如果需要捕获特定数据或根据特定条件进行日志记录，可以创建自定义过滤器，在里面添加日志相关的代码。

    import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public class LoggingFilter implements GatewayFilter {
  
    private static final Logger LOGGER = LoggerFactory.getLogger(LoggingFilter.class);

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 在这里添加自定义日志记录
        LOGGER.info("Pre-filter log message");
        return chain.filter(exchange) // 调用下一个过滤器
                 .then(Mono.fromRunnable(() -> {
                    LOGGER.info("Post-filter log message");
                 }));
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

通过适当配置日志和集成分布式跟踪，可以大大提高 Spring Cloud Gateway 服务运行的可见性，帮助开发者和运维人员进行故障排查和性能优化。

7.4 如何集成Spring Cloud Gateway与分布式追踪系统？

集成Spring Cloud Gateway与分布式追踪系统通常涉及以下步骤：

  1. 添加分布式追踪库的依赖：
    在Spring Cloud Gateway项目中，添加Spring Cloud Sleuth的依赖（Sleuth提供了分布式追踪的支持）。
<!-- Maven -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

  • 1
  • 2
  • 3
  • 4
  • 5
  1. 集成追踪系统：
    选择具体的分布式追踪系统，例如Zipkin。你需要添加所选择追踪系统的客户端库依赖。

对于Zipkin，添加如下依赖：

<!-- Maven -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

  • 1
  • 2
  • 3
  • 4
  • 5
  1. 配置追踪系统：
    配置追踪系统的客户端，以连接到追踪服务。如果你使用的是Zipkin，则配置如下：

在application.yml或application.properties中加入：

spring:
  zipkin:
    base-url: http://localhost:9411  # Zipkin服务器地址
  sleuth:
    sampler:
      probability: 1.0  # 采样率 (1.0 为全采样)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  1. 自定义追踪标识：
    可选操作，如果你需要自定义追踪标识或根据业务需求添加额外的追踪信息，可以利用Spring Cloud Sleuth提供的API手动操作。
@Autowired
private Tracer tracer;

public void doSomeWorkSameSpan() {
    // You can also manually code instrumentation
    Span newSpan = this.tracer.nextSpan().name("customSpan").start();
    try (Tracer.SpanInScope ws = this.tracer.withSpan(newSpan.start())) {
        // ...
    }
    finally {
        newSpan.finish();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

这段代码可以在需要的位置添加，newSpan将被链接到主追踪的Trace中。

  1. 请求链路追踪：
    Spring Cloud Sleuth会自动通过HTTP请求的Header添加追踪和跨度信息。这些Header在微服务间的请求中会自动传递，从而实现整个链路的追踪。

通过以上步骤，Spring Cloud Gateway可以将请求通过Sleuth集成到分布式追踪系统中。你将能够在追踪系统的UI中看到跨不同微服务的请求链路。这对于调试、检测服务瓶颈和性能分析十分有用。

若使用的追踪系统不是Zipkin，例如Jaeger或Dynatrace，那么需要相应地更换客户端依赖并配置连接到追踪系统服务。注意每个分布式追踪系统的配置和集成方法可能会略有差异。另外，请确保版本兼容性和服务的网络可访问性。

8. 高级特性和使用技巧

8.1 Spring Cloud Gateway中的Global Filters和GatewayFilters有何不同？

在 Spring Cloud Gateway 中，Gateway 过滤器包括两种类型：Global Filters 和 Gateway Filters。这两种过滤器都可以在请求被路由到下游服务之前或之后对其进行修改，或增加额外的处理逻辑。然而，它们在用途和范围上存在区别：

Global Filters

Global Filters（全局过滤器）是在整个 Gateway 应用的上下文中全局应用的过滤器。这些过滤器会对经过 Gateway 的所有请求和响应起作用，而不需要针对特定的路由进行配置。换句话说，全局过滤器无论你定义了多少路由，它们都会被自动应用到每个路由上。

Global Filters 非常适合用于那些对所有路由都适用的逻辑，比如日志记录、指标收集、认证和授权检查等。

Spring Cloud Gateway 提供了一些内置的 Global Filters，例如 NettyRoutingFilter、LoadBalancerClientFilter、ForwardRoutingFilter 等。

GatewayFilters

与 Global Filters 相对应，GatewayFilters（路由过滤器）是在定义每个路由时配置的过滤器。你可以在路由创建的时候指定一组 GatewayFilters 应用到该路由，它们只会在匹配了该路由的请求上执行。

这种过滤器非常适合执行那些只与特定服务或一组服务相关的任务，例如修改请求路径、添加请求头、修改响应状态码等。

在路由配置中你可以链式添加多个 GatewayFilters，并且可以为不同的路由分配不同的 GatewayFilters。

配置比较

以下是两者在声明式配置中的简单比较：

Global Filters 示范配置（Spring Cloud Gateway 内置实现，不需要在配置文件中明确配置）:

// Global Filters 通常通过实现 GlobalFilter 接口和添加 @Component 注解自动应用
@Component
public class MyGlobalFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 你的全局过滤器逻辑
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

GatewayFilters 示范配置（在 application.yml 或已 Spring Bean 形式配置）:

# application.yml
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          filters:
            - AddRequestHeader=X-Request-Foo, Bar
            - PrefixPath=/api

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

或者以编程方式配置路由和过滤器：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("user-service",
            r -> r.path("/user/**")
                .filters(f -> f.addRequestHeader("X-Request-Foo", "Bar")
                                 .prefixPath("/api"))
                .uri("lb://user-service"))
        .build();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

这个例子中，AddRequestHeader 和 PrefixPath 是 GatewayFilters，它们只会应用到 user-service 这条路由上。

总结来说，Global Filters 适用于所有的请求和响应，而 GatewayFilters 仅适用于特定的路由。开发者可以根据实际的业务和技术需求选择在 Spring Cloud Gateway 中使用 Global Filters 和 GatewayFilters。

8.2 如何优雅地关闭Spring Cloud Gateway实例？

为了优雅地关闭 Spring Cloud Gateway 实例，以避免在关闭过程中造成请求丢失或处理不当，可以按照如下步骤操作：

1. 在配置中启用优雅关闭

Spring Boot 2.3 及更高版本提供了优雅关闭的支持。在你的 application.properties 或 application.yml 文件中配置 Spring Boot 的优雅关闭功能：

# application.yml
server:
  shutdown: graceful
spring:
  lifecycle:
    timeout-per-shutdown-phase: 20s

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

上面的配置中，server.shutdown 设置为 graceful 来启用优雅关闭，spring.lifecycle.timeout-per-shutdown-phase 定义了每个关闭阶段的超时时间。

2. 使用 Actuator Endpoint

确保在你的项目中包含了 Actuator 相关依赖，这样就可以使用 Shutdown Endpoint：

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

  • 1
  • 2
  • 3
  • 4
  • 5

并在配置文件中启用 Shutdown Endpoint：

management:
  endpoints:
    web:
      exposure:
        include: shutdown

  • 1
  • 2
  • 3
  • 4
  • 5

3. 注册实例于服务发现

如果你的 Gateway 实例是通过服务发现（例如 Eureka）注册的，应当在关闭实例之前从服务注册中心取消注册，避免在关闭期间有新的请求被发送到实例。

如果你使用的是 Eureka，可以配置如下参数来确保实例在关闭时快速从 Eureka 注册中心下线：

eureka:
  instance:
    lease-expiration-duration-in-seconds: 1
    lease-renewal-interval-in-seconds: 10

  • 1
  • 2
  • 3
  • 4

4. 发起优雅关闭

关闭应用前，可以发送一个 HTTP POST 请求到 Actuator 的 Shutdown Endpoint：

curl -X POST http://localhost:8080/actuator/shutdown

  • 1

Shutdown Endpoint 会触发 Spring 容器的关闭，同时 Spring Boot 的优雅关闭配置会确保当前正在处理的请求能够完成，然后才真正停止服务实例。

5. 关闭时注意负载均衡

在进行关闭时，需要确保负载均衡器不会再向即将关闭的实例发送新的请求。根据所使用的云服务或负载均衡器不同，可能需要在其控制面板手动下线实例，或配置相应的规则自动化处理实例的加入和移除。

注意

优雅关闭是指当要关闭服务器时，服务器将停止接收新的请求，但会继续处理正在执行的请求，直到所有请求都处理完毕，或者达到配置的超时时间。这样可以最大程度减少服务关闭对用户和后端服务的影响。

在短暂的关闭窗口期内，对服务质量的影响可能依然存在，比如，负载高时请求可能会被重新路由到其他实例，这可能会导致短时间的性能影响。因此，关闭服务实例的操作应在系统负载较低时进行，并且结合监控工具确认关闭过程按预期进行。

8.3 WebSocket在Spring Cloud Gateway中是如何支持的？

Spring Cloud Gateway 支持将 WebSocket 流量路由到后端服务，这种支持是建立在WebFlux基础之上的，使用了Spring框架对WebSocket的原生支持。WebSocket协议允许在客户端和服务器之间建立一个持久的双向连接，以实现更快的数据交换。

Spring Cloud Gateway中的WebSocket支持通常涉及以下几个方面：

1. 路由定义

在Spring Cloud Gateway中，你需要在路由定义中包含WebSocket的URI，此过程与为HTTP路由配置路由类似。以下是一个简单的配置示例，该示例在配置文件中设置了WebSocket路由：

spring:
  cloud:
    gateway:
      routes:
        - id: websocket_route
          uri: ws://backend-websocket-service  # WebSocket服务的URI
          predicates:
            - Path=/ws-path

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

上面的配置定义了一个路由ID为websocket_route的路由，当请求路径匹配/ws-path时，请求会被路由至后端定义的WebSocket服务。

2. 透明转发

Spring Cloud Gateway 能够透明地代理 WebSocket 连接，它将客户端的 WebSocket 连接请求转发到配置的后端服务。Gateway处理连接升级请求，并维护与后端WebSocket服务的连接。

3. 运行时处理

Spring Cloud Gateway 使用Reactor Netty作为底层网络库，该网络库提供了必要的基础支持，例如处理TCP连接和WebSocket握手。在客户端与Gateway之间的WebSocket会话期间，Gateway 会处理所有入站和出站的Websocket数据帧，并将它们转发到后端服务。

4. 与服务发现集成

当与Eureka或Consul等服务发现工具集成时，WebSocket流量也可以通过服务发现机制来路由至对应的服务实例。

注意事项

  • 保证后端WebSocket服务的性能和稳定性是关键，因为任何后端的延迟或断开连接都会直接影响客户端。
  • 考虑WebSocket连接的安全性，如不同级别的认证和授权。
  • 监控WebSocket连接的资源使用情况，避免过度消耗服务器资源。

通过以上方式，Spring Cloud Gateway 提供了对WebSocket流量的初始支持，并能够在Spring驱动的微服务架构中实现对实时通信的代理和路由。这使得开发者能够构建响应迅速、交互性强的应用程序，而不必担心WebSocket通信的复杂性。

8.4 Spring Cloud Gateway有哪些流量控制和管理的策略？

Spring Cloud Gateway 提供了一系列流量控制和管理的策略，这些策略允许微服务架构中的网关对请求做出更紧密的管理并提供更好的服务质量。以下是一些核心的流量控制和管理策略:

  1. 请求限流（Rate Limiting）:
    使用 RequestRateLimiter 过滤器，结合 Redis 或其他存储，可以限制给定时间内允许通过的请求数量。这有助于保护资源免受过高负载和潜在的拒绝服务攻击。

  2. 断路器（Circuit Breaker）:
    通过集成与服务间调用的断路器，例如通过与 Resilience4j 库的结合，可以为服务调用提供熔断保护，当下游服务不稳定或失败时启动备用逻辑。

  3. 重试机制:
    配置重试过滤器，可以在下游服务调用失败时自动重试。重试策略可以根据状态码、HTTP方法和异常类型进行详细配置。

  4. 负载均衡:
    与服务发现结合（例如使用 Eureka），网关可以用负载均衡策略将请求分配到多个服务实例。这些策略可以是基于轮询、随机选择、响应时间或哈希值。

  5. 路由断言:
    通过路由断言，可以基于HTTP请求的各种参数（如路径、方法、头部等）建立复杂的路由规则，决定哪些请求应被路由到哪个微服务。

  6. WebSockets:
    支持WebSocket协议，为不同的服务提供流量转发。

  7. 访问控制:
    利用Spring Security集成，可以实现认证、授权和安全策略，控制谁可以访问哪些路由。

  8. Header、Query 参数的修改和验证:
    使用 ModifyRequestBody 和 ModifyResponseBody 这类过滤器来改变请求和响应的内容。可以验证、添加或移除HTTP头部和查询参数。

  9. 路径重写:
    通过重新定义网关路由匹配逻辑和路径，将请求重新路由到不同的下游服务路径。

  10. 跨域资源共享（CORS）配置:
    通过 Cors 配置项定义跨域访问策略，控制哪些源可访问 API。

  11. API版本控制:
    结合请求路径和请求头部信息，可以实现API版本的控制，确保不同版本的客户端访问相应版本的服务。

  12. 响应性能和QoS（服务质量）:
    通过配置如 response-timeout 和 connect-timeout 等参数，可以对服务的响应时间进行控制。

  13. 流量削峰填谷:
    通过调整重试和断路器策略，以应对流量的剧烈波动，并尝试维持平稳的服务质量。

  14. 全局过滤器:
    这些过滤器对所有路由生效，例如，可以用来进行全局日志记录和跟踪。

Spring Cloud Gateway 提供的这些流量控制和管理策略，让开发者有能力针对微服务架构的特定需求进行定制化的网关行为。这有助于提升应用的弹性、稳定性和用户体验。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/635274
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号