优雅降级架构

功能降级

功能降级是在系统压力过大时，关闭非核心功能，集中资源保障核心业务。

// 功能降级配置
@Component
public class FeatureToggleService {
    
    private final Map<String, Boolean> featureFlags = new ConcurrentHashMap<>();
    
    @Value("${feature.recommendation.enabled:true}")
    private boolean recommendationEnabled;
    
    @Value("${feature.comments.enabled:true}")
    private boolean commentsEnabled;
    
    @PostConstruct
    public void init() {
        featureFlags.put("recommendation", recommendationEnabled);
        featureFlags.put("comments", commentsEnabled);
        featureFlags.put("personalization", true);
    }
    
    public boolean isFeatureEnabled(String feature) {
        return featureFlags.getOrDefault(feature, false);
    }
    
    public void degradeFeature(String feature) {
        featureFlags.put(feature, false);
        log.warn("功能降级: {} 已关闭", feature);
    }
}

// 业务层使用
@Service
public class ProductPageService {
    
    public ProductPage getPage(Long productId) {
        ProductPage page = new ProductPage();
        page.setProduct(productRepository.findById(productId));
        
        // 降级时跳过推荐功能
        if (featureToggleService.isFeatureEnabled("recommendation")) {
            page.setRecommendations(getRecommendations(productId));
        }
        
        // 降级时返回缓存的评论
        if (featureToggleService.isFeatureEnabled("comments")) {
            page.setComments(getComments(productId));
        } else {
            page.setComments(getCachedComments(productId));
        }
        
        return page;
    }
}

流量降级

流量降级通过限流、排队等机制控制请求量，保护后端服务。

// 基于令牌桶的限流器
@Component
public class RateLimiter {
    
    private final Map<String, RateLimitConfig> configs = new HashMap<>();
    private final Map<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    
    public boolean tryAcquire(String resource) {
        RateLimitConfig config = configs.getOrDefault(resource, 
            new RateLimitConfig(1000, 100)); // 默认1000 QPS, 100突发
        
        TokenBucket bucket = buckets.computeIfAbsent(resource, 
            k -> new TokenBucket(config));
        
        if (bucket.tryConsume()) {
            return true;
        }
        
        // 触发降级：返回缓存数据或默认值
        log.warn("资源 {} 限流触发，执行降级", resource);
        return false;
    }
}

// 降级处理器
@Component
public class DegradationHandler {
    
    public Response handleRequest(String resource, Supplier<Response> supplier) {
        if (rateLimiter.tryAcquire(resource)) {
            try {
                return supplier.get();
            } catch (Exception e) {
                return fallback(resource);
            }
        }
        return fallback(resource);
    }
    
    private Response fallback(String resource) {
        // 返回缓存数据
        Response cached = cacheService.get(resource);
        if (cached != null) {
            return cached;
        }
        // 返回默认值
        return Response.defaultResponse();
    }
}

自动降级策略

自动降级根据系统负载、错误率等指标自动触发降级。

@Component
public class AutoDegradationService {
    
    @Scheduled(fixedRate = 10000)
    public void checkAndDegrade() {
        double cpuUsage = getSystemCpuUsage();
        double errorRate = getErrorRate();
        int queueLength = getQueueLength();
        
        // CPU 过高时降级非核心功能
        if (cpuUsage > 80) {
            featureToggleService.degradeFeature("recommendation");
        }
        
        // 错误率过高时降级
        if (errorRate > 0.1) {
            featureToggleService.degradeFeature("personalization");
            rateLimiter.adjustLimit(0.5); // 限流50%
        }
        
        // 队列过长时开启排队模式
        if (queueLength > 1000) {
            enableQueueMode();
        }
    }
}

优雅降级的关键是定义清晰的降级策略和恢复机制，确保在系统压力缓解后能自动恢复正常服务。