Spring Cloud微服务架构深度解析：把分布式核心讲透，你真的了解吗？
🎯 写在前面：在微服务时代，Spring Cloud是Java后端工程师必须掌握的技能。但很多人只是会用，却不理解其背后的原理。这篇文章，将带你从源码层面深度剖析Spring Cloud的核心组件！
一、微服务架构基础：什么是微服务？
1.1 单体架构 vs 微服务架构
┌─────────────────────────────────────────────────────────────────┐
│ 单体架构 │
├─────────────────────────────────────────────────────────────────┤
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ 单体应用 │ │
│ │ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │ │
│ │ │用户 │ │订单 │ │支付 │ │商品 │ │库存 │ │ │
│ │ │模块 │ │模块 │ │模块 │ │模块 │ │模块 │ │ │
│ │ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ │ │
│ └─────────────────────────────────────────────────────────┘ │
│ ↓ │
│ 问题：所有模块耦合在一起，修改任何一个模块都需要重新部署整个应用 │
└─────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────┐
│ 微服务架构 │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ │
│ │用户 │ │订单 │ │支付 │ │商品 │ │库存 │ │
│ │服务 │ │服务 │ │服务 │ │服务 │ │服务 │ │
│ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ └──┬──┘ │
│ │ │ │ │ │ │
│ └──────────┴──────────┴──────────┴──────────┘ │
│ ↓ │
│ ┌───────────────┐ │
│ │ 注册中心 │ │
│ │ (Nacos/Eureka)│ │
│ └───────────────┘ │
│ │
│ 优势：每个服务独立部署、独立扩展、独立技术栈 │
└─────────────────────────────────────────────────────────────────┘
1.2 Spring Cloud核心组件全景图
┌─────────────────────────────────────────────────────────────────────┐
│ Spring Cloud组件全景图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 服务治理 │ │
│ │ 注册中心：Nacos / Eureka / Consul │ │
│ │ 配置中心：Nacos Config / Apollo / Spring Cloud Config │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 网关层 │ │
│ │ Spring Cloud Gateway / Zuul │ │
│ │ 路由转发、限流、熔断、认证鉴权 │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 服务调用 │ │
│ │ OpenFeign（声明式HTTP客户端） │ │
│ │ Ribbon（负载均衡器） │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ 容错保护 │ │
│ │ Sentinel / Resilience4j / Hystrix │ │
│ │ 熔断、降级、限流 │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
二、服务注册与发现：Nacos深度剖析
2.1 Nacos注册原理
// 服务注册示例
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
public static void main(String[] args) {
SpringApplication.run(UserServiceApplication.class, args);
}
}
// application.yml配置
spring:
application:
name: user-service // 服务名
cloud:
nacos:
discovery:
server-addr: 127.0.0.1:8848 // Nacos地址
namespace: dev // 命名空间
group: DEFAULT_GROUP // 分组
2.2 Nacos注册流程
┌─────────────────────────────────────────────────────────────────────┐
│ Nacos服务注册流程 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 1. 服务启动 │
│ ↓ │
│ 2. Spring Cloud自动装配NacosServiceAutoConfiguration │
│ ↓ │
│ 3. 创建NacosNamingService实例 │
│ ↓ │
│ 4. 定时任务：发送心跳（默认5秒） │
│ ↓ │
│ 5. 注册服务：POST /nacos/v1/ns/instance │
│ ↓ │
│ 6. Nacos Server保存服务实例到内存 │
│ ↓ │
│ 7. 推送变更事件给订阅者 │
│ │
└─────────────────────────────────────────────────────────────────────┘
2.3 服务发现与负载均衡
// 服务调用 - 使用Feign声明式HTTP客户端
@FeignClient(name = "order-service", fallback = OrderServiceFallback.class)
public interface OrderFeignClient {
@GetMapping("/order/{userId}")
List<Order> getOrders(@PathVariable("userId") Long userId);
@PostMapping("/order/create")
Order createOrder(@RequestBody OrderRequest request);
}
// 启用Feign客户端
@EnableFeignClients
@SpringBootApplication
public class OrderConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(OrderConsumerApplication.class, args);
}
}
// 实现降级逻辑
@Component
public class OrderServiceFallback implements OrderFeignClient {
@Override
public List<Order> getOrders(Long userId) {
// 降级处理：返回空列表或缓存数据
return Collections.emptyList();
}
@Override
public Order createOrder(OrderRequest request) {
// 降级处理
return null;
}
}
三、网关：Spring Cloud Gateway深度剖析
3.1 Gateway工作原理
┌─────────────────────────────────────────────────────────────────────┐
│ Spring Cloud Gateway工作原理 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 请求 → Gateway Handler Mapping（路由匹配） │
│ ↓ │
│ Gateway Web Handler（过滤器链） │
│ ↓ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Filter Chain │ │
│ │ │ │
│ │ 1. GlobalFilter A ←── 自定义全局过滤器 │ │
│ │ 2. GatewayFilter B ←── 路由特定过滤器 │ │
│ │ 3. GatewayFilter C │ │
│ │ 4. ... │ │
│ │ 5. Netty Routing Filter ←── 转发请求到下游服务 │ │
│ │ 6. ... │ │
│ │ 7. GatewayFilter C │ │
│ │ 8. GatewayFilter B │ │
│ │ 9. GlobalFilter A │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ ↓ │
│ 响应 │
│ │
└─────────────────────────────────────────────────────────────────────┘
3.2 Gateway核心配置
spring:
cloud:
gateway:
# 路由配置
routes:
# 用户服务路由
- id: user-service
uri: lb://user-service # lb表示负载均衡
predicates:
- Path=/api/user/**
- After=2024-01-01T00:00:00Z # 时间断言
- Header=X-Request-Id, \d+ # 请求头断言
filters:
- StripPrefix=1 # 去掉第一层路径 /api/user/** -> /user/**
- RequestRateLimiter=10,20 # 限流：每秒10个请求，突发20个
# 订单服务路由
- id: order-service
uri: lb://order-service
predicates:
- Path=/api/order/**
filters:
- StripPrefix=1
- name: RequestSize
args:
maxSize: 5000000 # 最大请求体5MB
# 静态资源路由
- id: static-resources
uri: https://static.example.com
predicates:
- Path=/static/**
# 全局默认过滤器
default-filters:
- AddRequestHeader=X-Gateway, SpringCloudGateway
- AddResponseHeader=X-Response-Time, #{T(System).currentTimeMillis()}
# 全局跨域配置
globalcors:
cors-configurations:
'[/**]':
allowedOrigins: "*"
allowedMethods:
- GET
- POST
- PUT
- DELETE
allowedHeaders: "*"
3.3 自定义全局过滤器
// 认证鉴权过滤器
@Component
public class AuthFilter implements GlobalFilter, Ordered {
@Autowired
private JwtUtil jwtUtil;
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
String path = request.getURI().getPath();
// 1. 放行登录接口
if (path.contains("/auth/login") || path.contains("/auth/register")) {
return chain.filter(exchange);
}
// 2. 获取Token
String token = request.getHeaders().getFirst("Authorization");
if (token == null || !token.startsWith("Bearer ")) {
return unauthorized(exchange, "Missing or invalid token");
}
token = token.substring(7);
// 3. 验证Token
try {
Claims claims = jwtUtil.parseToken(token);
String userId = claims.getSubject();
// 4. 将用户信息传递给下游服务
ServerHttpRequest modifiedRequest = request.mutate()
.header("X-User-Id", userId)
.header("X-User-Role", claims.get("role", String.class))
.build();
return chain.filter(exchange.mutate().request(modifiedRequest).build());
} catch (Exception e) {
return unauthorized(exchange, "Token verification failed");
}
}
private Mono<Void> unauthorized(ServerWebExchange exchange, String message) {
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.UNAUTHORIZED);
response.getHeaders().add("Content-Type", "application/json");
String body = "{\"code\": 401, \"message\": \"" + message + "\"}";
DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
return response.writeWith(Mono.just(buffer));
}
@Override
public int getOrder() {
return -100; // 优先级，数字越小越先执行
}
}
// 限流过滤器（令牌桶算法）
@Component
public class RateLimiterFilter implements GlobalFilter, Ordered {
private final Map<String, Bucket> buckets = new ConcurrentHashMap<>();
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String key = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
// 获取或创建令牌桶（每秒10个请求）
Bucket bucket = buckets.computeIfAbsent(key, k ->
Bucket.builder()
.addLimit(Bandwidth.classic(10, Refill.intervally(10, Duration.ofSeconds(1))))
.build()
);
// 尝试获取令牌
if (bucket.tryConsume(1)) {
return chain.filter(exchange);
} else {
exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
}
}
@Override
public int getOrder() {
return -200;
}
}
四、熔断降级：Sentinel深度剖析
4.1 Sentinel vs Hystrix 对比
┌─────────────────────────────────────────────────────────────────────┐
│ 熔断器对比 │
├──────────────────────┬──────────────────────────────────────────────┤
│ Hystrix │ Sentinel │
├──────────────────────┼──────────────────────────────────────────────┤
│ 设计模式 │ 实时统计 + 滑动窗口 │
│ 线程池隔离 │ 信号量隔离 / 线程池隔离 │
│ 命令模式 │ @SentinelResource注解 │
│ 熔断策略 │ 慢调用比例、异常比例、异常数 │
│ 生效时机 │ 请求被拦截时 │
│ 规则配置 │ 硬编码 / 文件 / Nacos动态推送 │
│ Dashboard │ 控制台 + 规则动态管理 │
│ 社区状态 │ 阿里的商业支持，更新活跃 │
└──────────────────────┴──────────────────────────────────────────────┘
结论：Sentinel功能更全面、性能更好，推荐使用！
4.2 Sentinel核心配置
// Sentinel配置
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
// 方式1：配置文件配置
System.setProperty("csp.sentinel.dashboard.server", "localhost:8080");
System.setProperty("csp.sentinel.api.port", "8719");
SpringApplication.run(OrderApplication.class, args);
}
}
// application.yml
spring:
cloud:
sentinel:
enabled: true
transport:
dashboard: localhost:8080 # Sentinel Dashboard地址
port: 8719 # 通信端口
datasource:
ds:
nacos:
server-addr: localhost:8848
dataId: ${spring.application.name}-sentinel
groupId: SENTINEL_GROUP
data-type: json
rule-type: flow
4.3 Sentinel注解使用
// 定义资源（可以是接口、方法和异常）
@RestController
public class OrderController {
@Autowired
private OrderService orderService;
@GetMapping("/order/{id}")
@SentinelResource(
value = "getOrder", // 资源名
blockHandler = "getOrderBlockHandler", // 限流/熔断处理
fallback = "getOrderFallback", // 降级处理
exceptionsToIgnore = {BusinessException.class} // 忽略的异常
)
public Result<Order> getOrder(@PathVariable Long id) {
return Result.success(orderService.getById(id));
}
// BlockHandler：限流/熔断触发时调用（必须public，返回值必须和原方法一致）
public Result<Order> getOrderBlockHandler(Long id, BlockException e) {
log.warn("请求被限流：{}", e.getClass().getSimpleName());
return Result.fail("系统繁忙，请稍后重试");
}
// Fallback：业务异常或降级时调用
public Result<Order> getOrderFallback(Long id, Throwable e) {
log.warn("降级处理：{}", e.getMessage());
// 可以返回兜底数据
return Result.success(new Order().setId(id).setStatus("兜底数据"));
}
}
// 热点参数限流
@GetMapping("/order/detail")
@SentinelResource("orderDetail")
public Result<OrderDetail> orderDetail(
@RequestParam Long orderId,
@RequestParam(required = false) Long userId
) {
// 热点参数：orderId是热点参数，针对不同的orderId单独限流
return Result.success(orderService.getDetail(orderId, userId));
}
// 热点规则配置
@Configuration
public class SentinelConfig {
@PostConstruct
public void init() {
// 热点参数规则：orderId参数，索引0，每秒每个orderId最多10个请求
List<ParamFlowRule> rules = new ArrayList<>();
ParamFlowRule rule = new ParamFlowRule("orderDetail")
.setParamIdx(0)
.setCount(10)
.setDurationInSec(1);
rules.add(rule);
ParamFlowRuleManager.loadRules(rules);
}
}
// 系统自适应限流
@Configuration
public class SystemRuleConfig {
@PostConstruct
public void init() {
List<SystemRule> rules = new ArrayList<>();
SystemRule rule = new SystemRule()
.setHighestCpuUsage(0.8) // CPU使用率80%时触发
.setHighestSystemLoad(10.0) // 系统负载10时触发
.setAvgRt(1000) // 平均响应时间1秒时触发
.setQps(5000); // QPS 5000时触发
rules.add(rule);
SystemRuleManager.loadRules(rules);
}
}
4.4 熔断器状态机
┌─────────────────────────────────────────────────────────────────────┐
│ Sentinel熔断状态机 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 熔断关闭 熔断开启 │
│ (CLOSED) ──────────→ (OPEN) │
│ ↑ │ │
│ │ │ (达到熔断时间) │
│ │ ↓ │
│ │ ┌─────────────┐ │
│ │ │ 半开状态 │ │
│ │ │ (HALF_OPEN)│ │
│ │ └─────────────┘ │
│ │ │ │
│ │ ┌─────────┴─────────┐ │
│ │ ↓ ↓ │
│ │ 失败率仍然高 成功率高 │
│ │ │ │ │
│ └─────────┴───────────────────┘ │
│ │
│ 熔断策略： │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ 1. 慢调用比例：响应时间 > RT(秒) 的调用视为慢调用 │ │
│ │ 当慢调用比例 >= 比例阈值，开启熔断 │ │
│ │ │ │
│ │ 2. 异常比例：请求异常数 / 总请求数 >= 比例阈值 │ │
│ │ 当异常比例 >= 比例阈值，开启熔断 │ │
│ │ │ │
│ │ 3. 异常数：请求异常数 >= 异常数阈值 │ │
│ │ 当异常数 >= 阈值，开启熔断 │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
五、配置中心：Nacos Config
5.1 配置管理架构
┌─────────────────────────────────────────────────────────────────────┐
│ Nacos配置中心架构 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │User服务 │ │Order服务 │ │Pay服务 │ │
│ │dev环境 │ │dev环境 │ │dev环境 │ │
│ └────┬────┘ └────┬────┘ └────┬────┘ │
│ │ │ │ │
│ └──────────────┴──────────────┘ │
│ ↓ │
│ ┌──────────────────────┐ │
│ │ Nacos Server │ │
│ │ │ │
│ │ user-service.yaml │ ← Data ID │
│ │ order-service.yaml │ │
│ │ pay-service.yaml │ │
│ │ │ │
│ │ shared.yaml │ ← 共享配置 │
│ └──────────────────────┘ │
│ │
│ 配置命名空间：dev / test / prod │
│ 配置分组：DEFAULT_GROUP / SYSTEM_GROUP │
│ │
└─────────────────────────────────────────────────────────────────────┘
5.2 配置共享与动态刷新
# 主配置文件
spring:
application:
name: user-service
cloud:
nacos:
config:
server-addr: 127.0.0.1:8848
file-extension: yaml
namespace: dev
group: DEFAULT_GROUP
# 共享配置（所有服务共享）
shared-configs:
- data-id: common.yaml
group: SHARED_GROUP
refresh: true # 动态刷新
- data-id: datasource.yaml
group: SHARED_GROUP
refresh: true
# 扩展配置（可选）
extension-configs:
- data-id: ${spring.application.name}-ext.yaml
group: EXT_GROUP
refresh: true
// 方式1：@Value注解（局部配置）
@RestController
@RefreshScope // 启用配置刷新
public class UserController {
@Value("${user.max-count:100}")
private int maxCount;
@GetMapping("/user/count")
public int getMaxCount() {
return maxCount; // 配置变更后会自动刷新
}
}
// 方式2：@ConfigurationProperties（推荐）
@Data
@Component
@ConfigurationProperties(prefix = "user")
@RefreshScope
public class UserProperties {
private int maxCount = 100;
private int timeout = 5000;
private List<String> allowedOrigins;
}
// 方式3：@NacosConfigurationProperties（直接监听）
@Data
@Component
@NacosConfigurationProperties(prefix = "user", autoRefreshed = true)
public class UserProperties {
private int maxCount;
}
六、分布式事务：Seata
6.1 Seata事务模式对比
┌─────────────────────────────────────────────────────────────────────┐
│ Seata事务模式对比 │
├──────────────────────┬──────────────────────────────────────────────┤
│ AT模式 │ XA模式 │
├──────────────────────┼──────────────────────────────────────────────┤
│ 无需改造业务代码 │ 需要修改数据库连接为XA模式 │
│ 自动生成反向SQL │ 手动编写业务逻辑 │
│ 性能损耗低 │ 性能损耗较高（两阶段提交） │
│ 适合短事务 │ 适合长事务、强一致性场景 │
│ MySQL 5.7.11+ │ 支持XA的数据库 │
├──────────────────────┼──────────────────────────────────────────────┤
│ TCC模式 │ Saga模式 │
├──────────────────────┼──────────────────────────────────────────────┤
│ 手动编写Try/Confirm │ 编排式补偿，自动生成补偿 │
│ 性能最高 │ 适合长流程业务 │
│ 需要实现三个接口 │ 不保证隔离性 │
│ 适合并发控制场景 │ 适合状态机流转场景 │
└──────────────────────┴──────────────────────────────────────────────┘
推荐：先AT模式，复杂场景用TCC
6.2 AT模式实战
// 1. 添加依赖
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
<dependency>
<groupId>io.seata</groupId>
<artifactId>seata-spring-boot-starter</artifactId>
</dependency>
// 2. 配置
seata:
tx-service-group: my-service-group
service:
vgroup-mapping:
my-service-group: default
enable-degrade: false
registry:
type: nacos
nacos:
server-addr: 127.0.0.1:8848
config:
type: nacos
nacos:
server-addr: 127.0.0.1:8848
// 3. 业务代码（AT模式无感知，无需额外注解）
@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private AccountFeignClient accountFeignClient;
@Override
public void createOrder(OrderDTO orderDTO) {
// 1. 创建订单
Order order = new Order();
order.setUserId(orderDTO.getUserId());
order.setAmount(orderDTO.getAmount());
order.setStatus("PENDING");
orderMapper.insert(order);
// 2. 扣减余额（远程调用）
accountFeignClient.deduct(orderDTO.getUserId(), orderDTO.getAmount());
// 3. 更新订单状态
order.setStatus("COMPLETED");
orderMapper.updateById(order);
// 以上操作在一个全局事务中，任何一步失败都会回滚
}
}
七、常见面试题
Q1：Nacos和Eureka的区别？
┌─────────────────────────────────────────────────────────────────────┐
│ Nacos vs Eureka 对比 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 1. CAP定理 │
│ - Eureka：AP（优先可用性，允许短暂的数据不一致） │
│ - Nacos：同时支持AP和CP（可切换） │
│ │
│ 2. 功能 │
│ - Eureka：只支持服务注册/发现 │
│ - Nacos：服务注册/发现 + 配置管理 + 动态配置推送 │
│ │
│ 3. 配置管理 │
│ - Eureka：不支持 │
│ - Nacos：内置配置中心，支持配置变更推送 │
│ │
│ 4. 协议支持 │
│ - Eureka：只支持HTTP │
│ - Nacos：HTTP + gRPC │
│ │
│ 5. 活跃度 │
│ - Eureka 2.x已停更 │
│ - Nacos 阿里背书，持续更新 │
│ │
│ 结论：优先选择Nacos │
│ │
└─────────────────────────────────────────────────────────────────────┘
Q2：Gateway和Zuul的区别？
1. 架构：
- Zuul 1.x：同步阻塞模式，每个请求一个线程
- Gateway：基于WebFlux（响应式编程）+ Netty，非阻塞
2. 性能：
- Gateway性能是Zuul的2-3倍
3. 过滤机制：
- Zuul：Filter（4种类型）
- Gateway：GatewayFilter + GlobalFilter，更灵活
4. 限流：
- Zuul：需要借助Bucket4j等第三方
- Gateway：内置RequestRateLimiter
5. 结论：使用Spring Cloud Gateway
Q3：Sentinel的滑动窗口算法原理？
Sentinel使用滑动窗口来统计接口的QPS、响应时间等指标：
┌─────────────────────────────────────────────────────────────────────┐
│ 滑动窗口统计原理 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 当前时间：11:00:05 │
│ │
│ 窗口大小：1秒 │
│ 窗口数量：2个（统计最近2秒） │
│ │
│ ┌──────────────────┬──────────────────┐ │
│ │ 窗口1 │ 窗口2 │ │
│ │ 11:00:04 │ 11:00:05 │ │
│ │ 请求数:150 │ 请求数:80 │ │
│ │ 慢调用:10 │ 慢调用:5 │ │
│ │ 异常:3 │ 异常:1 │ │
│ └──────────────────┴──────────────────┘ │
│ │
│ 统计结果： │
│ - 总请求数 = 150 + 80 = 230 │
│ - 慢调用比例 = (10 + 5) / 230 = 6.5% │
│ - 异常比例 = (3 + 1) / 230 = 1.7% │
│ │
│ 特点：每500ms滑动一次，每次统计最近2个完整窗口 │
│ │
└─────────────────────────────────────────────────────────────────────┘
八、总结
┌─────────────────────────────────────────────────────────────────────┐
│ Spring Cloud知识地图 │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ 服务注册与发现 ───→ Nacos/Eureka │
│ ↓ │
│ 配置中心 ────────→ Nacos Config │
│ ↓ │
│ 网关 ───────────→ Spring Cloud Gateway │
│ ↓ │
│ 负载均衡 ───────→ Ribbon / LoadBalancer │
│ ↓ │
│ 服务调用 ───────→ OpenFeign │
│ ↓ │
│ 熔断降级 ───────→ Sentinel / Resilience4j │
│ ↓ │
│ 分布式事务 ─────→ Seata (AT/TCC/XA/Saga) │
│ │
│ 选型建议： │
│ 注册中心：Nacos（功能全面） │
│ 配置中心：Nacos Config（统一管理） │
│ 网关：Spring Cloud Gateway（性能好） │
│ 熔断：Sentinel（阿里背书，功能强） │
│ 分布式事务：Seata（对业务零侵入） │
│ │
└─────────────────────────────────────────────────────────────────────┘
🎯 讨论话题
大家在微服务改造中遇到过哪些坑？是怎么解决的？
往期热门文章推荐：
如果这篇文章对你有帮助，欢迎点赞、收藏、转发！我们下期再见！ 👋
