API 网关的核心价值
在分布式微服务架构中，API 网关作为系统流量的唯一入口，承担着路由分发、安全防护、流量治理三大核心职责。Spring Cloud Gateway 基于响应式编程模型与 Netty 高性能网络框架，提供灵活的路由规则、动态过滤器链和深度集成的安全方案。
典型场景
API 网关的基本请求流转如下：
graph LR
Client -->|请求| Gateway
Gateway -->|路由| ServiceA
Gateway -->|路由| ServiceB
Gateway -->|路由| ServiceC
一、Spring Cloud Gateway 架构与核心机制
1.1 核心架构
Spring Cloud Gateway 采用Reactor 响应式模型，通过如下核心组件构建请求处理链路：
• Route（路由）：定义请求转发的规则。
• Predicate（断言）：用于匹配请求条件，如路径、方法等。
• Filter（过滤器）：在请求处理前后执行操作，如鉴权、日志记录等。
请求处理流程如下：
// 简化的请求处理流程
public Mono<Void> handle(ServerWebExchange exchange) {
// 1. 路由匹配
return routePredicateHandlerMapping.getHandler(exchange)
// 2. 执行过滤器链
.flatMap(handler -> handler.handle(exchange))
// 3. 异常处理
.doOnError(e -> log.error("处理异常", e));
}
1.2 Spring Cloud 组件协作
Spring Cloud Gateway 与Eureka 和 LoadBalancer的协作流程如下：
工作流程
1.Client 发送请求（例如/api/users/1）。
2.Gateway 通过 Eureka 查询 user-service 可用实例。
3.Eureka 返回可用实例列表。
4.Gateway 选择合适的实例（负载均衡）。
5.Gateway 将请求转发到选定的服务实例。
6.Service 处理请求并返回结果给 Gateway。
7.Gateway 将响应返回给 Client。
关键机制解析
• 服务发现集成：
Gateway 集成 Eureka 客户端，自动从注册中心拉取服务实例列表。
通过discovery.locator.enabled=true自动生成服务路由规则。
• 负载均衡机制：
Gateway 默认集成Spring Cloud LoadBalancer（原 Ribbon），支持轮询、权重等策略。
使用 Eureka 作为注册中心时，网关自动获取服务实例并进行负载均衡。
1.3 Spring Cloud Gateway 配置示例
完整配置
在gateway-service的application.yml中配置如下：
server:
port: 9000 # 网关服务的端口
spring:
application:
name: gateway-service # 网关服务的名称
cloud:
gateway:
routes:
- id: user-service # 路由的名称
uri: lb://user-service # 从 Eureka 发现 user-service
predicates:
- Path=/user/** # 仅转发 /user/** 的请求
filters:
- StripPrefix=1 # 去掉 /user 前缀后再转发
eureka: # 网关服务注册到 Eureka
client:
service-url:
defaultZone: http://localhost:8761/eureka/ # Eureka 注册中心地址
instance:
prefer-ip-address: true # 让网关使用 IP 注册
配置解析
1.Eureka 注册
• gateway-service将自己的信息注册到 Eureka，方便其他微服务访问。
2.lb://user-service 机制
• 让网关从Eureka 动态发现user-service的地址，而无需手动指定 IP。
• lb://代表负载均衡（Load Balancer），会自动选择一个可用实例并根据负载均衡策略在多个实例之间分配流量。
3.路由规则
• Path=/user/**：匹配/user/开头的所有请求，并转发给user-service。
4.过滤器
• StripPrefix=1：去掉请求路径中的/user前缀，使user-service仅接收纯路径请求。
二、API 网关的四大职责
API 网关在微服务架构中的主要职责包括：
1.动态路由：
• 基于URL、请求参数、请求头等动态转发流量。
2.流量管理：
• 提供限流、熔断、负载均衡等能力，保障系统稳定性。
3.安全控制：
• 集成身份认证与权限管理，确保 API 访问安全。
4.日志与监控：
• 记录请求信息，支持服务监控与分析。
如下将分别讲解各个职责的工作机制：
三、动态路由：灵活性与生产级实现
Spring Cloud Gateway 允许使用配置文件或代码来定义路由规则，从而提供灵活的请求转发能力。
1. 配置文件定义路由
在gateway-service项目结构中，application.yml作为 Spring Cloud Gateway 的核心配置文件，存放在以下位置：
gateway-service/
├── src/main/resources/
│ ├── application.yml <-- ✅ 这里就是 Spring Cloud Gateway 的配置文件
在application.yml中，可对请求路由进行配置。分为静态路由配置和动态路由配置。
2. 静态路由 vs. 动态路由
静态路由适用于稳定、不频繁变更的场景，而动态路由更适合需要灵活调整或集中管理的微服务架构。
3.1 静态路由配置
Spring Cloud Gateway 支持YAML 配置和Java 代码两种方式定义静态路由。
1. YAML 配置方式
示例：
spring:
cloud:
gateway:
routes:
- id: user-service # 路由 ID，方便管理
uri: http://localhost:8081 # 目标服务地址
predicates:
- Path=/user/** # 匹配 /user/** 的请求
filters:
- StripPrefix=1 # 去除 /user 前缀
解析：
• id：路由名称，便于管理，如id: user-service代表“用户服务”路由。
• uri：请求最终转发的目标地址，如http://localhost:8081。
• predicates：定义请求匹配规则，如Path=/user/**表示匹配所有以/user/开头的请求。
• filters：对请求进行处理，如StripPrefix=1去掉/user前缀，使/user/list变为/list，简化目标服务路径。
示例访问效果：
# 访问 http://localhost:8080/user/list
# 实际会被转发到 http://localhost:8081/list
2. Java 代码方式
在应用的配置类中定义路由规则：
@Configuration
public class GatewayConfig {
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
// 匹配路径 /user/** 的请求
.route("user-service", r -> r.path("/user/**")
// 去掉路径前缀 /user
.filters(f -> f.stripPrefix(1))
// 将请求转发到 http://localhost:8081
.uri("http://localhost:8081"))
.build();
}
解析：
• 定义 RouteLocator Bean（@Bean注解的方法会被 Spring 容器管理）。
• 使用 RouteLocatorBuilder 配置路由规则，与 YAML 配置方式等效。
3. 静态路由的特点
• 适用于较固定的服务地址，比如内部服务间调用。
• 配置简单，但如果微服务地址变化，需要手动修改并重启网关。
• 不适用于大规模微服务，管理和维护成本较高，扩展性差。
3.2 动态路由配置
Spring Cloud Gateway 支持三种动态路由实现方式：
方式1：基于服务发现的动态路由（自动生效，无需手动刷新）
实现原理
Spring Cloud Gateway集成 Eureka，当启用服务发现功能后，网关会自动为注册到 Eureka 的服务生成默认路由，并同步服务实例变化。
配置示例
spring:
cloud:
gateway:
discovery:
locator:
enabled: true # 核心开关：启用服务发现自动路由
lower-case-service-id: true # 自动将服务名转为小写（兼容Eureka默认命名规则）
行为特征
• 自动生成路由：每个服务都会生成lb://service-id/规则，例如user-service变为/user-service/。
• 动态更新：当服务实例上下线时，网关自动更新，无需手动操作。
• 优先级控制：自动路由的优先级低于手动配置的路由。
验证方式
# 访问自动生成的路由（假设 user-service 已注册到 Eureka）
curl http://gateway:port/user-service/api/users/1
# 关闭 user-service 实例后再次访问，网关自动屏蔽不可用节点
方式2：基于配置中心的动态路由（需手动刷新）
实现原理
使用Spring Cloud Config等配置中心管理路由，修改配置后需手动调用刷新接口。
配置示例（Config Server + Git）
# config-repo/gateway-routes.yml
routes:
- id: order-service
uri: lb://order-service # 负载均衡标识
predicates:
- Path=/api/orders/**
filters:
- StripPrefix=1
刷新流程
1.修改配置中心的路由规则
2.调用刷新接口
curl -X POST http://gateway:port/actuator/refresh
3.网关重新加载配置，立即生效
方式3：基于数据库的动态路由（需主动触发刷新）
实现原理
• 将路由规则持久化到数据库。
• 通过自定义RouteDefinitionRepository实现动态加载，适用于生产环境。
数据库表设计
CREATE TABLE gateway_routes (
id VARCHAR(32) PRIMARY KEY COMMENT '路由ID',
uri VARCHAR(255) NOT NULL COMMENT '目标服务URI',
predicates TEXT NOT NULL COMMENT '断言规则（JSON格式）',
filters TEXT COMMENT '过滤器链（JSON格式）',
`order` INT DEFAULT 0 COMMENT '路由优先级'
);
核心代码
自定义路由仓库
@Component
public class DatabaseRouteRepository implements RouteDefinitionRepository {
@Autowired
private RouteDao routeDao; // 数据访问层（MyBatis/JPA）
// 从数据库加载路由规则
@Override
public Flux<RouteDefinition> getRouteDefinitions() {
return Flux.fromIterable(routeDao.findAllActiveRoutes())
.map(this::parseRouteDefinition);
}
// 转换实体为路由定义
private RouteDefinition parseRouteDefinition(RouteEntity entity) {
RouteDefinition definition = new RouteDefinition();
definition.setId(entity.getId());
definition.setUri(URI.create(entity.getUri()));
definition.setPredicates(parsePredicates(entity.getPredicates()));
definition.setFilters(parseFilters(entity.getFilters()));
definition.setOrder(entity.getOrder());
return definition;
}
}
触发路由刷新
@RestController
@RequestMapping("/gateway")
public class RouteRefreshController {
@Autowired
private GatewayRoutesRefresher refresher;
// 手动触发路由刷新
@PostMapping("/refresh")
public String refreshRoutes() {
refresher.refreshRoutes();
return "路由刷新成功";
}
}
动态更新流程
1.修改数据库中的路由规则
2.调用刷新接口
curl -X POST http://gateway:port/gateway/refresh
3.网关重新加载规则，立即生效
3.3 三种动态路由方案对比
3.4 混合模式
混合模式思路：
• 自动路由处理常规服务
• 手动配置处理特殊路由
配置示例
spring:
cloud:
gateway:
discovery:
locator:
enabled: true # 启用服务发现自动路由
lower-case-service-id: true
routes:
# 手动配置的静态路由（特殊需求）
- id: special-route
uri: lb://special-service # 目标服务
predicates:
- Path=/api/special/** # 匹配路径
filters:
- StripPrefix=1 # 去除路径前缀
代码示例：
@Configuration
public class GatewayConfig {
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
// 静态路由 - 手动配置特殊需求
.route("special-route", r -> r.path("/api/special/**") // 匹配 /api/special/** 的请求
.filters(f -> f.stripPrefix(1)) // 去除路径前缀
.uri("lb://special-service")) // 目标服务（负载均衡）
.build();
}
}
3.5 最佳实践建议
不同规模的系统可以采用不同的路由策略：
1.小型应用
• 直接启用服务发现自动路由(spring.cloud.gateway.discovery.locator.enabled=true)，无需额外配置，开箱即用。
2.中等规模
• 使用配置中心（如 Spring Cloud Config/Nacos）管理路由规则。
• 结合/actuator/refresh实现动态更新，提高灵活性。
3.生产级系统
• 采用数据库管理路由，实现更细粒度的控制。
• 结合缓存（如 Redis）减少数据库查询，提高性能。
• 配合事件驱动机制（如 Spring Cloud Bus），实现全网关集群的自动同步。
四、流量控制：过滤器与熔断策略
Spring Cloud Gateway 通过全局过滤器和局部过滤器进行请求拦截和流量管理。
• 全局过滤器（GlobalFilter）：作用于所有请求，必须实现GlobalFilter接口。
• 局部过滤器（GatewayFilter）：仅作用于指定路由，需要实现GatewayFilter并结合GatewayFilterFactory使用。
全局过滤器vs局部过滤器
4.1 全局限流示例
自定义全局限流过滤器（基于 Redis 实现令牌桶算法）
防止恶意请求过载服务。
@Component
public class RateLimitFilter implements GlobalFilter, Ordered {
private final RedisTemplate<String, Integer> redisTemplate;
// 通过构造函数注入 RedisTemplate，用于存储和管理请求计数
public RateLimitFilter(RedisTemplate<String, Integer> redisTemplate) {
this.redisTemplate = redisTemplate;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 获取客户端 IP 作为限流的 key
String key = "rate_limit:" + exchange.getRequest().getRemoteAddress();
// 从 Redis 获取当前请求次数
Integer current = redisTemplate.opsForValue().get(key);
// 如果当前请求次数小于 5，则允许请求通过，并增加计数
if (current == null || current < 5) {
redisTemplate.opsForValue().increment(key, 1);
return chain.filter(exchange);
}
// 超过限制，返回 429 Too Many Requests
exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
}
@Override
public int getOrder() {
return -1; // 过滤器优先级，值越小优先级越高
}
}
解析
1.实现 GlobalFilter 接口
• filter()方法控制请求流量，每个 IP最多 5 次请求，超过限制后网关直接拒绝请求，不再调用后端服务。
2.实现 Ordered 接口
• getOrder()方法用于控制过滤器的执行顺序，值越小，优先级越高。
• -1代表比默认过滤器（优先级通常为 0）更早执行。
全局过滤器的自动生效
无需在 application.yml 配置，Spring Boot会自动扫描 @Component 修饰的 GlobalFilter 并生效。所有通过网关的请求都会经过这个全局过滤器！
4.2 局部限流示例
自定义局部限流过滤器（基于 Redis 的 IP 限流）
@Component
public class RateLimitGatewayFilterFactory
extends AbstractGatewayFilterFactory<RateLimitGatewayFilterFactory.Config> {
private final RedisTemplate<String, Integer> redisTemplate;
public RateLimitGatewayFilterFactory(RedisTemplate<String, Integer> redisTemplate) {
super(Config.class);
this.redisTemplate = redisTemplate;
}
@Override
public GatewayFilter apply(Config config) {
return (exchange, chain) -> {
String key = "rate_limit:" + exchange.getRequest().getRemoteAddress();
Integer current = redisTemplate.opsForValue().get(key);
// 允许每个 IP 每分钟最多请求 5 次
if (current == null || current < 5) {
redisTemplate.opsForValue().increment(key, 1);
return chain.filter(exchange);
}
// 超过限制，返回 429
exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
};
}
// 过滤器的配置类
public static class Config {
}
}
局部过滤器的应用
在application.yml中配置，指定RateLimitGatewayFilterFactory过滤器：
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://user-service
predicates:
- Path=/user/**
filters:
- StripPrefix=1
- name: RateLimitGatewayFilterFactory # 添加自定义限流过滤器
代码解析
1.继承 AbstractGatewayFilterFactory
• 让 Spring Cloud Gateway 识别该类作为局部过滤器。
• apply(Config config)方法返回GatewayFilter实例，定义具体的过滤逻辑。
2.使用 Redis 存储请求计数
• key = rate_limit:客户端IP，存储该 IP 的请求次数。
• 每个 IP每分钟最多允许 5 次请求，超出后返回429 Too Many Requests。
3.如何生效？
• 局部过滤器必须在 application.yml 指定，不会影响所有请求。
• 仅作用于匹配 /user/** 的路由请求。
4.3 熔断降级集成（Resilience4j）
spring:
cloud:
gateway:
routes:
- id: order-service
uri: lb://order-service
filters:
- name: CircuitBreaker
args:
name: orderServiceBreaker
fallbackUri: forward:/fallback/order
五、安全策略：OAuth2 与 JWT 深度集成
5.1 认证与授权机制
JWT 认证全局过滤器 (JwtAuthFilter)
该类实现了 Spring Cloud Gateway 的全局过滤器 (GlobalFilter)，用于在网关层进行 JWT 认证，拦截未授权请求。
@Component
public class JwtAuthFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 从请求头中获取 Authorization 头部的 JWT
String token = exchange.getRequest().getHeaders().getFirst("Authorization");
// 如果 Token 为空或无效，则返回 401 Unauthorized
if (token == null || !validateToken(token)) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete(); // 直接终止请求
}
// 认证通过，继续执行下一个过滤器
return chain.filter(exchange);
}
/**
* 校验 JWT Token（这里只是示例，实际应解析 JWT 并验证有效性）
*/
private boolean validateToken(String token) {
// 解析 JWT 并验证签名、过期时间等（此处省略具体逻辑）
return true;
}
@Override
public int getOrder() {
return -10; // 过滤器优先级，值越小优先级越高
}
}
解析
• filter() 方法
• 获取请求头中的AuthorizationToken。
• 无效→ 直接返回401 Unauthorized，请求被拦截。
• 有效→ 继续执行后续过滤器，转发请求到下游服务。
• validateToken() 方法
• 解析并验证 JWT（需解码 JWT 并检查签名、过期时间等）。
• 返回true代表 Token 有效。
• getOrder() 方法
• -10代表优先级较高（早于默认过滤器执行）。
• 确保在网关早期拦截无效请求，避免将未授权请求转发到微服务。
适用场景：
• API 认证（保护微服务，避免未经授权的访问）。
• 网关级别 JWT 校验（减少后端微服务的安全负担）。
• 微服务安全加固（结合 OAuth2 或 Keycloak 进行更强的安全控制）。
5.2 结合 OAuth2 进行认证
Spring Cloud Gateway 也可以与 OAuth2 结合，实现更复杂的认证授权。
如下是Spring Cloud Gateway + OAuth2认证的完整示例，包含配置文件、代码和请求示例，确保网关具备如下功能：
1.拦截请求并校验 JWT 令牌（OAuth2 资源服务器模式）
2.作为 OAuth2 客户端访问受保护资源（可选，网关调用下游服务）
3.微服务解析 JWT，确保安全性
步骤 1：依赖引入
在gateway-server的pom.xml中添加必要的依赖：
<dependencies>
<!-- Spring Cloud Gateway -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- Spring Security OAuth2 资源服务器 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<!-- Spring Security OAuth2 客户端（如果 Gateway 需要访问受保护 API） -->
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-oauth2-client</artifactId>
</dependency>
<!-- Spring Boot Actuator (可选，用于刷新配置) -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>
步骤 2：配置 gateway-server
在application.yml配置OAuth2 资源服务器和OAuth2 客户端（如果 Gateway 需要访问受保护资源）。
server:
port: 9000 # 设置网关服务的端口为 9000
spring:
cloud:
gateway:
discovery:
locator:
enabled: true # 启用服务发现自动路由，网关可以动态地从 Eureka 中发现服务
lower-case-service-id: true # 将服务 ID 转为小写，避免大小写问题
routes:
- id: user-service # 路由名称为 user-service
uri: lb://user-service # 使用负载均衡的方式从 Eureka 服务注册中心发现 user-service 的实例
predicates:
- Path=/user/** # 路由匹配所有以 /user/ 开头的请求
filters:
- StripPrefix=1 # 去掉路径中的 /user 前缀，转发给目标服务（user-service）
security:
oauth2:
resourceserver:
jwt:
issuer-uri: https://auth-server.com # OAuth2 认证服务器的地址，用于验证 JWT
jwk-set-uri: https://auth-server.com/oauth2/jwks # 获取 JWT 公钥的 URI，用于验证 JWT 签名
client: # 配置 OAuth2 客户端
registration:
my-client: # 定义一个名为 my-client 的客户端
provider: my-auth-server # 指定 OAuth2 认证服务器的提供者（在下面的 provider 中定义）
client-id: gateway-service # 客户端 ID，通常是在认证服务器上注册的服务名称
client-secret: secret # 客户端密钥，用于身份验证
authorization-grant-type: client_credentials # 使用客户端凭证授权类型（client_credentials），适用于无用户交互的应用场景
scope: read,write # 定义客户端的权限范围，允许的操作权限（如 read 和 write）
provider:
my-auth-server: # 配置 OAuth2 认证服务器信息
issuer-uri: https://auth-server.com # 认证服务器的地址，JWT 的发行者 URI
解析：
• issuer-uri：用于校验 JWT 是否由可信 OAuth2 服务器签发。
• jwk-set-uri：JWT 公钥端点，供网关校验令牌。
• 如果网关自身需要 OAuth2 令牌访问受保护 API，则需要配置client-id。
步骤 3：启用 OAuth2 认证
创建SecurityConfig，让 Gateway 校验 JWT 并进行访问控制。
@Configuration
public class SecurityConfig {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
return http
.authorizeHttpRequests(auth -> auth
.requestMatchers("/public/**").permitAll() // 允许访问 /public 开头的接口
.anyRequest().authenticated() // 其他请求需要认证
)
.oauth2ResourceServer(oauth2 -> oauth2.jwt()) // 启用 JWT 校验
.build();
}
}
解析：
• 允许/public/**接口直接访问，其他接口需要 JWT 认证。
• oauth2ResourceServer().jwt()让网关解析 JWT。
步骤 4：自定义 JWT 过滤器（可选，拦截无效 Token）
创建JwtAuthFilter进行更细粒度的控制：
@Component
public class JwtAuthFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String token = exchange.getRequest().getHeaders().getFirst(HttpHeaders.AUTHORIZATION);
if (token == null || !validateToken(token)) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
return chain.filter(exchange);
}
private boolean validateToken(String token) {
// 解析 JWT 并验证（这里省略解析逻辑）
return true;
}
@Override
public int getOrder() {
return -10;
}
}
解析：
• 如果Authorization头为空或 Token 无效，则返回401 Unauthorized。
• 放行有效请求，继续执行 Gateway 路由。
步骤 5：受保护微服务 (user-service)
在user-service配置 JWT 校验，确保网关转发的请求也是安全的：
spring:
security:
oauth2:
resourceserver:
jwt:
issuer-uri: https://auth-server.com
解析：
• user-service也会校验 JWT，避免绕过网关直接访问服务。
步骤 6：测试 OAuth2 认证
(1) 获取 OAuth2 令牌
curl -X POST https://auth-server.com/oauth/token \
-d "client_id=gateway-service" \
-d "client_secret=secret" \
-d "grant_type=client_credentials"
返回：
{
"access_token": "eyJhbGciOiJIUzI1...",
"token_type": "bearer",
"expires_in": 3600
}
（2）带 Token 访问 Gateway
curl -H “Authorization: Bearer eyJhbGciOiJIUzI1…” http://localhost:9000/user/info
解析：
• Token 有效：网关转发请求到user-service并返回数据。
• Token 无效：返回401 Unauthorized。
六、生产级最佳实践
6.1 性能调优指标
开启 Actuator 监控
Spring Cloud Gateway 可集成Spring Boot Actuator，提供实时监控能力。
management:
endpoints:
web:
exposure:
include: gateway, health, metrics
访问http://localhost:8080/actuator/gateway/routes可查看当前所有路由。
结合 Prometheus + Grafana 监控请求情况
• Prometheus：收集 Gateway 请求数据。
• Grafana：可视化请求成功率、响应时间等关键指标。
6.2 高可用架构设计
graph TD
A[客户端] --> B[Gateway集群]
B --> C[Eureka注册中心]
B --> D[Redis限流缓存]
B --> E[Prometheus监控]
C --> F[微服务实例]
七、总结
7.1 核心重点
• API 网关提供统一入口：简化调用，具备流量管控、安全防护、动态路由等功能。
• Eureka 与 Gateway 集成：实现服务发现与自动负载均衡，简化微服务交互。
• 静态与动态路由：根据业务场景灵活选择路由方式，适配不同需求。
• 安全策略与过滤器：在流量控制、身份验证、限流等方面提供了强大的支持，确保微服务的高效与安全。
• 生产级优化：结合配置中心、数据库动态路由提升灵活性。