知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 50 - 微服务拆分原则与实践 > 导读:本文用一问一答的方式,讲清微服务"为什么拆、按什么边界拆、拆多细、拆完怎么通信和保证一致性"。读完你能独立回答服务拆分类系统设计题,并说清数据边界与分布式事务中的核心取舍。适合准备系统设计面试的后端工程师。 ## 一、先建立全局认知 ### Q:单体应用遇到了什么问题,为什么考虑拆微服务? A:结论——**单体应用的核心矛盾是"整个系统只有一条发布链路、一个数据库、一套技术栈",规模越大,任何一个局部改动都要为全局买单。** 一个典型场景:电商系统是单体应用,代码量 50 万行,20 个开发同时在一个仓库里改代码,问题越来越严重: ``` 1. 编译慢:改一行代码,编译打包 10 分钟 2. 发布怕:改了用户模块,要把整个系统重新部署,影响订单、支付等模块 3. 扩展难:大促时只有订单模块需要扩容,但只能整体扩容,浪费资源 4. 耦合深:用户模块改了个字段,订单模块编译不过了 5. 技术栈绑定:所有模块必须用同一个框架版本 ``` 这五条本质上是同一件事的五个侧面:**模块之间缺少边界,导致"局部"和"整体"被迫绑定。** 所以决定拆分微服务,但马上会引出三个必须回答的问题:怎么拆、拆多细、拆完怎么通信? ### Q:微服务拆分有哪几条核心原则? A:三条,按重要性排序: 1. **按业务域拆分(DDD 限界上下文)**:一个服务对应一个业务域,边界跟着业务走,而不是跟着技术分层走。 2. **粒度适中**:一个服务由 2~3 人的小团队负责(Two Pizza Team)。太粗失去微服务优势,太细分布式复杂度爆炸。 3. **数据私有**:每个服务拥有自己的数据库,禁止跨服务直接访问数据库。 其中第 3 条最难,也最容易在实施时被破坏(下节详解)。**判断拆分是否成功的一条标准是:如果两个服务的数据还需要频繁跨库 JOIN,那说明它们的边界划错了。** ## 二、理解核心机制 ### Q:怎么确定拆分的边界?按业务域拆分具体怎么落地? A:方法是先梳理业务域,让每个域内高内聚、域间低耦合。电商系统的核心业务域可以这样划分:  *图:电商七大核心业务域及其包含的能力* ``` 电商系统的核心业务域: ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ 用户域 │ │ 商品域 │ │ 订单域 │ │ 支付域 │ │ │ │ │ │ │ │ │ │ - 注册 │ │ - 商品管理│ │ - 下单 │ │ - 支付 │ │ - 登录 │ │ - 分类 │ │ - 购物车 │ │ - 退款 │ │ - 用户信息│ │ - 库存 │ │ - 订单查询│ │ - 对账 │ │ - 地址 │ │ - 价格 │ │ - 售后 │ │ │ └─────────┘ └─────────┘ └─────────┘ └─────────┘ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ 营销域 │ │ 物流域 │ │ 风控域 │ │ │ │ │ │ │ │ - 优惠券 │ │ - 发货 │ │ - 风险评估│ │ - 活动 │ │ - 物流跟踪│ │ - 反欺诈 │ │ - 积分 │ │ - 签收 │ │ │ └─────────┘ └─────────┘ └─────────┘ ```  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/50-microservice-split-microservice-split-domain-boundaries-diagram.excalidraw) **限界上下文(Bounded Context)** 是 DDD(领域驱动设计)里的概念,指"一个业务概念的边界,在边界内术语含义一致"。用业务语言说:用户域管"谁",商品域管"卖什么",订单域管"买了什么",支付域管"钱怎么走",营销域管"优惠怎么给"。**这样划分的好处是,每个域内部的变更通常不会外溢到其他域;坏处是拆出来的服务数不一定等于团队数,需要和粒度原则配合调整。** ### Q:拆多细才合适?太粗和太细分别有什么代价? A:判断"该不该拆"可以从五个信号入手: | 信号 | 该拆 | 不该拆 | |------|------|--------| | 团队规模 | 一个服务 > 3 人维护 | 一个服务只有 1 人维护 | | 变更频率 | 模块变更频率差异大 | 模块总是一起变更 | | 扩展需求 | 不同模块需要不同的扩展策略 | 所有模块负载均匀 | | 数据耦合 | 模块间数据交互少 | 模块间频繁 JOIN 查询 | | 技术异构 | 不同模块适合不同技术栈 | 技术栈统一 | ``` 拆分粒度的黄金法则: - 太粗:失去微服务的优势(独立部署、独立扩展) - 太细:分布式复杂度爆炸(网络调用、分布式事务、运维成本) - 合适:一个服务由 2~3 个人的小团队负责(Two Pizza Team) ``` **核心取舍:** 拆得越细,独立部署/独立扩展/技术异构的收益越大;但每一次跨服务调用都变成了网络调用,带来延迟、失败处理、分布式事务、链路追踪等一堆新问题。所以"太细"不是"更微服务",而是"把复杂度从代码搬到了运维"。大多数团队的合理起点是**先拆最粗的业务域(用户/商品/订单/支付),而不是一上来就按实体拆**。 ### Q:服务拆开后,数据边界怎么划? A:**原则是每个服务拥有自己的数据库,禁止跨服务直接访问数据库。** 这是微服务独立性最本质的要求——如果订单服务还直接查用户库,那"用户服务独立部署"就是假的:  *图:订单服务直连用户库 vs 经用户服务 API 调用* ``` 错误做法: 订单服务 ──直接查──→ 用户数据库(耦合!用户表改了字段,订单服务就挂了) 正确做法: 订单服务 ──API 调用──→ 用户服务 ──→ 用户数据库 ``` 正确做法落到代码上,就是通过接口(Feign)向数据属主服务要数据: ```java // 订单服务需要用户信息时,通过 Feign 调用用户服务 @FeignClient(name = "user-service") public interface UserClient { @GetMapping("/api/internal/user/{userId}") UserDTO getUserById(@PathVariable Long userId); } @Service public class OrderService { @Autowired private UserClient userClient; public OrderVO getOrderDetail(Long orderId) { Order order = orderMapper.selectById(orderId); // 通过 API 获取用户信息,而不是直接查用户表 UserDTO user = userClient.getUserById(order.getUserId()); return OrderVO.from(order, user); } } ``` **代价要讲清:** 跨库直查换成了 API 调用,性能上必然更慢、还可能失败。所以下面还有一条补偿原则——适度冗余。 ### Q:既然跨库访问不行,那为什么又允许"数据冗余"? A:因为**数据私有解决的是"写"的边界,冗余解决的是"读"的性能。** 对于下单这个高频场景,如果每次查询订单详情都要跨服务调用户服务、商品服务,延迟和失败率都会叠加。做法是:在下单那一刻把用到的字段以"快照"形式冗余到订单表里,此后订单展示就不需要再跨服务: ```java // 订单表中冗余用户名和商品名,避免频繁跨服务查询 // 这些字段在下单时写入,后续不会变(快照) CREATE TABLE orders ( id BIGINT PRIMARY KEY, user_id BIGINT NOT NULL, user_name VARCHAR(64), -- 冗余:下单时的用户名 product_id BIGINT NOT NULL, product_name VARCHAR(128), -- 冗余:下单时的商品名 product_price DECIMAL(10,2), -- 冗余:下单时的价格(快照) ... ); ```  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/50-microservice-split-microservice-split-data-ownership-diagram.excalidraw) **关键区分:** 这里冗余的是"下单时刻的快照",不是"会持续变化的当前值"。下单时的用户名、商品名、价格本来就该被定格——即使用户后来改了昵称、商品调了价,这笔订单也应该显示当时的数据。所以这份冗余既是性能优化,也是业务正确性的要求(订单要留痕)。**反过来说,如果需要的是"实时值"(比如用户当前余额),就不能靠冗余,只能老老实实查数据属主。** ### Q:服务之间怎么通信?什么时候用同步、什么时候用异步? A:判断标准只有一条:**主流程是否必须立即拿到结果。** 需要实时结果的用同步通信(HTTP / gRPC)。比如下单时要实时查询并扣减库存: ```java // 场景:下单时需要实时查询库存 // 用 Feign(HTTP)或 gRPC // Feign 示例 @FeignClient(name = "inventory-service", fallback = InventoryFallback.class) public interface InventoryClient { @PostMapping("/api/internal/inventory/deduct") Result<Boolean> deductStock(@RequestBody DeductRequest request); } // gRPC 示例(性能更好,适合内部高频调用) // 定义 proto 文件 // service InventoryService { // rpc DeductStock(DeductRequest) returns (DeductResponse); // } ``` 不影响主流程的用异步通信(消息队列):下单成功后通知营销服务加积分、通知物流服务准备发货,这些都是"可以不实时完成"的动作: ```java // 场景:下单成功后通知营销服务加积分、通知物流服务准备发货 // 不需要实时响应,用 MQ 解耦 @Service public class OrderService { public Order createOrder(OrderDTO dto) { // 1. 创建订单(同步) Order order = doCreateOrder(dto); // 2. 发消息通知其他服务(异步) mqProducer.send("order-created", new OrderCreatedEvent( order.getId(), order.getUserId(), order.getAmount())); return order; } } // 营销服务消费消息 @Component public class PointConsumer { @RocketMQMessageListener(topic = "order-created", consumerGroup = "point-group") public void onOrderCreated(OrderCreatedEvent event) { pointService.addPoints(event.getUserId(), event.getAmount()); } } // 物流服务消费消息 @Component public class LogisticsConsumer { @RocketMQMessageListener(topic = "order-created", consumerGroup = "logistics-group") public void onOrderCreated(OrderCreatedEvent event) { logisticsService.prepareShipment(event.getOrderId()); } } ``` 选择依据可以总结成一张表: | 场景 | 方式 | 原因 | |------|------|------| | 下单扣库存 | 同步(Feign/gRPC) | 需要实时结果 | | 下单后加积分 | 异步(MQ) | 不影响下单主流程 | | 下单后发通知 | 异步(MQ) | 不影响下单主流程 | | 查询订单详情(含用户信息) | 同步 + 数据冗余 | 高频查询用冗余,低频用 API |  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/50-microservice-split-microservice-split-communication-patterns-diagram.excalidraw) **取舍:** gRPC 相比 HTTP 在内部高频调用场景下性能更好(二进制协议、连接复用),代价是接口定义要走 proto 编译、调试不如 REST 直观。异步 MQ 解耦彻底、抗峰值,代价是引入最终一致性问题——消息可能重复、可能乱序,消费端必须做幂等。 ### Q:拆开之后,原本一个本地事务就能搞定的操作怎么办?(分布式事务) A:典型场景:下单 = 创建订单 + 扣减库存 + 扣减优惠券,三个操作落在三个服务里,没法用一个数据库事务包住。有两条路线: **方案一:本地消息表(最终一致性,推荐)。** 思路是把"要发的消息"和"业务数据"写在同一个本地事务里,再由定时任务可靠地把消息投递出去: ```java // 场景:下单 = 创建订单 + 扣减库存 + 扣减优惠券 // 三个操作在三个服务中,如何保证一致性? // 方案一:本地消息表(最终一致性,推荐) @Service public class OrderService { @Transactional public Order createOrder(OrderDTO dto) { // 1. 创建订单 Order order = doCreateOrder(dto); // 2. 写本地消息表(和订单在同一个事务) localMessageMapper.insert(new LocalMessage( "DEDUCT_STOCK", JSON.toJSONString(new DeductStockMsg(order)))); localMessageMapper.insert(new LocalMessage( "USE_COUPON", JSON.toJSONString(new UseCouponMsg(order)))); return order; } // 定时任务扫描本地消息表,发送到 MQ @Scheduled(fixedRate = 5000) public void sendPendingMessages() { List<LocalMessage> messages = localMessageMapper.selectPending(); for (LocalMessage msg : messages) { try { mqProducer.send(msg.getTopic(), msg.getBody()); localMessageMapper.updateStatus(msg.getId(), "SENT"); } catch (Exception e) { // 发送失败,下次重试 } } } } ``` **为什么这样能保证可靠?** 因为"订单落库"和"消息落库"在同一事务里,要么都成功要么都失败——不会出现"订单建了但消息丢了"。剩下的投递环节交给"定时扫描 + 失败重试",最多是延迟,不会丢失。代价是**最终一致**:下游可能延迟几秒才收到,且需要消费端幂等来应对重复投递。 **方案二:Seata AT 模式(强一致性)。** 用一个全局事务注解把跨服务调用包起来,任何一步失败就整体回滚: ```java // 方案二:Seata AT 模式(强一致性) @GlobalTransactional public Order createOrder(OrderDTO dto) { Order order = orderService.create(dto); // 订单服务 inventoryClient.deductStock(dto.getProductId()); // 库存服务 couponClient.useCoupon(dto.getCouponId()); // 优惠券服务 return order; // 任何一步失败,Seata 自动回滚所有服务的数据 } ```  [编辑 Excalidraw 源图](/images/java-interview-copy/system-design/50-microservice-split-microservice-split-outbox-flow-diagram.excalidraw) **两条路线的取舍:** 强一致(Seata/TCC)实现简单、语义直观,但需要引入事务协调器,且在全局锁和两阶段提交下性能损耗明显,只适合金融等强一致场景;最终一致(本地消息表 + MQ)性能好、无全局锁,代价是业务要接受"短暂不一致"并实现幂等与对账。**通用建议是默认选最终一致。** ## 三、放进真实场景 ### Q:拆分的步骤应该怎么安排?为什么数据库最后才拆? A:推荐渐进式五步,而不是"一步到位全部拆完": ``` 第一步:梳理业务域,画出服务依赖关系图 第二步:先拆最独立的服务(如用户服务、通知服务) 第三步:建立服务间通信机制(注册中心 + Feign + MQ) 第四步:逐步拆分核心服务(订单、商品、支付) 第五步:数据库拆分(最后做,风险最大) 切忌:一步到位全部拆完。应该边拆边验证,每拆一个服务就上线观察。 ``` **为什么数据库最后拆?** 因为代码可以快速回滚,数据不行。先拆代码服务、暂时共享数据库,可以让团队先跑通通信链路;等通信机制稳定了再动数据,风险才可控。反过来先拆库,会立刻引入分布式事务、跨库查询、数据一致性等最棘手的问题,一旦出错就是数据层面的事故。 ### Q:微服务拆分后,接口调用链路变长、性能下降怎么办? A:五种手段组合使用: 1. 高频调用用 gRPC 替代 HTTP(性能提升 2~5 倍,具体倍数取决于协议与序列化方式,需结合实测确认)。 2. 适度数据冗余减少跨服务调用。 3. 引入本地缓存 + Redis 缓存。 4. 异步化非关键路径(MQ)。 5. 服务间调用加超时和熔断,避免级联故障。 **核心思路是"把同步的必需调用减到最少"。** 冗余和缓存是减少调用次数,gRPC 是降低单次调用成本,异步是把调用移出主流程,超时熔断是防止某个下游拖垮上游。这五条里,减少调用次数通常收益最大。 ### Q:拆分后如何保证数据一致性? A:**放弃强一致性,拥抱最终一致性。** 核心手段有四个: 1. 本地消息表 + MQ 保证消息可靠投递。 2. 消费端幂等保证重复消费安全。 3. 对账系统定期校验数据一致性。 4. 只有金融级场景才考虑 Seata / TCC 强一致方案。 **一句话理解:** 最终一致性不追求"任何时刻都一致",而是保证"最终会对上账",并把中间不一致的时间窗口控制到业务可接受的范围。对账系统是最后一道防线——它不阻止不一致发生,但能发现并修复它。 ## 四、总结与自测 ### Q:面试里怎么答这道题? A:分四点作答: 1. **拆分原则**:按业务域(DDD 限界上下文)拆分,一个服务对应一个业务域,2~3 人团队负责。 2. **数据边界**:每个服务独立数据库,禁止跨库直接访问;高频查询字段适度冗余。 3. **通信方式**:需要实时结果用同步(Feign / gRPC),不影响主流程用异步(MQ 解耦)。 4. **分布式事务**:优先最终一致性(本地消息表 + MQ),强一致性场景用 Seata。 ### Q:这套设计的主线可以怎么复述? A:一句话串起来——**拆分的边界跟着业务域走(DDD)、粒度取决于团队与变更频率、数据必须私有(禁跨库)、通信按"是否要实时结果"选同步或异步、一致性默认选最终一致(本地消息表 + 幂等 + 对账)。** 面试时最有分量的一句是:"微服务不是拆得越细越好,而是用可控的分布式复杂度换取独立部署与扩展的能力。" --- ## 自测 1. 单体应用的痛点可以归结为哪一类根本矛盾?拆微服务解决了它,又引入了什么新成本? 2. "限界上下文"是什么?为什么按业务域拆比按技术分层拆更合理? 3. 拆分的"黄金法则"里,拆太粗和拆太细各自的代价是什么? 4. 为什么禁止跨服务直接访问数据库?如果频繁需要跨库 JOIN,说明什么问题? 5. 数据冗余和"查实时值"的边界在哪里?为什么下单时的用户名、价格适合冗余? 6. 什么情况下用同步 Feign / gRPC,什么情况下用异步 MQ?判断依据是什么? 7. 本地消息表为什么能保证消息不丢?它的代价是什么? 8. 为什么建议数据库放在拆分步骤的最后一步?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入