在微服务架构中，API 网关是系统的入口，承担着请求路由、负载均衡、安全认证等重要职责。随着业务流量的不断增长，API 网关面临着越来越大的挑战，其中最常见的问题之一就是大流量下的内存溢出。

想象一下这样的场景：当系统遭受突发流量冲击时，Gateway 接收到大量的请求，每个请求都需要处理和转发。如果 Gateway 采用全量缓冲的方式处理请求体，那么在大流量下，内存使用量会急剧上升，最终导致内存溢出，系统崩溃。

今天我就跟大家分享一套基于 Spring Cloud Gateway 的大流量内存溢出防护方案，通过流式转发替代全量缓冲，让 Gateway 在高并发下依然稳定运行。

为什么会内存溢出？

先来说说 Gateway 内存溢出的根本原因。在默认情况下，Spring Cloud Gateway 处理请求时会：

1. 全量读取请求体：将整个请求体读取到内存中
2. 创建完整的请求对象：为每个请求创建包含完整请求体的对象
3. 缓冲响应数据：将后端服务的响应也完整缓冲到内存中
4. 内存使用无上限：当请求体较大或并发请求较多时，内存使用量会持续增长

特别是在以下场景中，内存溢出的风险更高：

• 大文件上传：客户端上传大文件时，请求体可能达到数 MB 甚至数 GB
• 突发流量：促销活动、秒杀等场景下，短时间内产生大量并发请求
• 后端响应缓慢：当后端服务响应缓慢时，Gateway 会积压大量请求
• 长连接场景：WebSocket、SSE 等长连接场景下，连接数持续增长

整体架构设计

我们的 Gateway 内存溢出防护方案由以下几个核心组件构成：

1. 流式请求处理：使用 Flux 流式处理请求体，避免全量缓冲
2. 响应式编程：采用响应式编程模型，提高并发处理能力
3. 内存限制：设置合理的内存使用限制，防止内存无限制增长
4. 背压机制：实现背压控制，避免上游流量超过下游处理能力
5. 监控告警：实时监控内存使用情况，及时发现并处理异常

让我们看看如何在 Spring Cloud Gateway 中实现这套防护系统：

1. 引入依赖

首先在 pom.xml 中引入必要的依赖：

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

2. 配置 Gateway

在 application.yml 中配置 Gateway：

spring:
  cloud:
    gateway:
      httpclient:
        pool:
          max-connections: 10000
          max-idle-time: 30000
        connect-timeout: 5000
        response-timeout: 30000
        wiretap: false
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - name: RequestSize
              args:
                maxSize: 5000000
            - name: StreamRequest
            - name: StreamResponse

# 内存限制配置
server:
  max-http-header-size: 8192
  tomcat:
    max-swallow-size: 2097152
    max-http-post-size: 2097152

# 监控配置
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics
  endpoint:
    health:
      show-details: always

3. 创建流式请求过滤器

实现流式请求过滤器，避免全量缓冲请求体：

@Component
public class StreamRequestGatewayFilterFactory extends AbstractGatewayFilterFactory<StreamRequestGatewayFilterFactory.Config> {
    
    public StreamRequestGatewayFilterFactory() {
        super(Config.class);
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            
            // 检查请求方法是否允许携带请求体
            if (request.getMethod() == HttpMethod.GET || request.getMethod() == HttpMethod.DELETE) {
                return chain.filter(exchange);
            }
            
            // 获取请求体的 Flux<DataBuffer>
            Flux<DataBuffer> body = request.getBody();
            
            // 创建新的请求，使用流式请求体
            ServerHttpRequest newRequest = request.mutate()
                .body(body)
                .build();
            
            // 继续处理请求
            return chain.filter(exchange.mutate().request(newRequest).build());
        };
    }
    
    public static class Config {
        // 配置参数
    }
}

4. 创建流式响应过滤器

实现流式响应过滤器，避免全量缓冲响应体：

@Component
public class StreamResponseGatewayFilterFactory extends AbstractGatewayFilterFactory<StreamResponseGatewayFilterFactory.Config> {
    
    public StreamResponseGatewayFilterFactory() {
        super(Config.class);
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            return chain.filter(exchange).then(Mono.fromRunnable(() -> {
                ServerHttpResponse response = exchange.getResponse();
                // 响应已经是流式处理，无需额外处理
                // 这里可以添加响应监控逻辑
            }));
        };
    }
    
    public static class Config {
        // 配置参数
    }
}

5. 创建请求大小限制过滤器

实现请求大小限制过滤器，防止大请求体导致内存溢出：

@Component
public class RequestSizeGatewayFilterFactory extends AbstractGatewayFilterFactory<RequestSizeGatewayFilterFactory.Config> {
    
    public RequestSizeGatewayFilterFactory() {
        super(Config.class);
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            ServerHttpRequest request = exchange.getRequest();
            
            // 检查请求方法是否允许携带请求体
            if (request.getMethod() == HttpMethod.GET || request.getMethod() == HttpMethod.DELETE) {
                return chain.filter(exchange);
            }
            
            // 获取请求体的 Flux<DataBuffer>
            Flux<DataBuffer> body = request.getBody();
            
            // 限制请求体大小
            AtomicLong requestSize = new AtomicLong(0);
            Flux<DataBuffer> limitedBody = body.doOnNext(dataBuffer -> {
                requestSize.addAndGet(dataBuffer.readableByteCount());
                if (requestSize.get() > config.getMaxSize()) {
                    throw new RequestSizeExceededException("Request size exceeds limit: " + config.getMaxSize());
                }
            });
            
            // 创建新的请求，使用限流后的请求体
            ServerHttpRequest newRequest = request.mutate()
                .body(limitedBody)
                .build();
            
            // 继续处理请求
            return chain.filter(exchange.mutate().request(newRequest).build());
        };
    }
    
    public static class Config {
        private long maxSize = 10 * 1024 * 1024; // 默认 10MB
        
        public long getMaxSize() {
            return maxSize;
        }
        
        public void setMaxSize(long maxSize) {
            this.maxSize = maxSize;
        }
    }
    
    public static class RequestSizeExceededException extends RuntimeException {
        public RequestSizeExceededException(String message) {
            super(message);
        }
    }
}

6. 创建全局异常处理器

实现全局异常处理器，处理请求大小超限等异常：

@RestControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(RequestSizeGatewayFilterFactory.RequestSizeExceededException.class)
    public ResponseEntity<ErrorResponse> handleRequestSizeExceededException(RequestSizeGatewayFilterFactory.RequestSizeExceededException e) {
        ErrorResponse errorResponse = new ErrorResponse();
        errorResponse.setCode(413);
        errorResponse.setMessage(e.getMessage());
        return ResponseEntity.status(HttpStatus.PAYLOAD_TOO_LARGE).body(errorResponse);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleException(Exception e) {
        ErrorResponse errorResponse = new ErrorResponse();
        errorResponse.setCode(500);
        errorResponse.setMessage("Internal Server Error");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
    
    @Data
    public static class ErrorResponse {
        private int code;
        private String message;
    }
}

7. 创建内存监控服务

实现内存监控服务，实时监控内存使用情况：

@Service
@Slf4j
public class MemoryMonitorService {
    
    private final AtomicLong requestCount = new AtomicLong(0);
    private final AtomicLong responseCount = new AtomicLong(0);
    private final AtomicLong errorCount = new AtomicLong(0);
    
    @Scheduled(fixedRate = 5000)
    public void monitorMemory() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory() / (1024 * 1024);
        long freeMemory = runtime.freeMemory() / (1024 * 1024);
        long usedMemory = totalMemory - freeMemory;
        double memoryUsage = (double) usedMemory / totalMemory * 100;
        
        log.info("内存使用情况: 总内存={}MB, 已使用={}MB, 空闲={}MB, 使用百分比={:.2f}%",
                 totalMemory, usedMemory, freeMemory, memoryUsage);
        
        log.info("请求统计: 请求数={}, 响应数={}, 错误数={}",
                 requestCount.get(), responseCount.get(), errorCount.get());
        
        // 内存使用超过 80% 时告警
        if (memoryUsage > 80) {
            log.warn("内存使用过高: {:.2f}%", memoryUsage);
            // 发送告警通知
        }
    }
    
    public void incrementRequestCount() {
        requestCount.incrementAndGet();
    }
    
    public void incrementResponseCount() {
        responseCount.incrementAndGet();
    }
    
    public void incrementErrorCount() {
        errorCount.incrementAndGet();
    }
}

8. 创建全局过滤器

实现全局过滤器，记录请求和响应统计：

@Component
public class MetricsGlobalFilter implements GlobalFilter, Ordered {
    
    @Autowired
    private MemoryMonitorService memoryMonitorService;
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 增加请求计数
        memoryMonitorService.incrementRequestCount();
        
        return chain.filter(exchange).doFinally(signalType -> {
            // 增加响应计数
            memoryMonitorService.incrementResponseCount();
            
            // 检查响应状态码
            HttpStatus statusCode = exchange.getResponse().getStatusCode();
            if (statusCode != null && statusCode.isError()) {
                memoryMonitorService.incrementErrorCount();
            }
        });
    }
    
    @Override
    public int getOrder() {
        return -10000;
    }
}

9. 配置 WebClient

优化 WebClient 配置，提高并发处理能力：

@Configuration
public class WebClientConfig {
    
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
            .clientConnector(new ReactorClientHttpConnector(HttpClient.create()
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)
                .responseTimeout(Duration.ofSeconds(30))
                .poolResources(PoolResources.create("web-client", 10000))
                .doOnConnected(conn -> {
                    conn.addHandlerLast(new ReadTimeoutHandler(30));
                    conn.addHandlerLast(new WriteTimeoutHandler(30));
                }))
            .build();
    }
}

10. 配置 JVM 参数

设置合理的 JVM 参数，优化内存使用：

java -Xms4g -Xmx4g -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m \
     -XX:+UseG1GC -XX:MaxGCPauseMillis=200 \
     -XX:+ParallelRefProcEnabled -XX:+DisableExplicitGC \
     -XX:+AlwaysPreTouch -XX:G1HeapRegionSize=8m \
     -jar gateway-service.jar

实际应用效果

通过这套方案，我们可以实现：

优化前：

• 大文件上传时，内存使用量急剧上升
• 并发请求达到 1000 QPS 时，内存使用超过 80%
• 突发流量下，容易出现内存溢出
• 响应时间随着并发增加而显著增长

优化后：

• 大文件上传时，内存使用稳定
• 并发请求达到 5000 QPS 时，内存使用保持在 50% 以下
• 突发流量下，系统依然稳定
• 响应时间在高并发下保持稳定

性能测试结果

测试环境

• 服务器：8 核 16G
• JVM 配置：-Xms8g -Xmx8g
• 测试工具：JMeter
• 测试场景：大文件上传（5MB）、并发请求

测试结果

大文件上传测试

最佳实践建议

1. 使用流式处理：

   • 对请求体和响应体使用 Flux 流式处理
   • 避免全量缓冲，减少内存使用
   • 特别适合大文件上传下载场景

2. 设置合理的内存限制：

   • 配置请求体大小限制
   • 设置 JVM 内存参数
   • 监控内存使用情况

3. 优化连接池：

   • 配置合理的连接池大小
   • 设置连接超时和响应超时
   • 定期清理空闲连接

4. 实现背压控制：

   • 使用响应式编程模型
   • 实现流量控制，避免上游流量超过下游处理能力
   • 对突发流量进行削峰填谷

5. 监控和告警：

   • 实时监控内存使用情况
   • 设置内存使用告警阈值
   • 监控请求量和响应时间

6. 代码优化：

   • 避免在过滤器中进行耗时操作
   • 合理使用缓存，避免重复计算
   • 及时释放资源，避免内存泄漏

7. 部署策略：

   • 使用容器化部署，便于水平扩展
   • 配置合理的资源限制
   • 实现健康检查和自动恢复

高级功能扩展

1. 动态内存限制

根据系统负载动态调整内存限制：

@Service
public class DynamicMemoryLimitService {
    
    @Value("${gateway.memory.limit.max:80}")
    private int maxMemoryLimit;
    
    @Value("${gateway.memory.limit.min:40}")
    private int minMemoryLimit;
    
    public int getCurrentMemoryLimit() {
        Runtime runtime = Runtime.getRuntime();
        long totalMemory = runtime.totalMemory();
        long freeMemory = runtime.freeMemory();
        double memoryUsage = (double) (totalMemory - freeMemory) / totalMemory * 100;
        
        // 根据内存使用情况动态调整限制
        if (memoryUsage > 70) {
            return minMemoryLimit;
        } else if (memoryUsage > 50) {
            return (maxMemoryLimit + minMemoryLimit) / 2;
        } else {
            return maxMemoryLimit;
        }
    }
}

2. 智能路由

根据系统负载和内存使用情况智能路由请求：

@Component
public class SmartRoutePredicateFactory extends AbstractRoutePredicateFactory<SmartRoutePredicateFactory.Config> {
    
    @Autowired
    private DynamicMemoryLimitService memoryLimitService;
    
    public SmartRoutePredicateFactory() {
        super(Config.class);
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            int memoryLimit = memoryLimitService.getCurrentMemoryLimit();
            // 根据内存限制决定是否路由到该服务
            return memoryLimit > config.getThreshold();
        };
    }
    
    public static class Config {
        private int threshold = 50;
        
        public int getThreshold() {
            return threshold;
        }
        
        public void setThreshold(int threshold) {
            this.threshold = threshold;
        }
    }
}

3. 流量控制

实现基于令牌桶的流量控制：

@Component
public class RateLimitGatewayFilterFactory extends AbstractGatewayFilterFactory<RateLimitGatewayFilterFactory.Config> {
    
    private final RateLimiter rateLimiter;
    
    public RateLimitGatewayFilterFactory() {
        super(Config.class);
        this.rateLimiter = RateLimiter.create(1000); // 默认每秒 1000 个请求
    }
    
    @Override
    public GatewayFilter apply(Config config) {
        RateLimiter limiter = RateLimiter.create(config.getQps());
        
        return (exchange, chain) -> {
            if (limiter.tryAcquire()) {
                return chain.filter(exchange);
            } else {
                exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                return exchange.getResponse().setComplete();
            }
        };
    }
    
    public static class Config {
        private int qps = 1000;
        
        public int getQps() {
            return qps;
        }
        
        public void setQps(int qps) {
            this.qps = qps;
        }
    }
}

总结

通过 Spring Cloud Gateway 的流式处理和响应式编程，我们可以构建一套高并发、低内存使用的 API 网关系统：

• 内存使用降低：流式处理避免了全量缓冲，内存使用显著降低
• 并发能力提升：响应式编程模型提高了并发处理能力
• 系统稳定性增强：内存使用稳定，避免了内存溢出风险
• 响应时间稳定：在高并发下依然保持稳定的响应时间

这套方案特别适合处理大文件上传、突发流量等场景，能够让 API 网关在高并发下依然稳定运行。通过合理的配置和优化，可以进一步提升系统的性能和可靠性。

在实际项目中，建议根据具体的业务需求和系统环境，调整配置参数，以达到最佳的性能效果。同时，要注意监控系统状态，及时发现和处理异常情况。

希望这篇文章能对你有所帮助，如果你觉得有用，欢迎关注"服务端技术精选"，我会持续分享更多实用的技术干货。