本文系统介绍了 Spring Cloud Gateway 的构建、核心机制及底层原理。涵盖项目搭建、路由断言过滤器配置、服务注册发现、负载均衡、限流熔断等实践功能。同时深入解析了基于 Netty 和 WebFlux 的高性能架构模型，包括事件驱动、内存池化、连接复用及请求分发机制，帮助开发者全面掌握网关的设计思想与运维优化方案。
Spring Cloud Gateway 作为微服务架构的核心组件，其正确理解和应用至关重要。要真正掌握 Gateway，需从架构认知、核心机制与实践应用三个维度建立系统性理解。
<!-- 引入依赖 -->
<dependency>
<groupId>org.springframework.cloud
spring-cloud-starter-gateway
# 配置文件 application.yml
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://user-service
predicates:
- Path=/api/user/**
filters:
- StripPrefix=1
// 启动类
@SpringBootApplication
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
<!-- 集成 Nacos 注册中心 -->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
# 配置 Nacos
spring:
cloud:
nacos:
discovery:
server-addr: 127.0.0.1:8848
gateway:
discovery:
locator:
enabled: true
lower-case-service-id: true
请求流程：客户端 → HandlerMapping → RouteLocator → Predicate → Filter → 目标服务
关键组件：
@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
return builder.routes()
.route("order-service", r -> r.path("/api/order/**")
.filters(f -> f.stripPrefix(1))
.uri("lb://order-service"))
.build();
}
理解要点：
# 多条件组合断言
spring:
cloud:
gateway:
routes:
- id: complex-route
uri: lb://service
predicates:
- Path=/api/**
- Method=GET
- Header=X-Request-Id, \d+
- Query=token, \w+
- After=2024-01-01T00:00:00+08:00
理解要点：
@Component
public class AuthFilter implements GlobalFilter, Ordered {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String token = exchange.getRequest().getHeaders().getFirst("Authorization");
if (token == null || !validateToken(token)) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
return exchange.getResponse().setComplete();
}
return chain.filter(exchange);
}
@Override
public int getOrder() {
return -100; // 优先级
}
}
理解要点：
# 自动集成 Ribbon/LoadBalancer
spring:
cloud:
gateway:
routes:
- id: service-route
uri: lb://service-name # lb://前缀触发负载均衡
理解要点：
lb:// 前缀自动启用负载均衡# 基于 Redis 的分布式限流
spring:
cloud:
gateway:
routes:
- id: rate-limit-route
uri: lb://service
filters:
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 10 # 令牌桶填充速率
redis-rate-limiter.burstCapacity: 20 # 令牌桶容量
key-resolver: "#{@userKeyResolver}" # 自定义 key 解析器
@Bean
public KeyResolver userKeyResolver() {
return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("userId"));
}
# 集成 Hystrix/Sentinel
spring:
cloud:
gateway:
routes:
- id: circuit-breaker-route
uri: lb://service
filters:
- name: Hystrix
args:
name: fallbackCommand
fallbackUri: forward:/fallback
@Configuration
public class CorsConfig {
@Bean
public CorsWebFilter corsWebFilter() {
CorsConfiguration config = new CorsConfiguration();
config.addAllowedOrigin("*");
config.addAllowedMethod("*");
config.addAllowedHeader("*");
config.setAllowCredentials(true);
UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
source.registerCorsConfiguration("/**", config);
return new CorsWebFilter(source);
}
}
# 综合应用：API 网关的完整配置
spring:
cloud:
gateway:
# 全局过滤器配置
default-filters:
- AddResponseHeader=X-Response-Default,Default-Value
routes:
# 用户服务路由
- id: user-service
uri: lb://user-service
predicates:
- Path=/api/user/**
filters:
- StripPrefix=1
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 100
redis-rate-limiter.burstCapacity: 200
# 订单服务路由（带认证）
- id: order-service
uri: lb://order-service
predicates:
- Path=/api/order/**
filters:
- StripPrefix=1
- name: Hystrix
args:
name: orderFallback
fallbackUri: forward:/order/fallback
# 静态资源路由
- id: static-resources
uri: http://static.example.com
predicates:
- Path=/static/**
总结：真正理解 Gateway 不仅仅是会配置，更要理解其设计理念、执行机制、扩展方式，能够在复杂场景下灵活运用，并具备问题排查和性能优化的能力。
┌─────────────────────────────────────────────────────────┐
│ 客户端请求层 │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ Netty 网络层 (EventLoop) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Acceptor │ │ EventLoop1 │ │ EventLoop2 │ │
│ │ 线程 │ │ 线程组 │ │ 线程组 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ WebFlux 响应式处理层 (Reactor) │
│ ┌───────────────────────────────────────────────────┐ │
│ │ DispatcherHandler (请求分发器) │ │
│ ↓ │ │
│ │ RoutePredicateHandlerMapping (路由匹配) │ │
│ ↓ │ │
│ │ FilteringWebHandler (过滤器链) │ │
│ ↓ │ │
│ │ GatewayFilterChain (责任链) │ │
│ └───────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 路由与过滤器层 │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Route │ │ Predicate │ │ Filter │ │
│ │ 路由定义 │ │ 断言匹配 │ │ 过滤器链 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 服务发现与负载均衡层 │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Discovery │ │ LoadBalancer│ │ Connection │ │
│ │ 服务发现 │ │ 负载均衡 │ │ 连接池 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
└─────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────┐
│ 目标服务层 │
└─────────────────────────────────────────────────────────┘
// 1. DispatcherHandler - 请求入口分发器
public class DispatcherHandler implements WebHandler {
private final Map<String, HandlerMapping> handlerMappings;
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
return handlerMappings.values().stream()
.filter(mapping -> mapping.matches(exchange))
.findFirst()
.map(mapping -> mapping.getHandler(exchange))
.orElse(Mono.error(new ResponseStatusException(HttpStatus.NOT_FOUND)))
.flatMap(handler -> handler.handle(exchange));
}
}
// 2. RoutePredicateHandlerMapping - 路由匹配器
public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
@Override
protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
Flux<Route> routes = routeLocator.getRoutes();
return routes.filter(route -> {
List<PredicateDefinition> predicates = route.getPredicates();
return predicates.stream().allMatch(predicate -> predicate.apply(exchange));
}).next()
.map(route -> {
exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
return webHandler;
});
}
}
// 3. FilteringWebHandler - 过滤器链处理器
public class FilteringWebHandler implements WebHandler {
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
List<GatewayFilter> routeFilters = route.getFilters();
List<GlobalFilter> globalFilters = getGlobalFilters();
List<GatewayFilter> combined = combineFilters(routeFilters, globalFilters);
GatewayFilterChain chain = new DefaultGatewayFilterChain(combined);
return chain.filter(exchange);
}
}
// 4. DefaultGatewayFilterChain - 责任链模式
private static class DefaultGatewayFilterChain implements GatewayFilterChain {
private final int index;
private final List<GatewayFilter> filters;
@Override
public Mono<Void> filter(ServerWebExchange exchange) {
if (index < filters.size()) {
GatewayFilter filter = filters.get(index);
return filter.filter(exchange, this);
} else {
return ((NettyRoutingFilter) filters.get(filters.size() - 1)).route(exchange);
}
}
}
// 传统 Servlet 模型（阻塞）
@WebServlet("/api")
public class BlockingServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) {
String result = database.query(); // 阻塞等待
resp.getWriter().write(result);
}
}
// Gateway 响应式模型（非阻塞）
@GetMapping("/api")
public Mono<String> reactiveApi() {
return database.queryAsync()
.map(result -> process(result));
}
┌─────────────────────────────────────────────────────┐
│ BossEventLoopGroup │
│ (1 个线程，负责 Accept 连接) │
│ ┌───────────────────────────────────────────────┐ │
│ │ ServerSocketChannel → Accept → SocketChannel │ │
│ └───────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────┐
│ WorkerEventLoopGroup │
│ (N 个线程，负责 IO 读写) │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ EventLoop│ │ EventLoop│ │ EventLoop│ │ EventLoop│ │
│ │ 线程 1 │ │ 线程 2 │ │ 线程 3 │ │ 线程 4 │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ ↓ ↓ ↓ ↓ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │ Channel1│ │ Channel2│ │ Channel3│ │ Channel4│ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
└─────────────────────────────────────────────────────┘
关键特性：
// Netty 内存池：复用内存块
PooledByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;
ByteBuf buffer = allocator.buffer(1024); // 从池中获取
// 使用...
buffer.release(); // 归还到池中，可复用
优势：
# HTTP 连接池配置
spring:
cloud:
gateway:
httpclient:
pool:
type: ELASTIC # 弹性连接池
max-connections: 1000 # 最大连接数
acquire-timeout: 45000 # 获取连接超时
优势：
public class RoutePredicateHandlerMapping {
public Mono<Route> getRoute(ServerWebExchange exchange) {
return routeLocator.getRoutes().filter(route -> {
// 1. Path 匹配（AntPathMatcher）
if (route.getPath() != null) {
AntPathMatcher matcher = new AntPathMatcher();
if (!matcher.match(route.getPath(), exchange.getRequest().getPath().value())) {
return false;
}
}
// 2. Method 匹配
if (route.getMethod() != null) {
if (!route.getMethod().equals(exchange.getRequest().getMethod())) {
return false;
}
}
// 3. Header 匹配
if (route.getHeaders() != null) {
for (Map.Entry<String, String> header : route.getHeaders().entrySet()) {
String value = exchange.getRequest().getHeaders().getFirst(header.getKey());
if (value == null || !value.matches(header.getValue())) {
return false;
}
}
}
return true;
}).next();
}
}
public class RoundRobinLoadBalancer implements ReactorServiceInstanceLoadBalancer {
private final AtomicInteger position = new AtomicInteger();
@Override
public Mono<ServiceInstance> choose(Request request) {
List<ServiceInstance> instances = discoveryClient.getInstances(serviceId);
if (instances.isEmpty()) {
return Mono.empty();
}
int pos = Math.abs(position.incrementAndGet() % instances.size());
return Mono.just(instances.get(pos));
}
}
@Component
public class NacosRouteDefinitionRepository implements RouteDefinitionRepository {
@Autowired
private ConfigService configService;
@PostConstruct
public void init() throws NacosException {
configService.addListener("gateway-routes", "DEFAULT_GROUP", new Listener() {
@Override
public void receiveConfigInfo(String configInfo) {
List<RouteDefinition> routes = parseRoutes(configInfo);
routes.forEach(route -> {
routeDefinitionWriter.save(Mono.just(route)).subscribe();
});
}
});
}
}
| 特性 | 传统 Tomcat (Servlet) | Gateway (WebFlux + Netty) |
|---|---|---|
| 编程模型 | 阻塞 IO | 非阻塞响应式 |
| 线程模型 | 每请求一线程 | 少量 EventLoop 处理海量连接 |
| 内存管理 | 频繁分配/释放 | 内存池复用 |
| 连接管理 | 短连接 | 连接池复用 |
| 扩展性 | 垂直扩展 | 水平扩展 |
核心优势：
综上所述，这是 Gateway 能够支撑高并发流量的核心原理。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online