Spring Cloud 微服务架构全景图
·
Spring Cloud 微服务架构全景图
一、微服务架构概述
1.1 为什么需要微服务架构？
┌─────────────────────────────────────────────────────────────────────────┐
│ 从单体到微服务的演进 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 单体架构 │ │
│ │ │ │
│ │ ┌─────────┬─────────┬─────────┬─────────┐ │ │
│ │ │ 用户 │ 订单 │ 商品 │ 支付 │ │ │
│ │ │ 模块 │ 模块 │ 模块 │ 模块 │ │ │
│ │ └─────────┴─────────┴─────────┴─────────┘ │ │
│ │ │ │ │
│ │ ┌────┴────┐ │ │
│ │ │ 数据库 │ │ │
│ │ └─────────┘ │ │
│ │ │ │
│ │ 问题： │ │
│ │ ❌ 代码耦合，改一处动全身 │ │
│ │ ❌ 部署周期长，一个小功能需要全量发布 │ │
│ │ ❌ 技术栈固化，无法快速引入新技术 │ │
│ │ ❌ 扩展困难，无法针对热点模块单独扩容 │ │
│ │ ❌ 故障影响范围大，一个模块OOM可能导致整个应用不可用 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 微服务架构 │ │
│ │ │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │ 用户 │ │ 订单 │ │ 商品 │ │ 支付 │ │ │
│ │ │ 服务 │ │ 服务 │ │ 服务 │ │ 服务 │ │ │
│ │ └───┬────┘ └───┬────┘ └───┬────┘ └───┬────┘ │ │
│ │ │ │ │ │ │ │
│ │ ┌───┴────────────┴────────────┴────────────┴───┐ │ │
│ │ │ API Gateway │ │ │
│ │ └────────────────────┬───────────────────────────┘ │ │
│ │ │ │ │
│ │ ┌────────┐ ┌────────┴────────┐ ┌────────┐ │ │
│ │ │ MySQL │ │ Redis │ │MongoDB │ │ │
│ │ └────────┘ └─────────────────┘ └────────┘ │ │
│ │ │ │
│ │ 优势： │ │
│ │ ✅ 服务独立部署，一个模块变更无需影响其他模块 │ │
│ │ ✅ 技术栈灵活，不同服务可选用不同技术栈 │ │
│ │ ✅ 按需扩展，针对热点服务单独扩容 │ │
│ │ ✅ 故障隔离，单个服务故障不会导致整个系统不可用 │ │
│ │ ✅ 团队自治，每个团队负责独立服务，减少协调成本 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
1.2 微服务架构面临的核心挑战
| 挑战类别 | 具体问题 | 解决方案 | 关联文章 |
|---|---|---|---|
| 服务通信 | 服务如何发现彼此？如何调用？ | 注册中心 + 负载均衡 | 服务注册发现、负载均衡 |
| 配置管理 | 如何统一管理配置？配置变更如何生效？ | 配置中心 + 消息总线 | 配置中心原理、Spring Cloud Bus |
| 弹性容错 | 服务故障如何隔离？如何避免雪崩？ | 熔断、降级、重试、限流 | Sentinel、客户端重试 |
| 网关路由 | 外部请求如何路由到内部服务？ | API 网关 | Gateway 动态路由 |
| 可观测性 | 如何追踪请求链路？如何监控服务健康？ | 链路追踪 + 监控 + 日志 | 可观测性系列 |
| 安全认证 | 如何控制服务访问权限？ | OAuth2 + JWT | 安全认证系列 |
| 事务一致性 | 跨服务如何保证数据一致性？ | 分布式事务 | Seata 分布式事务 |
二、Spring Cloud 全景图
2.1 技术栈总览
┌─────────────────────────────────────────────────────────────────────────────────────┐
│ Spring Cloud 技术栈全景图 │
├─────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ 业务应用层 │ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 用户 │ │ 订单 │ │ 商品 │ │ 支付 │ │ 搜索 │ │ │
│ │ │ 服务 │ │ 服务 │ │ 服务 │ │ 服务 │ │ 服务 │ │ │
│ │ │ │ │ │ │ │ │ │ │ │ │ │
│ │ │ user- │ │ order- │ │ product │ │ payment │ │ search- │ │ │
│ │ │ service │ │ service │ │ -service│ │ -service│ │ service │ │ │
│ │ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │ │
│ └───────┼───────────┼───────────┼───────────┼───────────┼─────────────────┘ │
│ │ │ │ │ │ │
│ ┌───────┴───────────┴───────────┴───────────┴───────────┴─────────────────┐ │
│ │ 服务网格层 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────────┐ │ │
│ │ │ API Gateway │ │ │
│ │ │ │ │ │
│ │ │ SpringCloud Gateway 核心能力： │ │ │
│ │ │ ├── 动态路由 • 路由转发 │ │ │
│ │ │ ├── 请求过滤器 • 认证鉴权 │ │ │
│ │ │ ├── 限流熔断 • 限流熔断 │ │ │
│ │ │ └── 协议转换 • 请求监控 │ │ │
│ │ └─────────────────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ 服务治理层 │ │
│ │ │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ │
│ │ │ 服务注册发现 │ │ 负载均衡 │ │ 配置中心 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Nacos │ │ LoadBalancer │ │ Spring Config │ │ │
│ │ │ ├── 注册 │ │ ├── 轮询 │ │ ├── Git 配置 │ │ │
│ │ │ ├── 发现 │ │ ├── 随机 │ │ ├── 本地缓存 │ │ │
│ │ │ ├── 心跳 │ │ ├── 加权 │ │ ├── 热刷新 │ │ │
│ │ │ └── 分组 │ │ └── 最小连接 │ │ └── 多环境 │ │ │
│ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │
│ │ │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ │
│ │ │ 弹性容错 │ │ 消息总线 │ │ 分布式事务 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Sentinel │ │ Spring Bus │ │ Seata │ │ │
│ │ │ ├── 限流 │ │ ├── RabbitMQ │ │ ├── AT 模式 │ │ │
│ │ │ ├── 熔断 │ │ ├── Kafka │ │ ├── TCC 模式 │ │ │
│ │ │ ├── 降级 │ │ └── 配置广播 │ │ └── Saga 模式 │ │ │
│ │ │ └── 热点参数 │ │ │ │ │ │ │
│ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │
│ │ │ │
│ │ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────────┐ │ │
│ │ │ 健康检查 │ │ 链路追踪 │ │ 监控告警 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ HealthIndicator │ │ Sleuth + Zipkin │ │ Prometheus │ │ │
│ │ │ ├── 心跳检测 │ │ ├── TraceId │ │ ├── 指标采集 │ │ │
│ │ │ ├── 依赖检测 │ │ ├── SpanId │ │ ├── Grafana │ │ │
│ │ │ └── 自定义 │ │ └── 采样策略 │ │ └── 告警规则 │ │ │
│ │ └──────────────────┘ └──────────────────┘ └──────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────┐ │
│ │ 基础设施层 │ │
│ │ │ │
│ │ ┌────────┐ ┌────────────┐ ┌─────────────────┐ ┌────────────┐ │ │
│ │ │ Docker │ │Kubernetes │ │ CI/CD │ │ 存储 │ │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │ │ 容器化 │ │ K8s 编排 │ │ Jenkins/ArgoCD │ │ MySQL │ │ │
│ │ │ 镜像 │ │ 服务发现 │ │ 自动化部署 │ │ Redis │ │ │
│ │ └────────┘ │ 自动扩缩容│ │ 蓝绿部署 │ │ ES │ │ │
│ │ └────────────┘ └─────────────────┘ └────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────┘
2.2 组件分类详表
| 层级 | 组件 | 职责 | 推荐方案 | 状态 |
|---|---|---|---|---|
| 网关层 | SpringCloud Gateway | 统一入口、路由、限流 | ✅ 首选 | ✅ |
| Zuul / Zuul2 | 早期网关方案 | ⚠️ 已停更 | - | |
| Kong | Nginx 网关 | 性能要求高时 | ⏳ | |
| 服务治理 | Nacos | 注册中心 + 配置中心 | ✅ 首选 | ✅ |
| Consul | 服务发现 + KV 存储 | 跨语言场景 | ⏳ | |
| Eureka | Netflix 方案 | ⚠️ 已停更 | - | |
| 负载均衡 | SpringCloud LoadBalancer | 客户端负载均衡 | ✅ 首选 | ✅ |
| Ribbon | 早期方案 | ⚠️ 已停更 | - | |
| 配置中心 | Spring Cloud Config | Git 配置管理 | ✅ 基础方案 | ✅ |
| Nacos Config | 配置中心 | ✅ 国产方案 | ✅ | |
| Apollo | 携程配置中心 | 企业级方案 | ⏳ | |
| 弹性容错 | Sentinel | 熔断限流 | ✅ 首选 | ✅ |
| Resilience4j | 函数式容错 | 轻量级方案 | ⏳ | |
| Spring Retry | 重试机制 | ✅ 内置支持 | ✅ | |
| 消息总线 | Spring Cloud Bus | 配置刷新广播 | ✅ | ✅ |
| 分布式事务 | Seata | AT/TCC/Saga 模式 | ✅ | ✅ |
| 链路追踪 | Sleuth + Zipkin | 分布式追踪 | ✅ 基础方案 | ✅ |
| SkyWalking | APM 工具 | 生产级方案 | ⏳ | |
| 监控告警 | Prometheus + Grafana | 指标监控 | ✅ | ⏳ |
| 安全认证 | Spring Security OAuth2 | 认证授权 | ✅ | ⏳ |
| JWT | Token 方案 | ✅ | ✅ |
三、服务注册与发现
3.1 原理详解
┌─────────────────────────────────────────────────────────────────────────┐
│ 服务注册与发现完整流程 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 服务启动注册 │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ServiceA │ │
│ │ ┌─────────────────┐ │ │
│ │ │ @EnableDiscoveryClient │ │
│ │ │ 或 │ │
│ │ │ @EnableEurekaClient │ │
│ │ └────────┬────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ 1. 读取配置：spring.cloud.nacos.discovery.server-addr │ │ │
│ │ │ 2. 构建实例信息：IP、Port、权重、 metadata │ │ │
│ │ │ 3. 发送注册请求：POST /nacos/v1/ns/instance │ │ │
│ │ │ 4. 建立心跳：定时发送续约心跳 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ └────────────┼───────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Nacos Server │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ Service Registry │ │ │
│ │ │ │ │ │
│ │ │ { │ │ │
│ │ │ "serviceName": "order-service", │ │ │
│ │ │ "hosts": [ │ │ │
│ │ │ { "ip": "192.168.1.101", "port": 8080 }, │ │ │
│ │ │ { "ip": "192.168.1.102", "port": 8080 } │ │ │
│ │ │ { "ip": "192.168.1.103", "port": 8080 } │ │ │
│ │ │ ] │ │ │
│ │ │ } │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ 定时检查 │ │ │
│ │ │ • 心跳超时（15s）→ 从列表移除 │ │ │
│ │ │ • 保护阈值 → 开启阈值保护 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ 2. 服务发现订阅 │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ ServiceB │ │
│ │ ┌─────────────────┐ │ │
│ │ │ DiscoveryClient │ │ │
│ │ └────────┬────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ getInstances("order-service") │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ GET /nacos/v1/ns/instance/list?serviceName=xxx │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 返回可用实例列表 │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 负载均衡选择目标实例 │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
3.2 Nacos 1.x vs 2.x 对比
┌─────────────────────────────────────────────────────────────────────────┐
│ Nacos 1.x vs 2.x 核心差异 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Nacos 1.x │ │ Nacos 2.x │ │
│ │ HTTP 轮询 │ │ gRPC 长连接 │ │
│ └────────┬────────┘ └────────┬────────┘ │
│ │ │ │
│ │ 1. 发送注册请求 │ │
│ ├────────────────────────────► │
│ │ │ 2. 返回 gRPC 端口 │
│ │◄────────────────────────────┤ │
│ │ │ │
│ │ 3. 定时轮询（5s） │ 4. gRPC 推送（<1s） │
│ │◄────────────────────────────┤ │
│ │ │ │
│ │ │ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 性能对比 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 指标 │ 1.x HTTP │ 2.x gRPC │ 提升 │ │
│ │ ─────────────────┼───────────────┼──────────────┼─────────────│ │
│ │ 变更感知延迟 │ 5-30 秒 │ < 1 秒 │ 5-30倍 │ │
│ │ 服务端负载 │ 高（轮询） │ 低（推送） │ 降低80% │ │
│ │ 客户端负载 │ 中等 │ 中等 │ 持平 │ │
│ │ 心跳开销 │ 每次请求 │ 长连接保活 │ 降低90% │ │
│ │ 断线重连 │ 需重试 │ 自动重连 │ 更稳定 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 端口配置变化 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Nacos 1.x: │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ 8848 │ 主端口（HTTP）│ 控制台、API、注册发现 │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Nacos 2.x: │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ 8848 │ 主端口（HTTP）│ 控制台、API │ │ │
│ │ │ 9848 │ gRPC 端口 │ 服务注册发现 │ │ │
│ │ │ 9849 │ gRPC 集群 │ 节点间同步 │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 客户端自动映射：8848 → 9848（端口 + 1000） │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
3.3 服务发现源码解析
// Spring Cloud Commons - 服务发现核心接口
public interface ServiceRegistry<R extends Registration> {
// 注册服务
void register(R registration);
// 注销服务
void deregister(R registration);
// 关闭
void close();
// 设置状态
void setStatus(R registration, String status);
// 获取状态
<T> T getStatus(R registration);
}
// Nacos 实现 - NacosServiceRegistry
public class NacosServiceRegistry implements ServiceRegistry<NacosRegistration> {
private final NacosDiscoveryProperties discoveryProperties;
@Override
public void register(NacosRegistration registration) {
// 1. 检查是否开启注册
if (!discoveryProperties.isRegisterEnabled()) {
return;
}
// 2. 构建 Nacos 实例信息
NamingService namingService = namingService();
String serviceName = registration.getServiceId();
String groupName = discoveryProperties.getGroup();
Instance instance = buildInstance(registration);
// 3. 注册服务
namingService.registerInstance(serviceName, groupName, instance);
}
private Instance buildInstance(NacosRegistration registration) {
Instance instance = new Instance();
instance.setIp(registration.getHost());
instance.setPort(registration.getPort());
instance.setWeight(discoveryProperties.getWeight());
instance.setClusterName(discoveryProperties.getClusterName());
instance.setMetadata(registration.getMetadata());
return instance;
}
}
四、负载均衡
4.1 客户端负载均衡原理
┌─────────────────────────────────────────────────────────────────────────┐
│ 客户端负载均衡执行流程 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 负载均衡调用链 │ │
│ │ │ │
│ │ RestTemplate / WebClient │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ LoadBalancerInterceptor │ │ │
│ │ │ 拦截 @LoadBalanced 注解的 RestTemplate │ │ │
│ │ └────────────────────┬────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ LoadBalancerClient │ │ │
│ │ │ 1. 根据服务名获取服务实例列表 │ │ │
│ │ │ 2. 委托给 LoadBalancer 选择目标实例 │ │ │
│ │ │ 3. 替换 URL 中的服务名为真实 IP:Port │ │ │
│ │ └────────────────────┬────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────┐ │ │
│ │ │ ReactorLoadBalancer<T> │ │ │
│ │ │ 实际执行负载均衡策略 │ │ │
│ │ │ • RoundRobinLoadBalancer（轮询） │ │ │
│ │ │ • RandomLoadBalancer（随机） │ │ │
│ │ │ • WeightedResponseTimeBalancer（加权） │ │ │
│ │ └─────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 源码解析 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ // 1. 启用 @LoadBalanced 的 RestTemplate │ │
│ │ @Bean │ │
│ │ @LoadBalanced │ │
│ │ public RestTemplate restTemplate() { │ │
│ │ return new RestTemplate(); │ │
│ │ } │ │
│ │ │ │
│ │ // 2. 使用服务名调用 │ │
│ │ restTemplate.getForObject("http://order-service/api/orders", │ │
│ │ String.class); │ │
│ │ │ │
│ │ // 3. 拦截器会替换 order-service 为真实地址 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
4.2 负载均衡策略对比
| 策略 | 类名 | 原理 | 适用场景 | 优缺点 |
|---|---|---|---|---|
| 轮询 | RoundRobinLoadBalancer | 依次选择每个实例 | 均匀分布 | ✅ 实现简单 ✅ 请求均匀 ✗ 不感知服务端状态 |
| 随机 | RandomLoadBalancer | 随机选择实例 | 测试环境 | ✅ 实现简单 ✗ 负载不均 |
| 加权响应时间 | WeightedResponseTimeLoadBalancer | 响应时间越短权重越高 | 性能差异大 | ✅ 性能优化 ✗ 依赖响应时间统计 |
| 最小连接数 | BestAvailableLoadBalancer | 选择连接数最少 | 长连接场景 | ✅ 负载更均衡 ✗ 实现复杂 |
| 可用区感知 | ZoneAvoidanceLoadBalancer | 优先选择同区实例 | 跨区部署 | ✅ 高可用 ✗ 需要多可用区 |
4.3 Ribbon 到 LoadBalancer 迁移
// ==================== Ribbon 旧写法（已废弃）====================
@Configuration
public class RibbonConfig {
@Bean
public IRule ribbonRule() {
// 轮询策略
return new RoundRobinRule();
// 权重策略
// return new WeightedResponseTimeRule();
// 随机策略
// return new RandomRule();
}
}
// 使用 RibbonClient 指定配置
@RibbonClient(name = "order-service", configuration = RibbonConfig.class)
// ==================== LoadBalancer 新写法（推荐）====================
@Configuration
public class LoadBalancerConfig {
// 替换 Ribbon 的 IRule
@Bean
public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
ServiceInstanceListSupplier supplier) {
return new RandomLoadBalancer(supplier, "random-instance");
}
// 使用 @LoadBalancerClient 指定配置
@LoadBalancerClient(name = "order-service",
configuration = LoadBalancerConfig.class)
}
// ==================== 全局默认配置 ====================
@EnableConfigurationProperties(LoadBalancerClientsProperties.class)
public class CustomLoadBalancerClientConfiguration {
// 设置全局默认负载均衡策略
@Bean
public ReactorLoadBalancer<ServiceInstance> reactorServiceInstanceLoadBalancer(
Environment environment,
ServiceInstanceListSupplier supplier) {
String name = environment.getProperty(LoadBalancerClientName.PROPERTY_NAME);
return new RoundRobinLoadBalancer(supplier, name);
}
}
五、配置中心
5.1 配置中心架构
┌─────────────────────────────────────────────────────────────────────────┐
│ 配置中心完整架构图 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ │ Git Repository │ │
│ │ │ │
│ │ ┌───────────┐ │ │
│ │ │ config/ │ │ │
│ │ │ ├── dev │ │ │
│ │ │ ├── test│ │ │
│ │ │ └── prod│ │ │
│ │ └───────────┘ │ │
│ └────────┬─────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ Config Server │ │
│ │ │ │
│ │ ┌───────────┐ │ │
│ │ │ 应用配置 │ │ │
│ │ │ bootstrap │ │ │
│ │ │ .yaml │ │ │
│ │ └───────────┘ │ │
│ └────────┬─────────┘ │
│ │ │
│ ┌───────────────────┼───────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Service A │ │ Service B │ │ Service C │ │
│ │ Instance 1 │ │ Instance 1 │ │ Instance 1 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ Service A │ │ Service B │ │ Service C │ │
│ │ Instance 2 │ │ Instance 2 │ │ Instance 2 │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ @RefreshScope 刷新机制 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ 1. Git 配置变更 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 2. POST /actuator/refresh → 触发刷新 │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 3. ContextRefresher.refresh() │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 4. 销毁 @RefreshScope Bean │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ 5. 重新创建 Bean，加载新配置 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
5.2 Spring Cloud Bus 配置广播
┌─────────────────────────────────────────────────────────────────────────┐
│ Spring Cloud Bus 配置广播 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 无 Spring Cloud Bus（痛苦模式） │ │
│ │ │ │
│ │ Git ──▶ Config Server │ │
│ │ │ │ │
│ │ ┌──────┴──────┬───────┬───────┬───────┐ │ │
│ │ ▼ ▼ ▼ ▼ ▼ │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │Svc A│ │Svc B│ │Svc C│ │Svc D│ │Svc E│ │ │
│ │ │Inst1│ │Inst1│ │Inst1│ │Inst1│ │Inst1│ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ │ │ │
│ │ 需要手动调用 100 个 /actuator/refresh 端点！ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ▼ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 有 Spring Cloud Bus（优雅模式） │ │
│ │ │ │
│ │ Git ──▶ Config Server ──▶ RabbitMQ / Kafka │ │
│ │ │ │ │
│ │ ┌────────┴────────┐ │ │
│ │ ▼ ▼ │ │
│ │ ┌────────────────┐ ┌────────────────┐ │ │
│ │ │ Spring Cloud │ │ Spring Cloud │ │ │
│ │ │ Bus │ │ Bus │ │ │
│ │ │ (RabbitMQ) │ │ (Kafka) │ │ │
│ │ └───────┬────────┘ └───────┬────────┘ │ │
│ │ │ │ │ │
│ │ ┌──────────────────┼─────────────────┼──────────────┐ │ │
│ │ ▼ ▼ ▼ ▼ │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │Svc A│ │Svc B│ │Svc C│ │Svc D│ │Svc E│ │Svc F│ │ │
│ │ │Inst1│ │Inst1│ │Inst1│ │Inst1│ │Inst1│ │Inst1│ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ │ │ │
│ │ 只需调用 /bus-refresh 一次，自动广播到所有实例！ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
六、弹性容错
6.1 弹性容错四板斧
┌─────────────────────────────────────────────────────────────────────────┐
│ 弹性容错四板斧详解 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 限流（Rate Limiting） │ │
│ │ │ │
│ │ 问题：系统资源有限，请求量超过处理能力会崩溃 │ │
│ │ │ │
│ │ 解决方案：控制每秒/每分钟允许的请求数量 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ 请求 ──▶ [限流器] ──▶ 通过 ──▶ 处理 │ │ │
│ │ │ │ │ │ │
│ │ │ │ 超过阈值 │ │ │
│ │ │ ▼ │ │ │
│ │ │ 拒绝/排队 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Sentinel 实现： │ │
│ │ • QPS 流控：每秒请求数 │ │
│ │ • 线程数流控：并发执行线程数 │ │
│ │ • 关联流控：A 关联 B，A 超过阈值限制 B │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 熔断（Circuit Breaker） │ │
│ │ │ │
│ │ 问题：下游服务故障，持续调用会拖垮上游服务（雪崩） │ │
│ │ │ │
│ │ 解决方案：检测到故障后快速失败，一段时间后尝试恢复 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ 正常状态 ──▶ [统计失败率] ──▶ 超过阈值 ──▶ 熔断打开 │ │ │
│ │ │ │ │ │ │
│ │ │ ▼ │ │ │
│ │ │ 快速失败返回 │ │ │
│ │ │ │ │ │ │
│ │ │ 等待时间窗口 │ │ │
│ │ │ ▼ │ │ │
│ │ │ 熔断半开 │ │ │
│ │ │ │ │ │ │
│ │ │ 成功 ──▶ 熔断关闭 │ │ │
│ │ │ 失败 ──▶ 熔断打开 │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Sentinel 实现： │ │
│ │ • 慢调用比例：响应时间超过阈值视为慢调用 │ │
│ │ • 异常比例：异常请求占总请求比例 │ │
│ │ • 异常数：异常请求数超过阈值 │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 降级（Fallback） │ │
│ │ │ │
│ │ 问题：服务不可用时，用户请求必须有响应 │ │
│ │ │ │
│ │ 解决方案：提供兜底逻辑，返回默认值或友好提示 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ @SentinelResource(value = "getUser", │ │ │
│ │ │ fallback = "getUserFallback") │ │ │
│ │ │ public User getUser(Long id) { │ │ │
│ │ │ return userService.getUser(id); │ │ │
│ │ │ } │ │ │
│ │ │ │ │ │
│ │ │ // 兜底方法 │ │ │
│ │ │ public User getUserFallback(Long id, Throwable t) { │ │ │
│ │ │ log.error("获取用户失败: {}", id, t); │ │ │
│ │ │ return User.defaultUser(); // 返回默认用户 │ │ │
│ │ │ } │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 降级策略： │ │
│ │ • 返回默认值 │ │
│ │ • 返回缓存数据 │ │
│ │ • 返回友好提示 │ │
│ │ • 跳转降级页面 │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────┐ │
│ │ 重试（Retry） │ │
│ │ │ │
│ │ 问题：网络抖动或临时故障，一次请求可能失败 │ │
│ │ │ │
│ │ 解决方案：失败后自动重试，提高请求成功率 │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ try { │ │ │
│ │ │ return restTemplate.getForObject(url, User.class); │ │ │
│ │ │ } catch (RestClientException e) { │ │ │
│ │ │ // 重试 3 次，每次间隔 100ms │ │ │
│ │ │ return RetryTemplate.builder() │ │ │
│ │ │ .maxAttempts(3) │ │ │
│ │ │ .fixedBackoff(100) │ │ │
│ │ │ .retryableException(RestClientException.class) │ │ │
│ │ │ .build() │ │ │
│ │ │ .execute(ctx -> restTemplate.getForObject(url, │ │ │
│ │ │ User.class)); │ │ │
│ │ │ } │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ 重试策略： │ │
│ │ • 固定间隔 │ │
│ │ • 指数退避 │ │
│ │ • 抖动 │ │
│ │ │ │
│ │ 注意：重试需要接口幂等性保证！ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
6.2 Sentinel 核心概念
┌─────────────────────────────────────────────────────────────────────────┐
│ Sentinel 核心概念图 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Sentinel 架构 │ │
│ │ │ │
│ │ ┌──────────────┐ │ │
│ │ │ Dashboard │ ◀── 管理控制台，配置规则 │ │
│ │ │ (8080) │ │ │
│ │ └──────┬───────┘ │ │
│ │ │ │ │
│ │ │ 拉取/推送规则 │ │
│ │ ┌──────┴───────┐ │ │
│ │ │ │ │ │
│ │ ▼ ▼ │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │Service A│ │Service B│ │Service C│ │Service D│ │ │
│ │ │ Sentinel│ │ Sentinel│ │ Sentinel│ │ Sentinel│ │ │
│ │ │ Client │ │ Client │ │ Client │ │ Client │ │ │
│ │ └────────┘ └────────┘ └────────┘ └────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 滑动窗口算法 │ │
│ │ │ │
│ │ 统计最近 1 秒内的请求（默认） │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐ │ │ │
│ │ │ │ 100│ 100│ 100│ 100│ 100│ 100│ 100│ 100│ 100│ 100│ │ │ │
│ │ │ │ ms │ ms │ ms │ ms │ ms │ ms │ ms │ ms │ ms │ ms │ │ │ │
│ │ │ └──┬─┴────┴────┴────┴────┴────┴────┴────┴────┴────┘ │ │ │
│ │ │ │ Window 2 (当前窗口) │ │ │
│ │ │ │ │ │ │
│ │ │ └──────▶ 滑动窗口 ◀──────────────────────── │ │ │
│ │ │ │ │ │
│ │ │ 当前时间 ──────────────────────────────────▶ │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ QPS = 统计窗口内的请求总数 / 窗口时间 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Slot Chain 责任链 │ │
│ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ Node │───▶│ Stat │───▶│ Log │───▶│ Check │ │ │
│ │ │ Slot │ │ Slot │ │ Slot │ │ Slot │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ └────┬────┘ │ │
│ │ │ │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ WarmUp │───▶│ Flow │───▶│ Degrade│───▶ │ │ │
│ │ │ Slot │ │ Slot │ │ Slot │ │ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ ▼ │ │
│ │ ┌────────────────────────────────────────────────────────────────┐│ │
│ │ │ 执行目标方法 ││ │
│ │ └────────────────────────────────────────────────────────────────┘│ │
│ │ │ │
│ │ 职责说明： │ │
│ │ • NodeSelectorSlot：构建资源调用树 │ │
│ │ • ClusterBuilderSlot：统计实时数据 │ │
│ │ • StatisticSlot：记录通过/拒绝/限流/熔断统计 │ │
│ │ • FlowSlot：根据 QPS/并发数进行流量控制 │ │
│ │ • DegradeSlot：根据异常比例/慢调用进行熔断降级 │ │
│ │ • WarmUpSlot：冷启动，根据系统负载预热 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
七、服务网关
7.1 Gateway 请求处理流程
┌─────────────────────────────────────────────────────────────────────────┐
│ Gateway 请求处理完整流程 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 请求 ──▶ Netty Server ──▶ Reactor Http Server │
│ │ │
│ ▼ │
│ ┌────────────────────────────────┐ │
│ │ Gateway Web Handler │ │
│ │ │ │
│ │ 1. 根据请求路径匹配 Route │ │
│ │ 2. 构建 GatewayFilterChain │ │
│ │ 3. 依次执行 Gateway Filters │ │
│ └───────────────┬────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────┐ │
│ │ Route Predicate Handler │ │
│ │ │ │
│ │ Path=/api/order/** │ │
│ │ ──▶ Route ID: order_route │ │
│ │ ──▶ URI: lb://order-service │ │
│ └───────────────┬────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ Gateway Filter Chain │ │
│ ├────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ┌──────────────────────────────────────────────────────────┐ │ │
│ │ │ 1. RemoveCachedBodyFilter - 移除请求体缓存 │ │ │
│ │ └──────────────────────────────────────────────────────────┘ │ │
│ │ ┌──────────────────────────────────────────────────────────┐ │ │
│ │ │ 2. AdaptCachedBodyFilter - 适配缓存请求体 │ │ │
│ │ └──────────────────────────────────────────────────────────┘ │ │
│ │ ┌──────────────────────────────────────────────────────────┐ │ │
│ │ │ 3. GatewayFilterChain 执行自定义过滤器 │ │ │
│ │ │ • RequestSizeGatewayFilter - 请求大小限制 │ │ │
│ │ │ • RetryGatewayFilter - 重试机制 │ │ │
│ │ │ • SetStatusGatewayFilter - 设置响应状态码 │ │ │
│ │ └──────────────────────────────────────────────────────────┘ │ │
│ │ ┌──────────────────────────────────────────────────────────┐ │ │
│ │ │ 4. NettyRoutingFilter - 执行真实路由转发 │ │ │
│ │ └──────────────────────────────────────────────────────────┘ │ │
│ │ ┌──────────────────────────────────────────────────────────┐ │ │
│ │ │ 5. WebClientWriteResponseFilter - 处理响应 │ │ │
│ │ └──────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ Order Service │ │
│ │ (lb://) │ │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
7.2 动态路由配置
spring:
cloud:
gateway:
# 静态路由配置
routes:
# 订单服务路由
- id: order-route
uri: lb://order-service
predicates:
- Path=/api/order/**
- Method=GET,POST
- Header=X-Token, .+
filters:
# 路径重写：/api/order/** -> /**
- RewritePath=/api/order/(?<segment>.*), /$\{segment}
# 添加请求头
- AddRequestHeader=X-Gateway, SpringCloudGateway
# 移除响应头
- RemoveResponseHeader=X-Powered-By
# 请求限流
- name: RequestRateLimiter
args:
redis-rate-limiter.replenishRate: 100
redis-rate-limiter.burstCapacity: 200
# 熔断
- name: CircuitBreaker
args:
name: orderCircuitBreaker
fallbackUri: forward:/fallback/order
# 商品服务路由
- id: product-route
uri: lb://product-service
predicates:
- Path=/api/product/**
filters:
- RewritePath=/api/product/(?<segment>.*), /$\{segment}
# 用户服务路由
- id: user-route
uri: lb://user-service
predicates:
- Path=/api/user/**
filters:
- RewritePath=/api/user/(?<segment>.*), /$\{segment}
# 默认过滤器（对所有路由生效）
default-filters:
- AddRequestHeader=X-Request-Time, #{T(System).currentTimeMillis()}
- RemoveRequestHeader=Cookie
# 动态路由刷新（配合配置中心使用）
discovery:
locator:
enabled: true
lower-case-service-id: true
url-expression: "'lb://' + serviceId"
八、分布式事务
8.1 Seata AT 模式原理
┌─────────────────────────────────────────────────────────────────────────┐
│ Seata AT 模式执行流程 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 全局事务发起 │ │
│ │ │ │
│ │ @GlobalTransactional │ │
│ │ public void createOrder(OrderDTO order) { │ │
│ │ // 1. 创建订单（TC 创建全局事务记录） │ │
│ │ orderService.create(order); │ │
│ │ // 2. 扣减库存（TC 创建分支事务记录） │ │
│ │ stockService.deduct(order.getProductId(), order.getQty());│ │
│ │ // 3. 扣减余额 │ │
│ │ accountService.deduct(order.getUserId(), order.getAmount());│ │
│ │ } │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Branch Transaction │ │
│ │ │ │
│ │ Phase 1: 本地业务 + Undo Log 记录 │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ BEGIN; │ │ │
│ │ │ INSERT INTO orders (...) VALUES (...); │ │ │
│ │ │ INSERT INTO undo_log (...) VALUES (...); -- 记录前置镜像 │ │ │
│ │ │ COMMIT; │ │ │
│ │ └────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ │ Phase 2: 全局提交/回滚 │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ 成功 → TC 通知所有分支提交 → 删除 undo_log │ │ │
│ │ │ 失败 → TC 通知所有分支回滚 → 根据 undo_log恢复数据 │ │ │
│ │ └────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Undo Log 结构 │ │
│ │ │ │
│ │ { │ │
│ │ "branchId": 123456, │ │
│ │ "xid": "192.168.1.100:8091:123456789", │ │
│ │ "rollbackInfo": { │ │
│ │ "beforeImage": { │ │
│ │ "rows": [ │ │
│ │ { "fields": [ │ │
│ │ { "name": "balance", "type": 4, "value": 1000 } │ │
│ │ ]} │ │
│ │ ] │ │
│ │ }, │ │
│ │ "afterImage": { │ │
│ │ "rows": [ │ │
│ │ { "fields": [ │ │
│ │ { "name": "balance", "type": 4, "value": 900 } │ │
│ │ ]} │ │
│ │ ] │ │
│ │ } │ │
│ │ } │ │
│ │ } │ │
│ │ │ │
│ │ 回滚时：根据 beforeImage 恢复数据 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
8.2 三种模式对比
| 模式 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| AT | 自动补偿，通过 undo log | 低侵入，业务无感知 | 性能损耗，需要 undo 表 | 一致性要求高 |
| TCC | 手动补偿，Try-Confirm-Cancel | 性能好，无锁 | 业务侵入大 | 性能要求高 |
| Saga | 编排补偿，正向服务 | 长事务支持 | 无隔离性 | 长流程事务 |
九、技术选型建议
9.1 组件选型矩阵
| 场景 | 推荐方案 | 备选方案 | 选择理由 |
|---|---|---|---|
| 注册中心 | Nacos 2.x | Consul | 国产、活跃、功能全 |
| 配置中心 | Nacos Config | Apollo | 与注册中心合一 |
| 网关 | SpringCloud Gateway | Kong | Spring 生态原生 |
| 负载均衡 | LoadBalancer | - | Spring Cloud 原生 |
| 熔断限流 | Sentinel | Resilience4j | 功能完整、配套控制台 |
| 配置刷新 | Spring Cloud Bus | - | 与 Spring 深度集成 |
| 分布式事务 | Seata AT | Seata TCC | 阿里生产验证 |
| 链路追踪 | SkyWalking | Zipkin | 功能更强大 |
9.2 版本对应关系
┌─────────────────────────────────────────────────────────────────────────┐
│ Spring Cloud 版本兼容性 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 版本对照表 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Spring Boot │ Spring Cloud │ 状态 │ Java 版本 │ │
│ │ ──────────── │ ──────────── │ ────── │ ──────── │ │
│ │ 3.2.x │ 2023.0.x │ ✅ 最新 │ 17+ │ │
│ │ 3.1.x │ 2022.0.x │ ✅ 稳定 │ 17+ │ │
│ │ 2.7.x │ 2021.0.x │ ✅ 稳定 │ 8-17 │ │
│ │ 2.6.x │ 2021.0.x │ ⚠️ 维护 │ 8-17 │ │
│ │ 2.5.x │ 2020.0.x │ ⚠️ 维护 │ 8-11 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 组件版本对照 │ │
│ ├─────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Spring Cloud Alibaba 版本命名：Spring Cloud 版本 + 0.x.x │ │
│ │ │ │
│ │ Spring Boot 2.7.x ──▶ Spring Cloud 2021.0.x │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ Spring Cloud Alibaba │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────┬─────────┬─────────┬─────────┬─────────┐ │ │
│ │ │ Nacos │ Sentinel│ Seata │ Dubbo │ 组件 │ │ │
│ │ │ 2.0.x │ 1.8.x │ 1.5.x │ 2.7.x │ 版本 │ │ │
│ │ └─────────┴─────────┴─────────┴─────────┴─────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
十、学习路径
┌─────────────────────────────────────────────────────────────────────────┐
│ Spring Cloud 学习路径图 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 第一阶段：基础入门（1-2周） │ │
│ │ │ │
│ │ 目标：理解微服务架构核心概念，能够搭建简单微服务系统 │ │
│ │ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ 服务注册 │ │ 服务调用 │ │ 服务网关 │ │ │
│ │ │ 与发现 │ │ │ │ │ │ │
│ │ │ │ │ OpenFeign │ │ Gateway │ │ │
│ │ │ Nacos │ │ │ │ │ │ │
│ │ │ Eureka │ │ RestTemplate│ │ 动态路由 │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────────┐ │ │
│ │ │ 配置中心 │ │ │
│ │ │ │ │ │
│ │ │ Nacos Config│ │ │
│ │ │ Config Server│ │ │
│ │ │ │ │ │
│ │ │ bootstrap │ │ │
│ │ │ @RefreshScope│ │ │
│ │ └──────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 第二阶段：弹性容错（2-3周） │ │
│ │ │ │
│ │ 目标：掌握高可用设计，能够应对服务故障 │ │
│ │ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ 负载均衡 │ │ 熔断限流 │ │ 服务降级 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ LoadBalancer │ │ Sentinel │ │ @SentinelRes│ │ │
│ │ │ │ │ │ │ ource │ │ │
│ │ │ 轮询/加权 │ │ FlowControl │ │ │ │ │
│ │ │ 最小连接 │ │ Degrade │ │ Fallback │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ 客户端重试 │ │ 分布式事务 │ │ │
│ │ │ │ │ │ │ │
│ │ │ Spring Retry│ │ Seata │ │ │
│ │ │ │ │ │ │ │
│ │ │ RetryTemplate│ │ AT/TCC/Saga │ │ │
│ │ │ │ │ │ │ │
│ │ │ Backoff │ │ 全局锁 │ │ │
│ │ └──────────────┘ └──────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 第三阶段：可观测性（2周） │ │
│ │ │ │
│ │ 目标：掌握链路追踪和监控，能够定位性能问题 │ │
│ │ │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │
│ │ │ 链路追踪 │ │ 监控告警 │ │ 日志聚合 │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Sleuth │ │ Prometheus │ │ ELK │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ Zipkin │ │ Grafana │ │ Logstash │ │ │
│ │ │ │ │ │ │ │ │ │
│ │ │ TraceId │ │ Dashboard │ │ Kibana │ │ │
│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 第四阶段：安全认证（1-2周） │ │
│ │ │ │
│ │ 目标：掌握微服务认证方案，能够设计安全架构 │ │
│ │ │ │
│ │ ┌────────────────────────────────────────────────────────┐ │ │
│ │ │ │ │ │
│ │ │ OAuth2 + JWT │ │ │
│ │ │ │ │ │
│ │ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │ │
│ │ │ │ 授权 │────▶│ 颁发 │────▶│ 验证 │ │ │ │
│ │ │ │ 服务器 │ │ Token │ │ Token │ │ │ │
│ │ │ └─────────┘ └─────────┘ └─────────┘ │ │ │
│ │ │ │ │ │
│ │ │ Spring Security OAuth2 / JWT / Spring Security │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
十一、核心知识点汇总
11.1 知识图谱 MindMap
┌─────────────────────────────────────────────────────────────────────────┐
│ Spring Cloud 知识图谱 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Spring Cloud │
│ │ │
│ ┌─────────────┬───────────┼───────────┬─────────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │服务治理 │ │配置管理 │ │弹性容错 │ │网关路由 │ │可观测性 │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │ │ │
│ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ ┌────┴────┐ │
│ │注册发现 │ │配置加载 │ │限流 │ │路由匹配 │ │链路追踪 │ │
│ │负载均衡 │ │热刷新 │ │熔断 │ │过滤器链 │ │日志聚合 │ │
│ │健康检查 │ │多环境 │ │降级 │ │限流认证 │ │监控告警 │ │
│ │心跳续约 │ │消息广播 │ │重试 │ │跨域 │ │健康检查 │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │
│ 关联系列 │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │框架原理 │ │弹性容错 │ │安全认证 │ │微服务网关│ │数据存储 │ │
│ │ │ │ │ │ │ │ │ │ │ │
│ │SpringBoot│ │Sentinel │ │OAuth2 │ │Gateway │ │Redis │ │
│ │Spring │ │Seata │ │JWT │ │限流 │ │MySQL │ │
│ │SpringMVC │ │ │ │SpringSec│ │跨域 │ │ES │ │
│ └─────────┘ └─────────┘ └─────────┘ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
11.2 面试高频问题
| 类别 | 问题 | 答案要点 |
|---|---|---|
| 注册发现 | Nacos 和 Eureka 的区别？ | Nacos 支持配置中心、国产、2.0 gRPC；Eureka 已停更 |
| Nacos 2.0 为什么更快？ | gRPC 推送 vs HTTP 轮询，<1s vs 5-30s | |
| 负载均衡 | Ribbon 和 LoadBalancer 的区别？ | LB 是 Ribbon 的替代品，函数式编程 |
| 负载均衡策略有哪些？ | 轮询、随机、加权、最小连接数 | |
| 配置中心 | @RefreshScope 如何实现热刷新？ | 销毁 Bean + 重新创建 |
| Spring Cloud Bus 的作用？ | 配置变更广播到所有实例 | |
| 弹性容错 | Sentinel 和 Hystrix 的区别？ | Sentinel 更活跃、功能更完整 |
| 熔断器的三种状态？ | 关闭→打开→半开 | |
| 分布式事务 | AT 和 TCC 的区别？ | AT 自动补偿 vs TCC 手动补偿 |
| Seata 的全局锁何时释放？ | 分支事务完成后释放 | |
| 网关 | Gateway 和 Zuul 的区别？ | Gateway 基于 WebFlux，性能更高 |
| 如何实现限流？ | Redis + RequestRateLimiter |
十二、常见问题与解决方案
12.1 服务注册问题
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 服务注册失败 | 网络不通 | 检查防火墙、安全组 |
| 注册开关未开启 | spring.cloud.nacos.discovery.registerEnabled=true | |
| 端口未开放 | 开放 Nacos 8848/9848 端口 | |
| 实例被剔除 | 心跳超时 | 检查心跳间隔（默认 5s）和超时时间（默认 15s） |
| 服务端负载高 | 开启保护阈值 nacos.instances.protected.enabled |
12.2 负载均衡问题
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 负载不均 | 权重未配置 | 调整实例权重 |
| 最小连接数未生效 | 检查 LoadBalancer 实现 | |
| 服务调用失败 | 服务未注册 | 检查注册中心连接 |
| 实例不健康 | 检查健康检查配置 |
12.3 配置刷新问题
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 配置未生效 | 未加 @RefreshScope | Bean 上添加注解 |
| 未暴露 actuator 端点 | 配置 management.endpoints.web.exposure.include=refresh | |
| 静态变量未刷新 | 使用 @ConfigurationProperties 绑定配置 |
12.4 熔断降级问题
| 问题 | 原因 | 解决方案 |
|---|---|---|
| 所有请求都降级 | 熔断阈值过低 | 调高异常比例/慢调用比例阈值 |
| 统计窗口过短 | 增大统计窗口时间 | |
| 降级方法未执行 | 方法签名错误 | 降级方法需要与原方法参数一致 |
| 注解使用错误 | 使用 fallback 而非 fallbackFactory |
十三、总结
13.1 核心要点回顾
┌─────────────────────────────────────────────────────────────────────────┐
│ 微服务架构核心要点总结 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 1. 服务治理：注册发现 + 负载均衡 │ │
│ │ • Nacos 2.0 使用 gRPC，性能提升 5-30 倍 │ │
│ │ • LoadBalancer 是 Ribbon 的替代方案 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 2. 配置管理：配置中心 + 消息总线 │ │
│ │ • @RefreshScope 实现配置热刷新 │ │
│ │ • Spring Cloud Bus 实现配置广播 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 3. 弹性容错：限流 + 熔断 + 降级 + 重试 │ │
│ │ • Sentinel 是主流熔断限流方案 │ │
│ │ • 四板斧：限流→熔断→降级→重试 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 4. 网关路由：路由 + 过滤器 + 安全 │ │
│ │ • Gateway 基于 WebFlux，性能优于 Zuul │ │
│ │ • 过滤器链是核心机制 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 5. 分布式事务：AT + TCC + Saga │ │
│ │ • AT 模式低侵入，通过 undo log 自动补偿 │ │
│ │ • 根据场景选择合适的事务模式 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
13.2 与其他系列关联
| 本系列 | 关联系列 | 关联内容 |
|---|---|---|
| 微服务架构 | 框架原理 | SpringBoot 自动装配、Spring 核心机制 |
| 微服务网关 | Gateway 动态路由、限流、过滤器链 | |
| 弹性容错 | Sentinel 熔断限流、Seata 分布式事务 | |
| 安全认证 | OAuth2 + JWT 微服务认证 | |
| 可观测性 | 链路追踪、健康检查、监控告警 | |
| 数据存储 | Redis 缓存、MySQL 事务 |
参考资料
- Spring Cloud 官方文档
- Spring Cloud Alibaba 官方文档
- Nacos 官方文档
- Sentinel 官方文档
- Seata 官方文档
- Spring Cloud Gateway 官方文档
更多推荐
10
0- 0
已为社区贡献3条内容
所有评论(0)