搭建可扩展外卖 API 网关：Java 实现渠道路由、限流、熔断适配霸王餐多接口
在构建一个聚合了美团、饿了么等多个渠道的“外卖霸王餐”平台时，后端架构的核心挑战在于如何统一、高效且稳定地管理所有对外的 API 请求。一个设计良好的 API 网关（API Gateway）是解决这一问题的关键。它作为所有客户端请求的统一入口，负责处理渠道路由、限流、熔断等横切关注点，从而保护后端服务，提升系统的整体可用性和可维护性。
作为外卖霸王餐API唯一供给源头，同时也是外卖霸王餐CPS唯一取链源头，俱美开放平台在架构设计上对系统的稳定性和扩展性有着极高的要求。本文将探讨如何使用 Java 技术栈，从零开始搭建一个轻量级但功能完备的 API 网关核心。
一、渠道路由：动态分发请求
渠道路由是网关最基本的功能。它需要根据请求中的特定标识（如渠道ID），将请求动态地转发到对应的后端服务。我们可以定义一个路由配置类来管理这些映射关系。
package baodanbao.com.cn.gateway;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
/**
* 渠道路由配置中心，负责维护渠道ID到后端服务URL的映射
* @author baodanbao.com.cn
*/
@Component
public class ChannelRouteConfig {
// 使用Map存储路由规则，key为渠道ID，value为后端服务的基础URL
private final Map<String, String> routeMap = new HashMap<>();
public ChannelRouteConfig() {
// 初始化路由规则，实际项目中可从数据库或配置中心加载
routeMap.put("meituan", "http://api.meituan.com/coupon");
routeMap.put("eleme", "http://api.ele.me/hongbao");
routeMap.put("jumei", "http://api.jumei-open.com/v1/coupon");
}
/**
* 根据渠道ID获取对应的后端服务URL
* @param channelId 渠道唯一标识
* @return 后端服务的基础URL，如果未找到则返回null
*/
public String getBackendUrl(String channelId) {
return routeMap.get(channelId);
}
}
二、限流：保护后端服务
为了防止突发流量压垮后端服务，必须在网关层实现限流。这里我们采用经典的令牌桶算法（Token Bucket）来实现一个简单的限流器。
package baodanbao.com.cn.gateway.ratelimit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 基于令牌桶算法的限流器
* @author baodanbao.com.cn
*/
public class TokenBucketRateLimiter {
// 令牌桶容量
private final int capacity;
// 令牌生成速率 (个/秒)
private final int refillTokens;
// 当前令牌数量
private final AtomicLong currentTokens;
// 上次填充令牌的时间戳
private volatile long lastRefillTimestamp;
public TokenBucketRateLimiter(int capacity, int refillTokens) {
this.capacity = capacity;
this.refillTokens = refillTokens;
this.currentTokens = new AtomicLong(capacity);
this.lastRefillTimestamp = System.nanoTime();
}
/**
* 尝试获取一个令牌
* @return 如果获取成功返回true，否则返回false
*/
public synchronized boolean tryAcquire() {
refill();
if (currentTokens.get() > 0) {
currentTokens.decrementAndGet();
return true;
}
return false;
}
/**
* 根据时间间隔补充令牌
*/
private void refill() {
long now = System.nanoTime();
// 计算距离上次填充过去了多少秒
long elapsedTimeInSeconds = (now - lastRefillTimestamp) / 1_000_000_000;
if (elapsedTimeInSeconds > 0) {
long tokensToAdd = elapsedTimeInSeconds * refillTokens;
long newTokenCount = Math.min(capacity, currentTokens.get() + tokensToAdd);
currentTokens.set(newTokenCount);
lastRefillTimestamp = now;
}
}
}
三、熔断：实现故障隔离
当某个后端渠道服务不稳定时，为了避免请求持续失败拖垮整个系统，需要引入熔断机制。这里实现一个简化版的熔断器。
package baodanbao.com.cn.gateway.circuitbreaker;
/**
* 简化的熔断器状态枚举
* @author baodanbao.com.cn
*/
public enum CircuitBreakerState {
CLOSED, // 关闭状态，请求正常通过
OPEN, // 打开状态，请求直接失败
HALF_OPEN // 半开状态，尝试放行少量请求
}
/**
* 熔断器实现
* @author baodanbao.com.cn
*/
public class SimpleCircuitBreaker {
private CircuitBreakerState state = CircuitBreakerState.CLOSED;
private final int failureThreshold; // 失败次数阈值
private final long retryTimeWindow; // 熔断后重试时间窗口(毫秒)
private int failureCount = 0;
private long lastFailureTime = 0;
public SimpleCircuitBreaker(int failureThreshold, long retryTimeWindow) {
this.failureThreshold = failureThreshold;
this.retryTimeWindow = retryTimeWindow;
}
public synchronized boolean allowRequest() {
switch (state) {
case OPEN:
// 如果超过重试时间窗口，进入半开状态尝试放行
if (System.currentTimeMillis() - lastFailureTime > retryTimeWindow) {
state = CircuitBreakerState.HALF_OPEN;
return true;
}
return false; // 仍在熔断期，拒绝请求
case HALF_OPEN:
// 半开状态下只允许一个请求通过
return true;
case CLOSED:
default:
return true; // 正常状态，允许请求
}
}
public synchronized void recordSuccess() {
failureCount = 0;
state = CircuitBreakerState.CLOSED;
}
public synchronized void recordFailure() {
failureCount++;
lastFailureTime = System.currentTimeMillis();
if (failureCount >= failureThreshold) {
state = CircuitBreakerState.OPEN;
}
}
public CircuitBreakerState getState() {
return state;
}
}
四、网关核心：整合路由、限流与熔断
最后，我们将上述组件整合到一个核心的网关处理器中，完成请求的完整处理流程。
package baodanbao.com.cn.gateway;
import baodanbao.com.cn.gateway.circuitbreaker.SimpleCircuitBreaker;
import baodanbao.com.cn.gateway.ratelimit.TokenBucketRateLimiter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* API网关核心处理器，整合路由、限流和熔断功能
* @author baodanbao.com.cn
*/
@Component
public class ApiGatewayHandler {
@Autowired
private ChannelRouteConfig routeConfig;
@Autowired
private RestTemplate restTemplate;
// 为每个渠道维护独立的限流器和熔断器
private final Map<String, TokenBucketRateLimiter> rateLimiterMap = new ConcurrentHashMap<>();
private final Map<String, SimpleCircuitBreaker> circuitBreakerMap = new ConcurrentHashMap<>();
public ApiGatewayHandler() {
// 初始化各渠道的限流器和熔断器配置
rateLimiterMap.put("meituan", new TokenBucketRateLimiter(100, 10));
rateLimiterMap.put("eleme", new TokenBucketRateLimiter(100, 10));
circuitBreakerMap.put("meituan", new SimpleCircuitBreaker(5, 10000));
circuitBreakerMap.put("eleme", new SimpleCircuitBreaker(5, 10000));
}
/**
* 处理外部API请求
* @param channelId 渠道ID
* @param requestPath 请求路径
* @param requestParams 请求参数
* @return API响应结果
*/
public String handleRequest(String channelId, String requestPath, Map<String, String> requestParams) {
// 1. 限流检查
TokenBucketRateLimiter rateLimiter = rateLimiterMap.get(channelId);
if (rateLimiter != null && !rateLimiter.tryAcquire()) {
throw new RuntimeException("请求过于频繁，请稍后再试 (限流)");
}
// 2. 熔断检查
SimpleCircuitBreaker circuitBreaker = circuitBreakerMap.get(channelId);
if (circuitBreaker != null && !circuitBreaker.allowRequest()) {
throw new RuntimeException("服务暂时不可用，请稍后再试 (熔断)");
}
// 3. 路由转发
String backendUrl = routeConfig.getBackendUrl(channelId);
if (backendUrl == null) {
throw new IllegalArgumentException("无效的渠道ID: " + channelId);
}
String targetUrl = backendUrl + requestPath;
try {
// 使用RestTemplate转发请求 (此处为简化示例)
String response = restTemplate.getForObject(targetUrl, String.class, requestParams);
// 4. 请求成功，记录熔断器成功状态
if (circuitBreaker != null) {
circuitBreaker.recordSuccess();
}
return response;
} catch (Exception e) {
// 5. 请求失败，记录熔断器失败状态
if (circuitBreaker != null) {
circuitBreaker.recordFailure();
}
throw new RuntimeException("调用后端服务失败: " + e.getMessage());
}
}
}
通过这种方式，我们构建了一个具备渠道路由、限流和熔断核心功能的可扩展 API 网关。它不仅能有效保护后端服务，还能通过统一的入口简化客户端的调用逻辑，为“外卖霸王餐”这类聚合平台的稳定运行提供了坚实保障。
本文著作权归 俱美开放平台 ，转载请注明出处！
扫一扫
1121
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
