文章目录
- 🚦 Spring Cloud Gateway 路由与过滤器机制
-
- 📋 目录
- 🏗️ 一、Gateway 整体架构与设计理念
-
- 💡 Gateway 核心架构图
- 🎯 Gateway 核心组件关系
- ⚡ 二、Reactor 模型与 Netty 底层原理
-
- 🎯 WebFlux 响应式编程模型
- 🔄 Reactor 执行模型
- 🛣️ 三、路由匹配机制深度解析
-
- 🎯 RoutePredicateHandlerMapping 原理
- 📋 内置断言工厂详解
- 🔄 四、过滤器链执行机制
-
- 🎯 GatewayFilterChain 执行流程
- 📊 过滤器执行顺序
- 🛠️ 五、自定义过滤器开发实战
-
- 🔧 全局过滤器开发
- 🔄 自定义路由过滤器
- 🔄 六、动态路由与配置热更新
- 📊 七、性能优化与高并发设计
- 🆚 八、与 Nginx/Kong 的对比分析
🚦 Spring Cloud Gateway 路由与过滤器机制
📋 目录
- 🏗️ 一、Gateway 整体架构与设计理念
- ⚡ 二、Reactor 模型与 Netty 底层原理
- 🛣️ 三、路由匹配机制深度解析
- 🔄 四、过滤器链执行机制
- 🛠️ 五、自定义过滤器开发实战
- 🔄 六、动态路由与配置热更新
- 📊 七、性能优化与高并发设计
- 🆚 八、与 Nginx/Kong 的对比分析
🏗️ 一、Gateway 整体架构与设计理念
💡 Gateway 核心架构图
Spring Cloud Gateway 三层架构：
客户端请求 Gateway WebHandler RoutePredicateHandlerMapping 匹配路由规则 构建过滤链 执行Pre过滤器 代理请求到后端 执行Post过滤器 返回响应 配置源 路由定义
🎯 Gateway 核心组件关系
组件依赖关系与执行流程：
java
/**
* Gateway 核心组件架构
* 基于WebFlux的响应式编程模型
*/
@Component
@Slf4j
public class GatewayArchitecture {
/**
* 1. 网关自动配置类 - 核心配置入口
*/
@Configuration
@ConditionalOnClass(DispatcherHandler.class)
public class GatewayAutoConfiguration {
@Bean
@ConditionalOnMissingBean
public RouteLocator routeLocator() {
return new PropertiesRouteLocator();
}
@Bean
public RoutePredicateHandlerMapping routePredicateHandlerMapping(
FilteringWebHandler webHandler, RouteLocator routeLocator) {
return new RoutePredicateHandlerMapping(webHandler, routeLocator);
}
}
/**
* 2. 路由定位器接口 - 路由规则来源
*/
public interface RouteLocator {
Flux<Route> getRoutes();
}
/**
* 3. 路由定义 - 核心路由模型
*/
@Data
public class Route {
private final String id;
private final URI uri;
private final int order;
private final AsyncPredicate<ServerWebExchange> predicate;
private final List<GatewayFilter> gatewayFilters;
private final Map<String, Object> metadata;
}
/**
* 4. 路由断言处理器映射
*/
public class RoutePredicateHandlerMapping extends AbstractHandlerMapping {
private final FilteringWebHandler webHandler;
private final RouteLocator routeLocator;
@Override
public Mono<Object> getHandlerInternal(ServerWebExchange exchange) {
return lookupRoute(exchange)
.map(route -> {
exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
return webHandler;
});
}
private Mono<Route> lookupRoute(ServerWebExchange exchange) {
return routeLocator.getRoutes()
.concatMap(route -> Mono.just(route)
.filterWhen(r -> r.getPredicate().apply(exchange))
.doOnError(e -> log.error("路由匹配错误", e))
.onErrorResume(e -> Mono.empty()))
.next()
.map(route -> {
log.debug("路由匹配成功: {}", route.getId());
return route;
});
}
}
/**
* 5. 过滤Web处理器 - 执行过滤器链
*/
public class FilteringWebHandler implements WebHandler {
private final List<GatewayFilter> globalFilters;
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
List<GatewayFilter> gatewayFilters = route.getFilters();
// 合并全局过滤器和路由过滤器
List<GatewayFilter> combined = new ArrayList<>(globalFilters);
combined.addAll(gatewayFilters);
// 排序过滤器
AnnotationAwareOrderComparator.sort(combined);
// 构建过滤器链并执行
return new DefaultGatewayFilterChain(combined).filter(exchange);
}
}
}⚡ 二、Reactor 模型与 Netty 底层原理
🎯 WebFlux 响应式编程模型
Gateway 响应式处理流程：
java
/**
* WebFlux 响应式编程在Gateway中的应用
* 基于Project Reactor的异步非阻塞模型
*/
@Component
@Slf4j
public class ReactiveGatewayArchitecture {
/**
* 1. 响应式请求处理入口
*/
@Bean
public HttpHandler httpHandler() {
return new ReactorHttpHandlerAdapter(
WebHttpHandlerBuilder
.webHandler(createWebHandler())
.filter(createFilters())
.build()
);
}
/**
* 2. 创建Web处理器
*/
private WebHandler createWebHandler() {
return exchange -> {
// 构建响应式处理链
return Mono.fromRunnable(() -> {
// 设置请求属性
exchange.getAttributes().put("startTime", System.currentTimeMillis());
log.debug("开始处理请求: {}", exchange.getRequest().getURI());
})
.then(handleRequest(exchange))
.doOnSuccess(v -> logRequestCompletion(exchange))
.doOnError(e -> logRequestError(exchange, e));
};
}
/**
* 3. 请求处理核心逻辑
*/
private Mono<Void> handleRequest(ServerWebExchange exchange) {
return Mono.defer(() -> {
// 路由匹配
return routePredicateHandlerMapping.getHandler(exchange)
.flatMap(handler -> {
if (handler instanceof WebHandler) {
return ((WebHandler) handler).handle(exchange);
}
return Mono.error(new IllegalStateException("不支持的处理器类型"));
});
})
.subscribeOn(Schedulers.boundedElastic()) // 使用弹性调度器
.timeout(Duration.ofSeconds(30)) // 设置超时
.onErrorResume(this::handleError); // 错误处理
}
/**
* 4. Netty 底层配置
*/
@Configuration
public class NettyConfiguration {
@Bean
public ReactorResourceFactory reactorResourceFactory() {
ReactorResourceFactory factory = new ReactorResourceFactory();
factory.setUseGlobalResources(false);
return factory;
}
@Bean
public NettyWebServerFactoryCustomizer nettyWebServerFactoryCustomizer() {
return factory -> {
factory.addServerCustomizers(httpServer -> {
// 配置Netty服务器参数
return httpServer
.host("0.0.0.0")
.port(8080)
.compress(true)
.accessLog(true)
.httpRequestDecoder(decoder -> {
decoder.maxInitialLineLength(4096);
decoder.maxHeaderSize(8192);
})
.tcpConfiguration(tcp -> {
return tcp
.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)
.option(ChannelOption.SO_BACKLOG, 1000);
});
});
};
}
}
/**
* 5. 事件循环组配置
*/
@Bean
@ConditionalOnMissingBean
public LoopResources loopResources() {
return LoopResources.create("gateway-webflux", 1, 4, true);
}
/**
* 6. 背压控制
*/
@Component
public class BackpressureHandler {
private final RateLimiter rateLimiter;
public BackpressureHandler() {
this.rateLimiter = RateLimiter.create(1000); // 每秒1000个请求
}
public <T> Mono<T> withBackpressure(Mono<T> source) {
return Mono.fromCallable(() -> {
if (rateLimiter.tryAcquire()) {
return source;
} else {
throw new TooManyRequestsException("请求频率超限");
}
})
.flatMap(mono -> mono);
}
}
}🔄 Reactor 执行模型
响应式编程执行流程：
HTTP请求 EventLoop Group Channel Handler HttpServerHandler ReactorHttpHandlerAdapter WebHandler RoutePredicateHandlerMapping FilteringWebHandler GatewayFilter Chain 代理后端服务 返回响应
🛣️ 三、路由匹配机制深度解析
🎯 RoutePredicateHandlerMapping 原理
路由匹配核心源码分析：
java
/**
* 路由断言处理器映射实现
* 负责匹配请求到对应的路由规则
*/
@Component
@Slf4j
public class RoutePredicateHandlerMapping {
private final RouteLocator routeLocator;
private final FilteringWebHandler webHandler;
private final Map<String, RoutePredicateFactory> predicates;
/**
* 核心路由匹配方法
*/
@Override
public Mono<Object> getHandler(ServerWebExchange exchange) {
return lookupRoute(exchange)
.map(route -> {
// 设置路由属性
exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, route);
exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, route.getId());
// 记录匹配日志
if (log.isDebugEnabled()) {
log.debug("路由匹配成功: {} -> {}",
exchange.getRequest().getURI(), route.getUri());
}
return webHandler;
})
.switchIfEmpty(Mono.empty().doOnSuccess(v -> {
// 没有匹配的路由
if (log.isDebugEnabled()) {
log.debug("没有匹配的路由: {}", exchange.getRequest().getURI());
}
}));
}
/**
* 路由查找实现
*/
private Mono<Route> lookupRoute(ServerWebExchange exchange) {
return routeLocator.getRoutes()
.concatMap(route -> Mono.just(route)
.filterWhen(r -> r.getPredicate().apply(exchange))
.doOnError(e -> log.error("路由断言执行错误: {}", route.getId(), e))
.onErrorResume(e -> Mono.empty()))
.next()
.map(route -> {
// 记录路由匹配指标
recordRouteMatchMetric(exchange, route);
return route;
});
}
/**
* 内置断言工厂实现示例
*/
@Component
public class PathRoutePredicateFactory extends AbstractRoutePredicateFactory<PathRoutePredicateFactory.Config> {
public PathRoutePredicateFactory() {
super(Config.class);
}
@Override
public Predicate<ServerWebExchange> apply(Config config) {
return exchange -> {
String path = exchange.getRequest().getURI().getPath();
boolean match = config.patterns.stream()
.anyMatch(pattern -> {
if (pattern.contains("**")) {
// Ant风格路径匹配
return antPathMatcher.match(pattern, path);
} else {
// 正则表达式匹配
return path.matches(pattern);
}
});
if (match && log.isDebugEnabled()) {
log.debug("路径匹配成功: {} 匹配模式: {}", path, config.patterns);
}
return match;
};
}
@Data
public static class Config {
private List<String> patterns = new ArrayList<>();
}
}
/**
* 多条件组合断言
*/
@Component
public class CompositeRoutePredicate implements AsyncPredicate<ServerWebExchange> {
private final List<AsyncPredicate<ServerWebExchange>> predicates;
public CompositeRoutePredicate(List<AsyncPredicate<ServerWebExchange>> predicates) {
this.predicates = predicates;
}
@Override
public Publisher<Boolean> apply(ServerWebExchange exchange) {
return Flux.fromIterable(predicates)
.concatMap(predicate -> predicate.apply(exchange))
.reduce(true, (result, current) -> result && current)
.flux();
}
}
}📋 内置断言工厂详解
常用路由断言配置示例：
yaml
spring:
cloud:
gateway:
routes:
# 1. 路径匹配路由
- id: path_route
uri: lb://user-service
predicates:
- Path=/api/users/**
- Method=GET,POST
- Header=X-Request-Id, \d+
- Cookie=sessionId, .+
- After=2023-01-20T17:42:47.789-07:00[America/Denver]
# 2. 权重路由
- id: weight_high
uri: lb://user-service-v2
predicates:
- Path=/api/users/**
- Weight=group1, 80
# 3. 权重路由
- id: weight_low
uri: lb://user-service-v1
predicates:
- Path=/api/users/**
- Weight=group1, 20
# 4. 查询参数路由
- id: query_route
uri: lb://order-service
predicates:
- Path=/api/orders
- Query=type,prepaid
- RemoteAddr=192.168.1.1/24
# 5. 自定义断言
- id: custom_route
uri: lb://custom-service
predicates:
- name: CustomPredicate
args:
minVersion: 1.0
maxVersion: 2.0
filters:
- name: CustomFilter
args:
prefix: /v1🔄 四、过滤器链执行机制
🎯 GatewayFilterChain 执行流程
过滤器链核心实现：
java
/**
* 网关过滤器链实现
* 基于责任链模式的过滤器执行机制
*/
@Component
@Slf4j
public class GatewayFilterChainArchitecture {
/**
* 1. 默认网关过滤器链
*/
public class DefaultGatewayFilterChain implements GatewayFilterChain {
private final List<GatewayFilter> filters;
private final int index;
private final GatewayFilterChain next;
public DefaultGatewayFilterChain(List<GatewayFilter> filters) {
this.filters = filters;
this.index = 0;
this.next = null;
}
private DefaultGatewayFilterChain(DefaultGatewayFilterChain parent, int index) {
this.filters = parent.filters;
this.index = index;
this.next = index < filters.size() ?
new DefaultGatewayFilterChain(parent, index + 1) : null;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange) {
return Mono.defer(() -> {
if (index < filters.size()) {
GatewayFilter filter = filters.get(index);
// 记录过滤器执行开始
exchange.getAttributes().put("filter." + index + ".start", System.currentTimeMillis());
return filter.filter(exchange, next)
.doOnSuccess(v -> {
// 记录过滤器执行完成
long endTime = System.currentTimeMillis();
Long startTime = exchange.getAttribute("filter." + index + ".start");
if (startTime != null) {
long duration = endTime - startTime;
log.debug("过滤器 {} 执行耗时: {}ms",
filter.getClass().getSimpleName(), duration);
}
})
.doOnError(e -> {
log.error("过滤器执行失败: {}", filter.getClass().getSimpleName(), e);
});
} else {
// 所有过滤器执行完成，转发请求
return forwardToBackend(exchange);
}
});
}
}
/**
* 2. 全局过滤器排序与执行
*/
@Component
public class GlobalFilterConfiguration {
@Bean
@Order(-1)
public GlobalFilter loggingFilter() {
return (exchange, chain) -> {
long startTime = System.currentTimeMillis();
String requestId = exchange.getRequest().getId();
log.info("请求开始: {} {} {}",
exchange.getRequest().getMethod(),
exchange.getRequest().getURI(),
requestId);
return chain.filter(exchange)
.doOnSuccess(v -> {
long duration = System.currentTimeMillis() - startTime;
log.info("请求完成: {} 状态: {} 耗时: {}ms",
requestId,
exchange.getResponse().getStatusCode(),
duration);
})
.doOnError(e -> {
long duration = System.currentTimeMillis() - startTime;
log.error("请求失败: {} 耗时: {}ms", requestId, duration, e);
});
};
}
@Bean
@Order(0)
public GlobalFilter authFilter() {
return (exchange, 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);
};
}
@Bean
@Order(1)
public GlobalFilter rateLimitFilter() {
return new RateLimitGlobalFilter();
}
}
/**
* 3. 内置过滤器示例
*/
@Component
public class BuiltInFilters {
/**
* 添加请求头过滤器
*/
public class AddRequestHeaderFilter implements GatewayFilter {
private final String name;
private final String value;
public AddRequestHeaderFilter(String name, String value) {
this.name = name;
this.value = value;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 添加请求头
ServerHttpRequest request = exchange.getRequest().mutate()
.header(name, value)
.build();
return chain.filter(exchange.mutate().request(request).build());
}
}
/**
* 重试过滤器
*/
public class RetryFilter implements GatewayFilter {
private final int maxAttempts;
private final List<HttpStatus> statuses;
public RetryFilter(int maxAttempts, List<HttpStatus> statuses) {
this.maxAttempts = maxAttempts;
this.statuses = statuses;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return chain.filter(exchange)
.retryWhen(Retry.fixedDelay(maxAttempts, Duration.ofSeconds(1))
.filter(throwable -> {
if (throwable instanceof WebClientResponseException) {
WebClientResponseException ex = (WebClientResponseException) throwable;
return statuses.contains(ex.getStatusCode());
}
return false;
}));
}
}
}
}📊 过滤器执行顺序
过滤器执行优先级配置：
yaml
spring:
cloud:
gateway:
default-filters:
# 全局默认过滤器
- AddRequestHeader=X-Request-Gateway, SpringCloudGateway
- PrefixPath=/api
- StripPrefix=1
routes:
- id: user_route
uri: lb://user-service
predicates:
- Path=/users/**
filters:
# 路由级别过滤器
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 10
redis-rate-limiter.burstCapacity: 20
- name: Retry
args:
retries: 3
statuses: BAD_GATEWAY,SERVICE_UNAVAILABLE
- name: CircuitBreaker
args:
name: userService
fallbackUri: forward:/fallback/user
# 执行顺序：按配置顺序执行
- AddResponseHeader=X-Response-Time, anonymized
- ModifyResponseBody=UserResponse, UserResponse🛠️ 五、自定义过滤器开发实战
🔧 全局过滤器开发
自定义全局过滤器示例：
java
/**
* 自定义全局过滤器实战
* 实现认证、限流、日志等通用功能
*/
@Component
@Slf4j
public class CustomGlobalFilters {
/**
* 1. JWT认证过滤器
*/
@Component
@Order(-1000)
public class JwtAuthenticationFilter implements GlobalFilter {
@Autowired
private JwtTokenProvider tokenProvider;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String path = exchange.getRequest().getURI().getPath();
// 跳过认证的路径
if (shouldSkipAuth(path)) {
return chain.filter(exchange);
}
// 获取Token
String token = extractToken(exchange.getRequest());
if (token == null) {
return unauthorized(exchange, "缺少认证Token");
}
// 验证Token
try {
Authentication auth = tokenProvider.validateToken(token);
exchange.getAttributes().put("user", auth);
log.debug("用户认证成功: {}", auth.getName());
return chain.filter(exchange);
} catch (JwtException e) {
log.warn("Token验证失败: {}", e.getMessage());
return unauthorized(exchange, "Token无效或已过期");
}
}
private boolean shouldSkipAuth(String path) {
return path.startsWith("/auth/login") ||
path.startsWith("/public/") ||
path.equals("/health");
}
private String extractToken(ServerHttpRequest request) {
String header = request.getHeaders().getFirst("Authorization");
if (header != null && header.startsWith("Bearer ")) {
return header.substring(7);
}
return null;
}
private Mono<Void> unauthorized(ServerWebExchange exchange, String message) {
exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
byte[] bytes = ("{\"code\": 401, \"message\": \"" + message + "\"}").getBytes();
DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(bytes);
return exchange.getResponse().writeWith(Mono.just(buffer));
}
}
/**
* 2. 请求限流过滤器
*/
@Component
@Order(-500)
public class RateLimitFilter implements GlobalFilter {
private final RateLimiter rateLimiter;
public RateLimitFilter() {
// 每秒钟100个请求
this.rateLimiter = RateLimiter.create(100.0);
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String clientIp = getClientIp(exchange.getRequest());
String path = exchange.getRequest().getURI().getPath();
// 生成限流key
String rateLimitKey = String.format("%s:%s", clientIp, path);
// 尝试获取许可
if (rateLimiter.tryAcquire()) {
log.debug("限流通过: {}", rateLimitKey);
return chain.filter(exchange);
} else {
log.warn("限流拒绝: {}", rateLimitKey);
exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
}
}
private String getClientIp(ServerHttpRequest request) {
String xff = request.getHeaders().getFirst("X-Forwarded-For");
if (xff != null && !xff.isEmpty()) {
return xff.split(",")[0].trim();
}
return request.getRemoteAddress() != null ?
request.getRemoteAddress().getAddress().getHostAddress() : "unknown";
}
}
/**
* 3. 请求日志过滤器
*/
@Component
@Order(-100)
public class RequestLogFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
long startTime = System.currentTimeMillis();
String requestId = generateRequestId();
// 设置请求ID
ServerHttpRequest request = exchange.getRequest().mutate()
.header("X-Request-ID", requestId)
.build();
exchange = exchange.mutate().request(request).build();
// 记录请求开始
logRequestStart(exchange, requestId);
return chain.filter(exchange)
.doOnSuccess(v -> {
// 记录请求完成
long duration = System.currentTimeMillis() - startTime;
logRequestCompletion(exchange, requestId, duration, true);
})
.doOnError(e -> {
// 记录请求失败
long duration = System.currentTimeMillis() - startTime;
logRequestCompletion(exchange, requestId, duration, false);
});
}
private void logRequestStart(ServerWebExchange exchange, String requestId) {
if (log.isInfoEnabled()) {
ServerHttpRequest request = exchange.getRequest();
log.info("REQUEST_START [{}] {} {} {}",
requestId,
request.getMethod(),
request.getURI(),
getClientInfo(request));
}
}
private void logRequestCompletion(ServerWebExchange exchange, String requestId,
long duration, boolean success) {
if (log.isInfoEnabled()) {
ServerHttpResponse response = exchange.getResponse();
log.info("REQUEST_END [{}] status:{} duration:{}ms success:{}",
requestId,
response.getStatusCode(),
duration,
success);
}
}
private String generateRequestId() {
return UUID.randomUUID().toString().replace("-", "").substring(0, 16);
}
}
}🔄 自定义路由过滤器
路由级别过滤器开发：
java
/**
* 自定义路由过滤器
* 针对特定路由的定制化处理
*/
@Component
@Slf4j
public class CustomRouteFilters {
/**
* 1. 响应修改过滤器
*/
public class ModifyResponseFilter implements GatewayFilter, Ordered {
private final String headerName;
private final String headerValue;
private final int order;
public ModifyResponseFilter(String headerName, String headerValue, int order) {
this.headerName = headerName;
this.headerValue = headerValue;
this.order = order;
}
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
return chain.filter(exchange)
.then(Mono.fromRunnable(() -> {
// 修改响应头
ServerHttpResponse response = exchange.getResponse();
if (!response.isCommitted()) {
response.getHeaders().add(headerName, headerValue);
log.debug("添加响应头: {} = {}", headerName, headerValue);
}
}));
}
@Override
public int getOrder() {
return order;
}
}
/**
* 2. 请求体修改过滤器
*/
public class ModifyRequestBodyFilter implements GatewayFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 缓存请求体
ServerHttpRequest request = exchange.getRequest();
if (request.getHeaders().getContentType() != null &&
request.getHeaders().getContentType().includes(MediaType.APPLICATION_JSON)) {
return DataBufferUtils.join(request.getBody())
.flatMap(dataBuffer -> {
// 读取并修改请求体
byte[] bytes = new byte[dataBuffer.readableByteCount()];
dataBuffer.read(bytes);
DataBufferUtils.release(dataBuffer);
String body = new String(bytes, StandardCharsets.UTF_8);
String modifiedBody = modifyJsonBody(body);
// 创建新的请求
byte[] newBytes = modifiedBody.getBytes(StandardCharsets.UTF_8);
ServerHttpRequest newRequest = request.mutate()
.body(Flux.just(exchange.getResponse().bufferFactory().wrap(newBytes)))
.build();
return chain.filter(exchange.mutate().request(newRequest).build());
});
}
return chain.filter(exchange);
}
private String modifyJsonBody(String originalBody) {
try {
ObjectMapper mapper = new ObjectMapper();
JsonNode root = mapper.readTree(originalBody);
// 修改JSON内容
if (root.isObject()) {
((ObjectNode) root).put("modifiedBy", "gateway");
((ObjectNode) root).put("modifyTime", System.currentTimeMillis());
}
return mapper.writeValueAsString(root);
} catch (Exception e) {
log.warn("修改请求体失败", e);
return originalBody;
}
}
}
/**
* 3. 自定义过滤器工厂
*/
@Component
public class CustomFilterFactory extends AbstractGatewayFilterFactory<CustomFilterFactory.Config> {
public CustomFilterFactory() {
super(Config.class);
}
@Override
public GatewayFilter apply(Config config) {
return (exchange, chain) -> {
log.info("执行自定义过滤器: {}", config.getName());
// 前置处理
if (config.isPreFilter()) {
ServerHttpRequest request = exchange.getRequest().mutate()
.header("X-Custom-Filter", config.getName())
.build();
exchange = exchange.mutate().request(request).build();
}
return chain.filter(exchange)
.then(Mono.fromRunnable(() -> {
// 后置处理
if (config.isPostFilter() && !exchange.getResponse().isCommitted()) {
exchange.getResponse().getHeaders()
.add("X-Custom-Filter", config.getName());
}
}));
};
}
@Override
public List<String> shortcutFieldOrder() {
return Arrays.asList("name", "preFilter", "postFilter");
}
@Data
public static class Config {
private String name;
private boolean preFilter = true;
private boolean postFilter = true;
}
}
}由于篇幅限制，我将后续内容简要概述。完整文章将包含：
🔄 六、动态路由与配置热更新
- 基于配置中心的动态路由
- 路由变更监听机制
- 零停机配置刷新
- 路由版本管理
📊 七、性能优化与高并发设计
- Netty 参数调优
- 响应式背压控制
- 连接池优化配置
- 监控指标收集
🆚 八、与 Nginx/Kong 的对比分析
- 功能特性对比
- 性能基准测试
- 适用场景分析
- 混合架构设计
性能优化配置示例：
yaml
server:
port: 8080
spring:
cloud:
gateway:
httpclient:
connect-timeout: 1000
response-timeout: 5s
pool:
type: elastic
max-connections: 1000
acquire-timeout: 45000
metrics:
enabled: true
management:
endpoints:
web:
exposure:
include: health,metrics,gateway
endpoint:
gateway:
enabled: true洞察：Spring Cloud Gateway 作为第二代API网关，基于WebFlux的响应式编程模型提供了卓越的性能表现。深入理解其路由匹配和过滤器链机制，是构建高性能微服务网关的关键。
如果觉得本文对你有帮助，请点击 👍 点赞 + ⭐ 收藏 + 💬 留言支持！