一、核心理念理解
熔断降级 vs 限流：
-
熔断：服务异常时快速失败，防止级联故障
-
降级：服务压力大时返回默认值或简化逻辑
-
限流：控制请求速率，保护系统不被压垮
-
自适应：根据实时指标动态调整策略
二、熔断降级机制详解
2.1 熔断器模式（Circuit Breaker）
java
复制
下载
/**
* 熔断器状态机
* 闭合(Closed) -> 打开(Open) -> 半开(Half-Open)
*/
public enum CircuitBreakerState {
CLOSED, // 正常状态，请求正常通过
OPEN, // 熔断状态，快速失败
HALF_OPEN // 试探状态，部分请求通过
}
/**
* 熔断器核心实现
*/
public class CircuitBreaker {
// 配置参数
private int failureThreshold = 5; // 失败阈值
private long timeout = 5000; // 超时时间(ms)
private long retryTimePeriod = 10000; // 重试间隔(ms)
// 状态变量
private AtomicInteger failureCount = new AtomicInteger(0);
private AtomicLong lastFailureTime = new AtomicLong(0);
private AtomicReference<CircuitBreakerState> state =
new AtomicReference<>(CircuitBreakerState.CLOSED);
/**
* 执行受保护的方法
*/
public <T> T execute(Callable<T> protectedCode, Callable<T> fallback) {
// 1. 检查熔断器状态
if (state.get() == CircuitBreakerState.OPEN) {
// 检查是否应该进入半开状态
if (System.currentTimeMillis() - lastFailureTime.get() > retryTimePeriod) {
state.compareAndSet(CircuitBreakerState.OPEN, CircuitBreakerState.HALF_OPEN);
} else {
// 熔断状态，直接执行降级逻辑
return executeFallback(fallback);
}
}
// 2. 执行业务逻辑
try {
T result = protectedCode.call();
// 3. 成功处理：重置失败计数（如果是半开状态则关闭熔断器）
if (state.get() == CircuitBreakerState.HALF_OPEN) {
reset();
}
return result;
} catch (Exception e) {
// 4. 异常处理：记录失败
recordFailure();
// 5. 执行降级逻辑
return executeFallback(fallback);
}
}
private void recordFailure() {
int count = failureCount.incrementAndGet();
lastFailureTime.set(System.currentTimeMillis());
// 达到失败阈值，打开熔断器
if (count >= failureThreshold &&
state.compareAndSet(CircuitBreakerState.CLOSED, CircuitBreakerState.OPEN)) {
System.out.println("熔断器打开！失败次数: " + count);
}
}
private void reset() {
failureCount.set(0);
state.set(CircuitBreakerState.CLOSED);
System.out.println("熔断器重置为关闭状态");
}
private <T> T executeFallback(Callable<T> fallback) {
try {
return fallback.call();
} catch (Exception e) {
throw new RuntimeException("降级逻辑执行失败", e);
}
}
}2.2 降级策略分类
java
复制
下载
/**
* 降级策略工厂
*/
public class FallbackStrategyFactory {
/**
* 1. 快速失败降级
* 直接返回默认值或抛出自定义异常
*/
public static class FastFailFallback<T> implements FallbackStrategy<T> {
private final T defaultValue;
@Override
public T fallback() {
return defaultValue;
}
}
/**
* 2. 静默降级
* 不执行操作，返回空结果
*/
public static class SilentFallback<T> implements FallbackStrategy<T> {
@Override
public T fallback() {
return null;
}
}
/**
* 3. 备选服务降级
* 调用备用服务或缓存数据
*/
public static class AlternativeServiceFallback<T> implements FallbackStrategy<T> {
private final Callable<T> alternativeService;
@Override
public T fallback() throws Exception {
return alternativeService.call();
}
}
/**
* 4. 排队降级
* 将请求放入队列稍后处理
*/
public static class QueueFallback<T> implements FallbackStrategy<T> {
private final BlockingQueue<Runnable> queue;
@Override
public T fallback() {
// 放入队列异步处理
queue.offer(() -> {
// 稍后重试逻辑
});
return null;
}
}
}篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
三、限流算法详解
3.1 基础限流算法
java
复制
下载
/**
* 令牌桶限流器
*/
public class TokenBucketRateLimiter {
private final int capacity; // 桶容量
private final int refillTokens; // 每次补充的令牌数
private final long refillPeriodMs; // 补充周期(ms)
private double tokens; // 当前令牌数
private long lastRefillTime; // 上次补充时间
public TokenBucketRateLimiter(int capacity, int refillTokens, long refillPeriodMs) {
this.capacity = capacity;
this.refillTokens = refillTokens;
this.refillPeriodMs = refillPeriodMs;
this.tokens = capacity;
this.lastRefillTime = System.currentTimeMillis();
}
public synchronized boolean tryAcquire(int permits) {
// 1. 补充令牌
refillTokens();
// 2. 检查是否有足够令牌
if (tokens >= permits) {
tokens -= permits;
return true;
}
return false;
}
private void refillTokens() {
long currentTime = System.currentTimeMillis();
long timeElapsed = currentTime - lastRefillTime;
if (timeElapsed > refillPeriodMs) {
int refillCount = (int) (timeElapsed / refillPeriodMs);
tokens = Math.min(capacity, tokens + refillCount * refillTokens);
lastRefillTime = currentTime;
}
}
}
/**
* 漏桶限流器
*/
public class LeakyBucketRateLimiter {
private final int capacity; // 桶容量
private final long leakRateMs; // 漏水速率(ms/个)
private double water; // 当前水量
private long lastLeakTime; // 上次漏水时间
public LeakyBucketRateLimiter(int capacity, int leakRatePerSecond) {
this.capacity = capacity;
this.leakRateMs = 1000 / leakRatePerSecond; // 转换为毫秒
this.water = 0;
this.lastLeakTime = System.currentTimeMillis();
}
public synchronized boolean tryAcquire() {
// 1. 漏水
leakWater();
// 2. 检查是否溢出
if (water < capacity) {
water += 1;
return true;
}
return false;
}
private void leakWater() {
long currentTime = System.currentTimeMillis();
long timeElapsed = currentTime - lastLeakTime;
if (timeElapsed > 0) {
double leakAmount = timeElapsed / (double) leakRateMs;
water = Math.max(0, water - leakAmount);
lastLeakTime = currentTime;
}
}
}3.2 滑动窗口限流
java
复制
下载
/**
* 滑动时间窗口限流器
*/
public class SlidingWindowRateLimiter {
private final int limit; // 时间窗口内最大请求数
private final long windowSizeMs; // 时间窗口大小(ms)
private final int segmentCount; // 窗口分段数
private final LinkedList<WindowSegment> segments = new LinkedList<>();
private final Object lock = new Object();
static class WindowSegment {
long startTime;
int count;
}
public SlidingWindowRateLimiter(int limit, long windowSizeMs, int segmentCount) {
this.limit = limit;
this.windowSizeMs = windowSizeMs;
this.segmentCount = segmentCount;
}
public boolean tryAcquire() {
synchronized (lock) {
long currentTime = System.currentTimeMillis();
// 1. 清理过期分段
long windowStart = currentTime - windowSizeMs;
while (!segments.isEmpty() && segments.getFirst().startTime < windowStart) {
segments.removeFirst();
}
// 2. 计算当前窗口内请求总数
int totalCount = 0;
for (WindowSegment segment : segments) {
totalCount += segment.count;
}
// 3. 判断是否超过限制
if (totalCount >= limit) {
return false;
}
// 4. 找到或创建当前时间段的分段
long segmentSize = windowSizeMs / segmentCount;
long segmentStart = currentTime - (currentTime % segmentSize);
WindowSegment currentSegment = null;
if (!segments.isEmpty() && segments.getLast().startTime == segmentStart) {
currentSegment = segments.getLast();
} else {
currentSegment = new WindowSegment();
currentSegment.startTime = segmentStart;
segments.addLast(currentSegment);
}
currentSegment.count++;
return true;
}
}
}四、自适应限流算法
4.1 基于响应时间的自适应限流
java
复制
下载
/**
* 自适应限流器 - 根据响应时间动态调整
*/
public class AdaptiveRateLimiter {
private final RateLimiter rateLimiter;
private final int initialRate; // 初始速率
private final double minRateFactor; // 最低速率比例
private final double maxRateFactor; // 最高速率比例
// 统计指标
private final MovingAverage responseTimeAvg = new MovingAverage(10);
private final double targetResponseTime; // 目标响应时间(ms)
public AdaptiveRateLimiter(int initialRate, double targetResponseTime) {
this.initialRate = initialRate;
this.targetResponseTime = targetResponseTime;
this.minRateFactor = 0.5;
this.maxRateFactor = 2.0;
this.rateLimiter = RateLimiter.create(initialRate);
}
public void recordResponseTime(long responseTimeMs) {
// 1. 记录响应时间
responseTimeAvg.add(responseTimeMs);
// 2. 计算调整因子
double avgResponseTime = responseTimeAvg.getAverage();
double adjustmentFactor = calculateAdjustmentFactor(avgResponseTime);
// 3. 调整限流速率
double newRate = initialRate * adjustmentFactor;
double boundedRate = Math.max(initialRate * minRateFactor,
Math.min(initialRate * maxRateFactor, newRate));
rateLimiter.setRate(boundedRate);
System.out.printf("平均响应时间: %.2fms, 调整因子: %.2f, 新速率: %.2f/s%n",
avgResponseTime, adjustmentFactor, boundedRate);
}
private double calculateAdjustmentFactor(double avgResponseTime) {
if (avgResponseTime <= targetResponseTime) {
// 响应时间良好，可以适当提高速率
double ratio = targetResponseTime / avgResponseTime;
return Math.min(1.2, ratio); // 最大提高20%
} else {
// 响应时间过长，需要降低速率
double ratio = targetResponseTime / avgResponseTime;
return Math.max(0.8, ratio); // 最低降低20%
}
}
public boolean tryAcquire() {
return rateLimiter.tryAcquire();
}
/**
* 移动平均值计算
*/
static class MovingAverage {
private final double[] values;
private int index = 0;
private int count = 0;
MovingAverage(int size) {
this.values = new double[size];
}
void add(double value) {
values[index] = value;
index = (index + 1) % values.length;
if (count < values.length) count++;
}
double getAverage() {
if (count == 0) return 0;
double sum = 0;
for (int i = 0; i < count; i++) {
sum += values[i];
}
return sum / count;
}
}
}4.2 基于系统负载的自适应限流
java
复制
下载
/**
* 系统负载感知限流器
*/
public class LoadAwareRateLimiter {
private final RateLimiter rateLimiter;
private final int initialRate;
// 监控指标
private final SystemMetricsCollector metricsCollector;
private final double cpuThreshold = 0.8; // CPU使用率阈值
private final double memoryThreshold = 0.8; // 内存使用率阈值
private final double loadThreshold = 2.0; // 系统负载阈值
public LoadAwareRateLimiter(int initialRate) {
this.initialRate = initialRate;
this.rateLimiter = RateLimiter.create(initialRate);
this.metricsCollector = new SystemMetricsCollector();
// 启动监控线程
startMonitoring();
}
private void startMonitoring() {
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
scheduler.scheduleAtFixedRate(() -> {
try {
adjustRateBasedOnSystemLoad();
} catch (Exception e) {
// 忽略监控异常
}
}, 1, 1, TimeUnit.SECONDS);
}
private void adjustRateBasedOnSystemLoad() {
SystemMetrics metrics = metricsCollector.collect();
// 计算负载因子
double loadFactor = calculateLoadFactor(metrics);
// 根据负载调整速率
double adjustedRate = initialRate * loadFactor;
rateLimiter.setRate(adjustedRate);
System.out.printf("系统负载 - CPU: %.2f%%, 内存: %.2f%%, 负载: %.2f, 调整因子: %.2f, 新速率: %.2f/s%n",
metrics.cpuUsage * 100, metrics.memoryUsage * 100,
metrics.systemLoad, loadFactor, adjustedRate);
}
private double calculateLoadFactor(SystemMetrics metrics) {
double factor = 1.0;
// CPU使用率过高时降低速率
if (metrics.cpuUsage > cpuThreshold) {
factor *= (1 - (metrics.cpuUsage - cpuThreshold));
}
// 内存使用率过高时降低速率
if (metrics.memoryUsage > memoryThreshold) {
factor *= (1 - (metrics.memoryUsage - memoryThreshold));
}
// 系统负载过高时降低速率
if (metrics.systemLoad > loadThreshold) {
factor *= (loadThreshold / metrics.systemLoad);
}
// 确保速率不会降得过低
return Math.max(0.1, Math.min(2.0, factor));
}
static class SystemMetrics {
double cpuUsage; // CPU使用率 (0-1)
double memoryUsage; // 内存使用率 (0-1)
double systemLoad; // 系统平均负载
}
static class SystemMetricsCollector {
SystemMetrics collect() {
SystemMetrics metrics = new SystemMetrics();
// 这里简化实现，实际应从操作系统获取
metrics.cpuUsage = getCpuUsage();
metrics.memoryUsage = getMemoryUsage();
metrics.systemLoad = getSystemLoad();
return metrics;
}
private native double getCpuUsage();
private native double getMemoryUsage();
private native double getSystemLoad();
}
}五、生产级综合方案
5.1 RPC框架集成实现
java
复制
下载
/**
* RPC调用熔断降级限流拦截器
*/
@Slf4j
public class RpcCircuitBreakerInterceptor implements ClientInterceptor {
// 服务维度熔断器映射
private final ConcurrentHashMap<String, CircuitBreaker> circuitBreakers =
new ConcurrentHashMap<>();
// 服务维度限流器映射
private final ConcurrentHashMap<String, AdaptiveRateLimiter> rateLimiters =
new ConcurrentHashMap<>();
// 配置管理器
private final ConfigManager configManager;
// 降级策略注册表
private final FallbackRegistry fallbackRegistry;
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(
MethodDescriptor<ReqT, RespT> method,
CallOptions callOptions,
Channel next) {
String serviceName = method.getFullMethodName();
return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(
next.newCall(method, callOptions)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
try {
// 1. 熔断器检查
CircuitBreaker circuitBreaker = getOrCreateCircuitBreaker(serviceName);
if (circuitBreaker.isOpen()) {
handleCircuitBreakerOpen(serviceName, responseListener);
return;
}
// 2. 限流器检查
AdaptiveRateLimiter rateLimiter = getOrCreateRateLimiter(serviceName);
if (!rateLimiter.tryAcquire()) {
handleRateLimitExceeded(serviceName, responseListener);
return;
}
// 3. 执行实际RPC调用（带熔断器保护）
long startTime = System.currentTimeMillis();
circuitBreaker.execute(() -> {
super.start(new ForwardingClientCallListener<RespT>(
responseListener) {
@Override
public void onClose(Status status, Metadata trailers) {
long responseTime = System.currentTimeMillis() - startTime;
// 记录响应时间用于自适应限流
rateLimiter.recordResponseTime(responseTime);
// 根据响应状态更新熔断器
if (!status.isOk()) {
circuitBreaker.recordFailure();
} else {
circuitBreaker.recordSuccess();
}
super.onClose(status, trailers);
}
@Override
public void onMessage(RespT message) {
super.onMessage(message);
}
}, headers);
return null;
}, () -> {
// 降级逻辑
return executeFallback(serviceName, method, headers);
});
} catch (Exception e) {
log.error("RPC调用拦截器异常", e);
responseListener.onClose(Status.INTERNAL
.withDescription("拦截器异常")
.withCause(e), new Metadata());
}
}
private RespT executeFallback(String serviceName,
MethodDescriptor<ReqT, RespT> method,
Metadata headers) {
// 获取降级策略
FallbackStrategy<RespT> fallback = fallbackRegistry.getFallback(serviceName);
if (fallback != null) {
try {
return fallback.fallback();
} catch (Exception e) {
log.warn("降级逻辑执行失败: {}", serviceName, e);
}
}
// 默认降级：抛出自定义异常
throw new ServiceDegradedException("服务降级: " + serviceName);
}
};
}
private CircuitBreaker getOrCreateCircuitBreaker(String serviceName) {
return circuitBreakers.computeIfAbsent(serviceName, name -> {
CircuitBreakerConfig config = configManager.getCircuitBreakerConfig(name);
return new CircuitBreaker(config);
});
}
private AdaptiveRateLimiter getOrCreateRateLimiter(String serviceName) {
return rateLimiters.computeIfAbsent(serviceName, name -> {
RateLimiterConfig config = configManager.getRateLimiterConfig(name);
return new AdaptiveRateLimiter(config.getInitialRate(),
config.getTargetResponseTime());
});
}
private void handleCircuitBreakerOpen(String serviceName,
ClientCall.Listener<RespT> responseListener) {
log.warn("服务熔断: {}", serviceName);
responseListener.onClose(
Status.UNAVAILABLE.withDescription("服务熔断: " + serviceName),
new Metadata()
);
}
private void handleRateLimitExceeded(String serviceName,
ClientCall.Listener<RespT> responseListener) {
log.warn("服务限流: {}", serviceName);
responseListener.onClose(
Status.RESOURCE_EXHAUSTED.withDescription("请求限流: " + serviceName),
new Metadata()
);
}
}5.2 动态配置管理
java
复制
下载
/**
* 动态配置管理器
*/
@Component
public class DynamicConfigManager {
@Resource
private ConfigService configService;
// 配置缓存
private final Map<String, CircuitBreakerConfig> circuitBreakerConfigs =
new ConcurrentHashMap<>();
private final Map<String, RateLimiterConfig> rateLimiterConfigs =
new ConcurrentHashMap<>();
// 配置监听器
private final List<ConfigChangeListener> listeners = new CopyOnWriteArrayList<>();
@PostConstruct
public void init() {
// 从配置中心加载初始配置
loadInitialConfigs();
// 监听配置变更
configService.addListener(new ConfigChangeListener() {
@Override
public void onChange(ConfigChangeEvent event) {
handleConfigChange(event);
}
});
}
public CircuitBreakerConfig getCircuitBreakerConfig(String serviceName) {
return circuitBreakerConfigs.computeIfAbsent(serviceName,
name -> getDefaultCircuitBreakerConfig());
}
public RateLimiterConfig getRateLimiterConfig(String serviceName) {
return rateLimiterConfigs.computeIfAbsent(serviceName,
name -> getDefaultRateLimiterConfig());
}
private void handleConfigChange(ConfigChangeEvent event) {
for (ConfigChange change : event.getChanges()) {
String key = change.getKey();
if (key.startsWith("circuitbreaker.")) {
updateCircuitBreakerConfig(key, change.getNewValue());
} else if (key.startsWith("ratelimiter.")) {
updateRateLimiterConfig(key, change.getNewValue());
}
}
// 通知监听器
notifyConfigChange();
}
private void notifyConfigChange() {
for (ConfigChangeListener listener : listeners) {
try {
listener.onChange(new ConfigChangeEvent());
} catch (Exception e) {
log.error("通知配置变更监听器失败", e);
}
}
}
/**
* 配置类定义
*/
@Data
@ConfigurationProperties(prefix = "circuitbreaker")
public static class CircuitBreakerConfig {
private int failureThreshold = 10; // 失败阈值
private long timeout = 1000; // 超时时间(ms)
private long retryTimePeriod = 5000; // 重试间隔(ms)
private double failureRateThreshold = 0.5; // 失败率阈值
private int minimumNumberOfCalls = 20; // 最小调用次数
}
@Data
@ConfigurationProperties(prefix = "ratelimiter")
public static class RateLimiterConfig {
private int initialRate = 100; // 初始速率(QPS)
private double targetResponseTime = 100; // 目标响应时间(ms)
private int warmupPeriod = 10; // 预热时间(s)
private double maxBurstSeconds = 1.0; // 最大突发秒数
}
}六、面试回答要点
6.1 回答结构建议
-
概念区分：先清晰定义熔断、降级、限流的概念和区别
-
算法原理：详细说明各种算法的实现原理
-
应用场景：结合具体场景说明如何选择和组合使用
-
实践经验：分享实际项目中的最佳实践和踩坑经验
-
发展趋势：提到服务网格、云原生环境下的新变化
6.2 常见面试问题准备
Q1：熔断和降级有什么区别？
text
复制
下载
熔断：关注服务可用性，快速失败防止级联故障
降级：关注服务质量，压力大时提供简化服务
关系：熔断通常会触发降级，但降级不一定需要熔断Q2：如何选择合适的限流算法？
text
复制
下载
- 固定窗口：简单场景，对精度要求不高
- 滑动窗口：需要更精确的控制
- 令牌桶：允许突发流量，平滑限流
- 漏桶：严格控制速率，输出平稳
- 自适应：需要根据系统状态动态调整Q3：如何避免误熔断？
text
复制
下载
1. 设置合理的失败阈值和采样窗口
2. 实现半开状态试探机制
3. 区分业务异常和系统异常
4. 配置白名单和特殊处理
5. 监控告警及时发现误熔断Q4：自适应限流的关键指标有哪些？
text
复制
下载
1. 响应时间：P50、P90、P99分位
2. 错误率：业务错误和系统错误区分
3. 系统负载：CPU、内存、线程池状态
4. 调用链路：依赖服务的健康状态
5. 业务指标：成功交易率、用户体验篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案
【点击此处即可/免费获取】
七、性能优化建议
7.1 性能优化技巧
java
复制
下载
/**
* 高性能熔断器实现
*/
public class HighPerformanceCircuitBreaker {
// 使用LongAdder代替AtomicInteger提高并发性能
private final LongAdder failureCount = new LongAdder();
private final LongAdder successCount = new LongAdder();
// 使用StampedLock提高读多写少场景性能
private final StampedLock lock = new StampedLock();
// 使用ConcurrentHashMap存储服务状态
private final ConcurrentHashMap<String, ServiceState> serviceStates =
new ConcurrentHashMap<>();
// 使用缓存减少计算
@GuardedBy("lock")
private volatile boolean cachedIsOpen = false;
private volatile long cachedCheckTime = 0;
public boolean allowRequest(String serviceName) {
// 缓存检查
if (cachedIsOpen && System.currentTimeMillis() - cachedCheckTime < 100) {
return false;
}
long stamp = lock.tryOptimisticRead();
boolean isOpen = checkIfOpen(serviceName);
if (!lock.validate(stamp)) {
stamp = lock.readLock();
try {
isOpen = checkIfOpen(serviceName);
} finally {
lock.unlockRead(stamp);
}
}
return !isOpen;
}
// 批量更新统计信息，减少锁竞争
public void batchRecordMetrics(List<RequestResult> results) {
Map<String, List<RequestResult>> grouped = results.stream()
.collect(Collectors.groupingBy(RequestResult::getServiceName));
grouped.forEach((serviceName, serviceResults) -> {
long failures = serviceResults.stream()
.filter(r -> !r.isSuccess()).count();
long successes = serviceResults.size() - failures;
updateMetrics(serviceName, failures, successes);
});
}
}7.2 监控告警集成
java
复制
下载
/**
* 监控告警集成
*/
@Slf4j
@Component
public class CircuitBreakerMonitor {
@Resource
private MetricsRegistry metricsRegistry;
@Resource
private AlertService alertService;
private final Map<String, CircuitBreakerMetrics> metricsMap =
new ConcurrentHashMap<>();
@Scheduled(fixedRate = 5000)
public void collectAndReportMetrics() {
metricsMap.forEach((serviceName, metrics) -> {
// 收集指标
double failureRate = metrics.getFailureRate();
long requestCount = metrics.getRequestCount();
long openDuration = metrics.getOpenDuration();
// 上报到监控系统
metricsRegistry.recordGauge("circuitbreaker.failure_rate",
failureRate, "service", serviceName);
metricsRegistry.recordCounter("circuitbreaker.request_total",
requestCount, "service", serviceName);
// 检查告警条件
checkAndAlert(serviceName, failureRate, openDuration);
// 重置采样窗口
metrics.resetWindow();
});
}
private void checkAndAlert(String serviceName, double failureRate, long openDuration) {
// 熔断器打开告警
if (openDuration > 0) {
if (openDuration > 30000) { // 熔断超过30秒
alertService.sendAlert(AlertLevel.WARNING,
"CircuitBreaker长时间打开",
String.format("服务%s熔断已持续%dms", serviceName, openDuration));
}
}
// 高失败率告警
if (failureRate > 0.3) { // 失败率超过30%
alertService.sendAlert(AlertLevel.ERROR,
"服务失败率过高",
String.format("服务%s失败率%.2f%%", serviceName, failureRate * 100));
}
}
/**
* 实时仪表板数据
*/
@GetMapping("/metrics/circuitbreaker")
public Map<String, Object> getCircuitBreakerMetrics() {
Map<String, Object> result = new LinkedHashMap<>();
metricsMap.forEach((serviceName, metrics) -> {
Map<String, Object> serviceMetrics = new HashMap<>();
serviceMetrics.put("state", metrics.getState().name());
serviceMetrics.put("failureRate", metrics.getFailureRate());
serviceMetrics.put("requestCount", metrics.getRequestCount());
serviceMetrics.put("openDuration", metrics.getOpenDuration());
serviceMetrics.put("lastFailureTime", metrics.getLastFailureTime());
result.put(serviceName, serviceMetrics);
});
return result;
}
}这个完整的熔断降级和自适应限流实现方案，涵盖了从基础原理到生产级实现的所有关键点，特别适合在面试中展示深度理解和实践经验。