引言：微服务防护的必要性

大促活动来了，流量暴涨，系统直接被压垮了？或者某个服务响应慢，导致整个调用链雪崩？再或者第三方服务挂了，结果把你的系统也拖垮了？

这就是微服务架构下的防护难题。传统的单体应用防护方式已经无法满足微服务架构的需求。今天我们就来聊聊如何用SpringBoot + Sentinel + Nacos构建一个完整的微服务防护体系，实现熔断、降级、限流一体化防护。

为什么需要微服务防护？

先说说为什么微服务需要防护。

想象一下，你是一家电商平台的后端工程师。用户访问商品详情页，需要调用商品服务、库存服务、价格服务、评价服务等多个微服务。如果：

• 商品服务响应慢：会导致整个页面响应慢
• 库存服务挂了：可能导致用户无法看到库存信息
• 价格服务超时：可能导致价格无法显示
• 流量过大：可能导致所有服务都被压垮

这就是典型的微服务雪崩效应。微服务防护就是为了解决这些问题而生的。

技术选型：为什么选择这些技术？

Sentinel：阿里巴巴开源的流量防护组件

Sentinel是阿里巴巴开源的轻量级流量控制组件，专门为微服务架构设计：

• 流量控制：QPS、线程数等维度的流量控制
• 熔断降级：快速失败，避免雪崩
• 系统负载保护：根据系统负载自动保护
• 实时监控：丰富的监控指标

Nacos：服务发现与配置中心

Nacos是阿里巴巴开源的服务发现和配置中心：

• 动态配置：防护规则动态调整
• 服务发现：服务注册与发现
• 配置管理：统一管理配置信息

SpringBoot：快速集成的桥梁

SpringBoot提供了：

• 自动配置：快速集成各种组件
• 注解支持：@SentinelResource等便捷注解
• 拦截器支持：便于统一处理

系统架构设计

我们的防护体系主要包括以下几个模块：

1. 流量控制：控制接口访问频率
2. 熔断降级：服务异常时快速失败
3. 系统保护：根据系统指标自动保护
4. 动态配置：防护规则动态调整
5. 监控告警：实时监控防护效果

核心实现思路

1. 流量控制

使用Sentinel的流控规则控制接口访问频率：

@RestController
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    @GetMapping("/order/{id}")
    @SentinelResource(
        value = "getOrder",
        blockHandler = "handleGetOrderBlock",
        fallback = "handleGetOrderFallback"
    )
    public ResponseEntity<Order> getOrder(@PathVariable Long id) {
        return ResponseEntity.ok(orderService.getOrderById(id));
    }
    
    // 流控处理方法
    public ResponseEntity<Order> handleGetOrderBlock(Long id, BlockException ex) {
        return ResponseEntity.status(429).body(new Order("服务繁忙，请稍后再试"));
    }
    
    // 降级处理方法
    public ResponseEntity<Order> handleGetOrderFallback(Long id, Throwable ex) {
        return ResponseEntity.ok(new Order("降级处理，返回缓存数据"));
    }
}

2. 熔断降级

配置熔断规则，当错误率超过阈值时自动熔断：

@Service
public class PaymentService {
    
    @Autowired
    private ThirdPartyPaymentClient paymentClient;
    
    @SentinelResource(
        value = "processPayment",
        fallback = "handlePaymentFallback",
        fallbackClass = PaymentFallbackHandler.class
    )
    public PaymentResult processPayment(PaymentRequest request) {
        // 调用第三方支付
        return paymentClient.pay(request);
    }
}

// 降级处理类
public class PaymentFallbackHandler {
    
    public static PaymentResult handlePaymentFallback(PaymentRequest request, Throwable ex) {
        // 记录降级日志
        log.warn("支付服务降级，使用本地处理逻辑", ex);
        
        // 返回降级结果
        return PaymentResult.builder()
            .status(PaymentStatus.DEFERRED)
            .message("支付处理中，请稍后查询结果")
            .build();
    }
}

3. 系统保护

配置系统保护规则，根据系统指标自动保护：

@Component
public class SystemProtectionConfig {
    
    @PostConstruct
    public void initSystemRules() {
        List<SystemRule> rules = new ArrayList<>();
        
        // 设置系统负载保护规则
        SystemRule loadRule = new SystemRule();
        loadRule.setHighestSystemLoad(3.0); // 最高系统负载
        loadRule.setStrategy(SystemRuleConstants.FULL_PROTECTION);
        
        // 设置CPU使用率保护规则
        SystemRule cpuRule = new SystemRule();
        cpuRule.setHighestCpuUsage(0.8); // 最高CPU使用率80%
        
        // 设置RT保护规则
        SystemRule rtRule = new SystemRule();
        rtRule.setAvgRt(500); // 平均响应时间500ms
        
        // 设置线程数保护规则
        SystemRule threadRule = new SystemRule();
        threadRule.setHighestThread(200); // 最高线程数200
        
        rules.add(loadRule);
        rules.add(cpuRule);
        rules.add(rtRule);
        rules.add(threadRule);
        
        SystemRuleManager.loadRules(rules);
    }
}

4. 动态配置

通过Nacos实现防护规则的动态配置：

@Component
public class DynamicRuleConfig {
    
    @Autowired
    private ConfigService configService;
    
    @PostConstruct
    public void initDynamicRules() {
        // 监听流控规则配置
        configService.addListener("sentinel-flow-rules", "DEFAULT_GROUP", new Listener() {
            @Override
            public void receiveConfigInfo(String configInfo) {
                try {
                    List<FlowRule> flowRules = JSON.parseArray(configInfo, FlowRule.class);
                    FlowRuleManager.loadRules(flowRules);
                } catch (Exception e) {
                    log.error("解析流控规则失败", e);
                }
            }
            
            @Override
            public Executor getExecutor() {
                return null;
            }
        });
        
        // 监听熔断规则配置
        configService.addListener("sentinel-degrade-rules", "DEFAULT_GROUP", new Listener() {
            @Override
            public void receiveConfigInfo(String configInfo) {
                try {
                    List<DegradeRule> degradeRules = JSON.parseArray(configInfo, DegradeRule.class);
                    DegradeRuleManager.loadRules(degradeRules);
                } catch (Exception e) {
                    log.error("解析熔断规则失败", e);
                }
            }
            
            @Override
            public Executor getExecutor() {
                return null;
            }
        });
    }
}

5. 自定义限流处理器

@Component
public class CustomUrlBlockHandler implements UrlBlockHandler {
    
    @Override
    public void blocked(HttpServletRequest request, HttpServletResponse response, BlockException ex) 
            throws IOException {
        
        response.setContentType("application/json;charset=UTF-8");
        response.setStatus(429);
        
        String message = "访问频率过高，请稍后再试";
        if (ex instanceof FlowException) {
            message = "请求被流控限制";
        } else if (ex instanceof DegradeException) {
            message = "服务降级处理";
        } else if (ex instanceof ParamFlowException) {
            message = "参数流控限制";
        }
        
        response.getWriter().write(JSON.toJSONString(
            Result.error(429, message)
        ));
    }
}

高级特性实现

1. 参数限流

对特定参数进行限流：

@PostMapping("/order")
@SentinelResource(value = "createOrder")
public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
    // 使用热点参数限流，对用户ID进行限流
    Entry entry = null;
    try {
        entry = SphU.entry("createOrder", EntryType.IN, 1, request.getUserId());
        return ResponseEntity.ok(orderService.createOrder(request));
    } catch (BlockException ex) {
        return ResponseEntity.status(429).body(new Order("请求过于频繁"));
    } finally {
        if (entry != null) {
            entry.exit();
        }
    }
}

// 配置热点参数规则
@PostConstruct
public void initHotParamRules() {
    ParamFlowRule rule = new ParamFlowRule("createOrder")
        .setParamIdx(0) // 第一个参数（用户ID）
        .setCount(5); // 每秒最多5次
    
    // 针对特定用户设置不同的限流阈值
    rule.setParamFlowItemList(Arrays.asList(
        new ParamFlowItem().setObject("VIP_USER_ID").setCount(20),
        new ParamFlowItem().setObject("NORMAL_USER_ID").setCount(5)
    ));
    
    ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
}

2. 异步调用防护

@Service
public class AsyncOrderService {
    
    @Async
    @SentinelResource(value = "processOrderAsync")
    public CompletableFuture<OrderResult> processOrderAsync(OrderRequest request) {
        try {
            OrderResult result = orderService.processOrder(request);
            return CompletableFuture.completedFuture(result);
        } catch (Exception e) {
            log.error("异步处理订单失败", e);
            return CompletableFuture.completedFuture(OrderResult.error("处理失败"));
        }
    }
}

3. 自定义异常处理

@Component
public class SentinelExceptionHandler {
    
    @EventListener
    public void handleBlockException(BlockExceptionEvent event) {
        BlockException ex = event.getBlockException();
        String resource = event.getResource();
        
        // 记录限流日志
        log.warn("资源[{}]被限流，异常类型：{}", resource, ex.getClass().getSimpleName());
        
        // 发送告警
        alertService.sendAlert("限流告警", String.format("资源[%s]被限流", resource));
    }
}

Nacos配置管理

application.yml配置

spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848
        file-extension: yaml

sentinel:
  transport:
    dashboard: localhost:8080
    port: 8719
  eager: true
  datasource:
    flow:
      nacos:
        server-addr: localhost:8848
        dataId: ${spring.application.name}-flow-rules
        groupId: SENTINEL_GROUP
        rule-type: flow

流控规则配置示例

[
  {
    "resource": "getOrder",
    "limitApp": "default",
    "grade": 1,
    "count": 100,
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
  }
]

熔断规则配置示例

[
  {
    "resource": "processPayment",
    "grade": 2,
    "count": 0.1,
    "timeWindow": 10,
    "minRequestAmount": 10,
    "statIntervalMs": 1000
  }
]

监控与告警

1. 自定义监控指标

@Component
public class SentinelMetricsCollector {
    
    private final MeterRegistry meterRegistry;
    
    public void recordBlockEvent(String resource, String ruleType) {
        Counter.builder("sentinel_block_total")
            .tag("resource", resource)
            .tag("rule_type", ruleType)
            .register(meterRegistry)
            .increment();
    }
    
    public void recordPassEvent(String resource) {
        Counter.builder("sentinel_pass_total")
            .tag("resource", resource)
            .register(meterRegistry)
            .increment();
    }
}

2. 实时监控

@RestController
@RequestMapping("/monitor")
public class SentinelMonitorController {
    
    @GetMapping("/metrics")
    public ResponseEntity<Map<String, Object>> getMetrics() {
        Map<String, Object> metrics = new HashMap<>();
        
        // 获取当前QPS
        metrics.put("qps", Metrics.get("getOrder").getQps());
        // 获取当前线程数
        metrics.put("activeThread", Metrics.get("getOrder").getActiveThreadCount());
        // 获取平均RT
        metrics.put("avgRt", Metrics.get("getOrder").getRt());
        
        return ResponseEntity.ok(metrics);
    }
}

最佳实践

1. 规则设计原则

• 分级防护：不同重要程度的接口设置不同防护级别
• 渐进式降级：从功能降级到服务降级
• 快速恢复：熔断后快速恢复机制
• 动态调整：根据业务量动态调整规则

2. 性能优化

• 异步处理：避免防护逻辑阻塞业务线程
• 缓存规则：减少规则查询开销
• 批量上报：减少监控数据上报频率

3. 安全考虑

• 权限控制：限制防护规则的修改权限
• 审计日志：记录防护规则的变更历史
• 防刷机制：防止恶意调用绕过防护

总结

通过SpringBoot + Sentinel + Nacos的组合，我们可以构建一个完整的微服务防护体系。关键在于：

1. 全面防护：流量控制、熔断降级、系统保护全覆盖
2. 动态配置：通过Nacos实现规则动态调整
3. 实时监控：及时发现问题并调整策略
4. 快速恢复：熔断后快速恢复机制

记住，防护不是一成不变的，需要根据业务特点和流量模式持续优化。掌握了这些技巧，你就能让系统更加稳定可靠，告别雪崩的烦恼。