一、问题背景：为什么需要动态降级？

在生产环境中，我们经常面临各种突发情况：

真实案例

去年双11大促期间，某电商平台遇到了一个棘手的问题：

场景：大促开始后 10 分钟，订单系统突然出现大量超时，导致用户无法下单。

原因：推荐服务（非核心功能）调用了第三方 AI 接口，由于第三方服务响应变慢，大量线程被阻塞，最终拖垮了整个网关。

后果：核心的下单、支付功能也受到了影响，造成了巨大的经济损失。

反思：如果当时能够快速关闭非核心路由（如推荐、广告、评论等），保留核心路由（如下单、支付），就能将损失降到最低。

传统降级方式的不足

动态降级开关的优势

动态降级开关是一种基于配置中心的降级方案，具有以下优势：

• 秒级响应：无需重启，配置修改立即生效
• 精细控制：可以针对单个路由或一组路由进行降级
• 可视化操作：通过配置中心界面进行操作，降低出错概率
• 历史追溯：记录降级操作历史，便于事后分析
• 自动恢复：可以设置自动恢复时间，避免人为遗忘

二、核心概念：动态降级架构

1. 降级策略

根据业务重要性，将路由分为不同级别：

2. 降级方式

• 快速失败：直接返回错误，不调用后端服务
• 返回默认值：返回预设的默认值或空数据
• 降级到缓存：从缓存中读取数据
• 降级到备用服务：调用备用服务或本地服务

3. 配置中心集成

主流配置中心对比：

本文使用 Nacos 作为配置中心，因为它功能全面且易于使用。

三、实现方案：Spring Cloud Gateway + Nacos

1. 技术栈

• Spring Boot 2.7.5
• Spring Cloud Gateway 3.1.0
• Nacos 2.2.0
• Java 11+

2. 架构设计

┌─────────────┐
│  运维人员   │
└─────┬───────┘
      │
      ▼
┌─────────────────┐
│   Nacos 控制台  │
│  (修改降级配置)  │
└────────┬────────┘
         │
         ▼
┌─────────────────────────────────────────────────────┐
│              Spring Cloud Gateway                │
│  ┌──────────────────────────────────────────┐  │
│  │      动态降级过滤器 (CircuitBreaker)    │  │
│  │  - 读取降级配置                          │  │
│  │  - 判断路由是否降级                        │  │
│  │  - 执行降级逻辑                          │  │
│  └──────────────────────────────────────────┘  │
│  ┌──────────────────────────────────────────┐  │
│  │         路由配置                         │  │
│  │  - 核心路由 (P0, P1)                   │  │
│  │  - 非核心路由 (P2, P3)                  │  │
│  └──────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────┘
         │
         ▼
┌─────────────────────┐
│   后端微服务集群     │
└─────────────────────┘

3. 降级配置设计

在 Nacos 中配置降级规则：

gateway:
  degrade:
    enabled: true  # 是否启用降级
    routes:
      # 核心路由（永不降级）
      - id: order-service
        priority: P0
        enabled: true
        degrade: false
      
      - id: payment-service
        priority: P0
        enabled: true
        degrade: false
      
      # 非核心路由（可以降级）
      - id: recommend-service
        priority: P2
        enabled: true
        degrade: false
        strategy: DEFAULT_VALUE  # 降级策略：返回默认值
      
      - id: ad-service
        priority: P3
        enabled: true
        degrade: false
        strategy: FAIL_FAST  # 降级策略：快速失败
      
      - id: comment-service
        priority: P3
        enabled: true
        degrade: false
        strategy: CACHE  # 降级策略：降级到缓存

四、代码实现：完整示例

1. 添加依赖

<dependencies>
    <!-- Spring Cloud Gateway -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!-- Nacos Config -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>

    <!-- Nacos Discovery -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- Lombok -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

2. 配置文件

spring:
  application:
    name: gateway-degrade-demo
  
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: public
      config:
        server-addr: localhost:8848
        namespace: public
        file-extension: yaml
        shared-configs:
          - data-id: gateway-degrade.yaml
            refresh: true

    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - StripPrefix=1
          metadata:
            priority: P0
            degrade: false

        - id: payment-service
          uri: lb://payment-service
          predicates:
            - Path=/api/payment/**
          filters:
            - StripPrefix=1
          metadata:
            priority: P0
            degrade: false

        - id: recommend-service
          uri: lb://recommend-service
          predicates:
            - Path=/api/recommend/**
          filters:
            - StripPrefix=1
          metadata:
            priority: P2
            degrade: false
            strategy: DEFAULT_VALUE

        - id: ad-service
          uri: lb://ad-service
          predicates:
            - Path=/api/ad/**
          filters:
            - StripPrefix=1
          metadata:
            priority: P3
            degrade: false
            strategy: FAIL_FAST

        - id: comment-service
          uri: lb://comment-service
          predicates:
            - Path=/api/comment/**
          filters:
            - StripPrefix=1
          metadata:
            priority: P3
            degrade: false
            strategy: CACHE

server:
  port: 8080

management:
  endpoints:
    web:
      exposure:
        include: health,info,gateway

3. 降级配置类

@Data
@Component
@ConfigurationProperties(prefix = "gateway.degrade")
@RefreshScope
public class DegradeConfig {

    private Boolean enabled = true;
    
    private List<RouteDegradeConfig> routes = new ArrayList<>();

    @Data
    public static class RouteDegradeConfig {
        private String id;
        private String priority;
        private Boolean enabled;
        private Boolean degrade;
        private DegradeStrategy strategy;
    }

    public enum DegradeStrategy {
        FAIL_FAST,           // 快速失败
        DEFAULT_VALUE,       // 返回默认值
        CACHE,               // 降级到缓存
        BACKUP_SERVICE       // 降级到备用服务
    }

    public RouteDegradeConfig getRouteConfig(String routeId) {
        return routes.stream()
                .filter(config -> config.getId().equals(routeId))
                .findFirst()
                .orElse(null);
    }

    public boolean isDegradeEnabled(String routeId) {
        if (!enabled) {
            return false;
        }
        RouteDegradeConfig config = getRouteConfig(routeId);
        return config != null && config.getDegrade();
    }

}

4. 动态降级过滤器

@Component
@Slf4j
public class DynamicDegradeFilter implements GlobalFilter, Ordered {

    @Autowired
    private DegradeConfig degradeConfig;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String routeId = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR)
                .map(route -> route.getId())
                .orElse(null);

        if (routeId == null) {
            return chain.filter(exchange);
        }

        // 检查是否启用降级
        if (!degradeConfig.isDegradeEnabled(routeId)) {
            return chain.filter(exchange);
        }

        DegradeConfig.RouteDegradeConfig routeConfig = degradeConfig.getRouteConfig(routeId);
        if (routeConfig == null) {
            return chain.filter(exchange);
        }

        log.info("Route {} is degraded, strategy: {}", routeId, routeConfig.getStrategy());

        // 根据降级策略执行降级逻辑
        return executeDegradeStrategy(exchange, routeConfig);
    }

    private Mono<Void> executeDegradeStrategy(ServerWebExchange exchange, 
                                            DegradeConfig.RouteDegradeConfig config) {
        switch (config.getStrategy()) {
            case FAIL_FAST:
                return failFast(exchange);
            
            case DEFAULT_VALUE:
                return returnDefaultValue(exchange);
            
            case CACHE:
                return returnFromCache(exchange);
            
            case BACKUP_SERVICE:
                return callBackupService(exchange);
            
            default:
                return failFast(exchange);
        }
    }

    private Mono<Void> failFast(ServerWebExchange exchange) {
        exchange.getResponse().setStatusCode(HttpStatus.SERVICE_UNAVAILABLE);
        exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
        
        String response = "{\"code\":503,\"message\":\"Service temporarily unavailable\"}";
        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(response.getBytes());
        
        return exchange.getResponse().writeWith(Mono.just(buffer));
    }

    private Mono<Void> returnDefaultValue(ServerWebExchange exchange) {
        exchange.getResponse().setStatusCode(HttpStatus.OK);
        exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
        
        String response = "{\"code\":200,\"message\":\"success\",\"data\":[]}";
        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(response.getBytes());
        
        return exchange.getResponse().writeWith(Mono.just(buffer));
    }

    private Mono<Void> returnFromCache(ServerWebExchange exchange) {
        String cacheKey = "gateway:cache:" + exchange.getRequest().getPath();
        Object cachedData = redisTemplate.opsForValue().get(cacheKey);
        
        if (cachedData != null) {
            exchange.getResponse().setStatusCode(HttpStatus.OK);
            exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
            
            String response = "{\"code\":200,\"message\":\"success\",\"data\":" + cachedData + "}";
            DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(response.getBytes());
            
            return exchange.getResponse().writeWith(Mono.just(buffer));
        }
        
        return returnDefaultValue(exchange);
    }

    private Mono<Void> callBackupService(ServerWebExchange exchange) {
        // 这里可以调用备用服务
        return returnDefaultValue(exchange);
    }

    @Override
    public int getOrder() {
        return -100; // 优先级高于默认过滤器
    }

}

5. 降级管理接口

@RestController
@RequestMapping("/admin/degrade")
@Slf4j
public class DegradeAdminController {

    @Autowired
    private DegradeConfig degradeConfig;

    @Autowired
    private ApplicationContext applicationContext;

    /**
     * 获取所有降级配置
     */
    @GetMapping("/config")
    public Result<DegradeConfig> getDegradeConfig() {
        return Result.success(degradeConfig);
    }

    /**
     * 获取指定路由的降级配置
     */
    @GetMapping("/config/{routeId}")
    public Result<DegradeConfig.RouteDegradeConfig> getRouteDegradeConfig(@PathVariable String routeId) {
        DegradeConfig.RouteDegradeConfig config = degradeConfig.getRouteConfig(routeId);
        if (config == null) {
            return Result.error("Route not found: " + routeId);
        }
        return Result.success(config);
    }

    /**
     * 开启降级（单个路由）
     */
    @PostMapping("/enable/{routeId}")
    public Result<String> enableDegrade(@PathVariable String routeId) {
        DegradeConfig.RouteDegradeConfig config = degradeConfig.getRouteConfig(routeId);
        if (config == null) {
            return Result.error("Route not found: " + routeId);
        }
        
        if ("P0".equals(config.getPriority())) {
            return Result.error("Cannot degrade P0 route");
        }
        
        config.setDegrade(true);
        log.info("Degrade enabled for route: {}", routeId);
        
        return Result.success("Degrade enabled for route: " + routeId);
    }

    /**
     * 关闭降级（单个路由）
     */
    @PostMapping("/disable/{routeId}")
    public Result<String> disableDegrade(@PathVariable String routeId) {
        DegradeConfig.RouteDegradeConfig config = degradeConfig.getRouteConfig(routeId);
        if (config == null) {
            return Result.error("Route not found: " + routeId);
        }
        
        config.setDegrade(false);
        log.info("Degrade disabled for route: {}", routeId);
        
        return Result.success("Degrade disabled for route: " + routeId);
    }

    /**
     * 批量开启降级（按优先级）
     */
    @PostMapping("/enable/priority/{priority}")
    public Result<String> enableDegradeByPriority(@PathVariable String priority) {
        int count = 0;
        for (DegradeConfig.RouteDegradeConfig config : degradeConfig.getRoutes()) {
            if (priority.equals(config.getPriority()) && !"P0".equals(priority)) {
                config.setDegrade(true);
                count++;
            }
        }
        
        log.info("Degrade enabled for {} routes with priority: {}", count, priority);
        return Result.success("Degrade enabled for " + count + " routes");
    }

    /**
     * 批量关闭降级（按优先级）
     */
    @PostMapping("/disable/priority/{priority}")
    public Result<String> disableDegradeByPriority(@PathVariable String priority) {
        int count = 0;
        for (DegradeConfig.RouteDegradeConfig config : degradeConfig.getRoutes()) {
            if (priority.equals(config.getPriority())) {
                config.setDegrade(false);
                count++;
            }
        }
        
        log.info("Degrade disabled for {} routes with priority: {}", count, priority);
        return Result.success("Degrade disabled for " + count + " routes");
    }

    /**
     * 一键降级（关闭所有非核心路由）
     */
    @PostMapping("/emergency")
    public Result<String> emergencyDegrade() {
        int count = 0;
        for (DegradeConfig.RouteDegradeConfig config : degradeConfig.getRoutes()) {
            if (!"P0".equals(config.getPriority())) {
                config.setDegrade(true);
                count++;
            }
        }
        
        log.info("Emergency degrade enabled for {} routes", count);
        return Result.success("Emergency degrade enabled for " + count + " routes");
    }

    /**
     * 恢复所有路由
     */
    @PostMapping("/recover")
    public Result<String> recoverAll() {
        int count = 0;
        for (DegradeConfig.RouteDegradeConfig config : degradeConfig.getRoutes()) {
            if (config.getDegrade()) {
                config.setDegrade(false);
                count++;
            }
        }
        
        log.info("Recovered {} routes", count);
        return Result.success("Recovered " + count + " routes");
    }

}

五、Nacos 配置中心集成

1. 创建配置文件

在 Nacos 控制台创建配置文件 gateway-degrade.yaml：

gateway:
  degrade:
    enabled: true
    routes:
      - id: order-service
        priority: P0
        enabled: true
        degrade: false
      
      - id: payment-service
        priority: P0
        enabled: true
        degrade: false
      
      - id: recommend-service
        priority: P2
        enabled: true
        degrade: false
        strategy: DEFAULT_VALUE
      
      - id: ad-service
        priority: P3
        enabled: true
        degrade: false
        strategy: FAIL_FAST
      
      - id: comment-service
        priority: P3
        enabled: true
        degrade: false
        strategy: CACHE

2. 配置动态刷新

@Configuration
public class NacosConfigRefreshListener {

    @Autowired
    private DegradeConfig degradeConfig;

    @NacosConfigListener(dataId = "gateway-degrade.yaml", groupId = "DEFAULT_GROUP")
    public void onConfigReceived(String config) {
        log.info("Received degrade config update: {}", config);
        // 配置会自动刷新到 DegradeConfig 中
    }

}

六、监控与告警

1. 降级监控指标

@Component
public class DegradeMetrics {

    @Autowired
    private MeterRegistry meterRegistry;

    private Counter degradeCounter;
    private Counter recoverCounter;

    @PostConstruct
    public void init() {
        degradeCounter = Counter.builder("gateway.degrade.enabled")
                .description("降级启用次数")
                .register(meterRegistry);

        recoverCounter = Counter.builder("gateway.degrade.recovered")
                .description("降级恢复次数")
                .register(meterRegistry);
    }

    public void recordDegrade(String routeId) {
        degradeCounter.increment(Tags.of("route", routeId));
    }

    public void recordRecover(String routeId) {
        recoverCounter.increment(Tags.of("route", routeId));
    }

}

2. 告警规则

• 降级启用告警：当 P0 或 P1 路由降级时立即告警
• 降级时长告警：当降级时间超过阈值时告警
• 降级频率告警：当降级操作过于频繁时告警

七、最佳实践

1. 降级策略选择

2. 降级操作流程

1. 发现问题：监控系统发现异常
2. 评估影响：评估哪些路由需要降级
3. 执行降级：通过 Nacos 控制台或 API 执行降级
4. 观察效果：观察系统是否恢复正常
5. 问题修复：修复后端服务问题
6. 恢复服务：逐步恢复降级的路由

3. 降级注意事项

• P0 路由永不降级：核心业务必须保证可用性
• 降级前测试：在生产环境降级前，先在测试环境验证
• 记录降级原因：便于事后分析和优化
• 设置自动恢复：避免人为遗忘恢复服务
• 定期演练：定期进行降级演练，确保降级机制有效

八、常见问题与解决方案

1. 配置不生效

问题：修改 Nacos 配置后，降级不生效
解决方案：

• 检查 @RefreshScope 注解是否正确添加
• 检查 Nacos 配置的 dataId 和 groupId 是否正确
• 检查网络连接是否正常

2. 降级后无法恢复

问题：降级后无法恢复服务
解决方案：

• 检查降级配置是否正确更新
• 检查后端服务是否已恢复
• 检查是否有其他降级规则阻止恢复

3. 降级影响核心业务

问题：降级操作影响了核心业务
解决方案：

• 检查路由优先级配置是否正确
• 检查降级策略是否合适
• 建立降级操作审批机制

欢迎在评论区分享你的经验和观点！

关于作者：服务端技术精选，专注于分享后端技术、分布式系统、微服务架构等内容。

个人博客：www.jiangyi.space

公众号：服务端技术精选