微服务入门:边界、代价与演进路径
本篇要点:读完能对着自己项目的数字判断"该不该拆",并说清拆分会新增哪几类成本。前置要求:你独立写过至少一个能上线的单体应用,知道一次发布要走哪些环节。
为什么需要它
2026 年 4 月,一支 31 人的团队把 41 万行的订单系统拆成了 11 个服务。拆之前他们有三个具体痛点:全量编译 14 分 20 秒,发布窗口每周只有两个凌晨,一个完全无关的模块改动也能让整次发布回滚。拆完编译降到 90 秒,每人只编自己那个服务。
六个月后复盘是另一组数字:需求从提出到上线的中位时间从 9 天变成 14 天,生产事故从每月 1.2 起变成 3.5 起,其中 7 起是跨服务调用超时级联,新人能独立改代码的时间从 2 周变成 5 周。两组数字都是真的,前一组在立项材料里算过,后一组没人算。
所以"微服务好不好"是个错问题。真正的问题是:你现在的痛点是拆分能解决的,还是拆分反而会放大的。编译慢、发布排队、模块互相阻塞,这三样拆分确实能解;如果团队只有 6 个人、需求每周还在变、监控都没接,拆完只会让同样的问题乘以 11。
核心概念
概念一:微服务换到了什么,又付出了什么
微服务(microservice)是一种把应用拆成多个可独立部署单元(deployable unit)的架构风格:每个单元围绕一项业务能力(business capability)构建,拥有自己的数据存储,通过进程间通信(inter-process communication,IPC)协作。
换来四样。独立部署(independent deployability):改通知模板不必重发订单服务,影响半径从"整个应用"缩到一个服务。独立扩缩:秒杀链路要 40 个实例,后台对账只要 2 个。故障隔离(fault isolation):报表服务吃满内存,下单不受影响。第四样是技术异构——多数公司在这条上是负收益,它把"技能互补"变成"值班要会三门语言",除非有明确理由,别算进收益。
代价也有四样,比收益更难量化,所以常被跳过。网络从"不会失败"变成"一定会失败":本地调用以纳秒计,跨可用区一次远程过程调用(Remote Procedure Call,RPC)的 P99 以毫秒计,失败模式有十几种——连接被拒、读超时、半开连接、响应丢了但服务端其实执行成功。一致性从本地事务变成最终一致(eventual consistency):一行 @Transactional 解决的扣库存加写订单,拆开后要么 Saga,要么本地消息表加对账,两者都要业务方接受"中间状态可见"。可观测性从日志变成追链路:一次请求跨 6 个服务,没有统一 traceId 就定位不了报错。运维面积做乘法:11 个服务 × 3 套环境 × 3 个实例 = 99 个进程,每个都要健康检查、配置、日志采集和告警。
一个类比:单体是一个厨房一个厨师,微服务是中央厨房加 12 个配送点。分工更细、单点出餐更快,但每次配送都可能迟到、可能送错,而顾客只投诉最后那一步。
反例:某团队拆完 11 个服务,日志仍各写本地文件。一次支付回调丢失,他们花两天靠人肉对齐 11 台机器的时间戳才定位。这不叫微服务失败,这叫把单体的调试习惯搬到了分布式环境。
概念二:康威定律解释了边界为什么长这样
康威定律(Conway's Law)是 Melvin Conway 在 1968 年的文章《How Do Committees Invent?》里提出的:设计系统的组织,其产出的设计结构必然复制该组织的沟通结构。更直白的版本:4 个团队维护的系统,会长出 4 的倍数个模块边界,位置跟汇报线重合。
原因不神秘。跨团队沟通成本远高于团队内,工程师会不自觉地用代码降低耦合——接口做粗一点、依赖往后推一点。这些"为了少开会"的决定累积起来就是架构。你没有设计它,它自己长出来了。
由此有一条操作性推论,逆康威操作(Inverse Conway Maneuver):想让系统变成什么形状,先让组织变成那个形状。想要 3 个能独立发布的服务,先有 3 个能对发布负责的团队;组织不动就拆 11 个服务,得到的是 11 个服务、4 个团队、4 条跨团队发布链。
反例:一个 12 人的团队负责 5 个服务,5 个仓库的 CI 串在一条流水线上,每次发布要同一个人点确认。边界画得漂亮,发布半径还是整个系统。
概念三:分布式单体的四个信号
分布式单体(distributed monolith)指进程已经拆开,但部署、数据、调用关系仍然绑在一起,于是既丢了单体的简单,也没拿到微服务的独立。判断不用开会,数四个东西。
| 信号 | 观测方法 | 出现即说明 |
|---|---|---|
| 共享数据库 | 两个服务连同一实例、同一批表 | 表结构变更要两个团队同时上线 |
| 锁步发布 | 一次发布要动几个仓库 | 改一个接口必须同一天全量上线 |
| 同步调用链 | 单次请求串行跨几个服务 | 任一跳 P99 抖动都会被累加 |
| 共享领域模型库 | 是否依赖同一个 xxx-domain.jar | 改一个字段两边都要重编译 |
第一项最隐蔽:两个服务各有 repository 层、看着干净,但底层连同一个库,order 表被库存服务直接 JOIN。这只是把单体切成两半,数据层还是同一个。第三项要配数字看:链路串行跨 5 个服务、每个 P99 是 20 毫秒,整条链路就是 100 毫秒起——超时和抖动会叠加,不会平均。第四项的动机是"避免重复定义",代价是它成了所有服务的隐式发布耦合点。
概念四:三种形态,选择标准是团队和运维能力
单体(monolith):一个代码库、一个部署单元、一个数据库。好处被低估——进程内调用不会失败,本地事务天然强一致,发布只有一个版本号要追。
模块化单体(modular monolith):仍是单个部署单元,但内部按业务模块划出强边界,模块间只能通过公开接口调用,边界由构建期规则(ArchUnit)或框架(Spring Modulith,截至 2026 年 11 月为 2.0.x 线)强制检查。关键不在怎么分包,而在边界是否被机器强制:只有 package 命名约定、谁都能 import 对方内部类的项目不是模块化单体,只是命名整齐的单体。
三种形态看五个条件,不看业务复杂度:
| 维度 | 单体 | 模块化单体 | 微服务 |
|---|---|---|---|
| 团队规模 | 1–2 个团队 | 2–4 个团队共享一个库 | 每服务有独立负责团队 |
| 发布节奏 | 每周一到两次够用 | 需要按模块差异化发布 | 各服务发布频率差 3 倍以上 |
| 独立扩缩 | 无差异化需求 | 个别模块需要单独扩容 | 多条链路容量差异大 |
| 运维人力 | 无专职运维 | 有 1 名兼职 SRE | 每 5–8 个服务配 1 名 SRE |
| 一致性要求 | 强一致为主 | 强一致为主 | 能接受最终一致 |
这张表从左往右读:任何一行不满足就停在上一列。只有"团队独立"和"运维人力"同时满足,微服务才转得动;其余三行缺了只是收益变小,缺了这两行直接翻车。选择路径如图 1-1 所示。
图 1-1 单体到微服务的三条演进路径
图 1-1 里最容易被跳过的是节点 D,它问的是团队而不是技术。绝大多数拆分做不下去,不是方案不对,而是拆出来的服务没有明确归属。前面那套系统 23 个模块打分后,达到拆分标准的只有 3 个;多数团队的正确终点是模块化单体加 2 到 4 个需要独立的服务。
动手实践
步骤 1:量一下模块之间的发布耦合
先别急着设计边界,先看代码实际怎么被改。取近 90 天合入主干的提交,统计同一次提交里一起被改的文件对。
git log --since="90 days ago" --name-only --pretty=format:'---%H' \
| awk '/^---/{if(n>1)for(i=1;i<=n;i++)for(j=i+1;j<=n;j++)print (a[i]<a[j]?a[i]" "a[j]:a[j]" "a[i]); delete a; n=0; next} NF{a[++n]=$0}' \
| sort | uniq -c | sort -rn | head -8预期输出形如(数值取自本篇开头那套系统,已脱敏):
47 order/service/OrderService.java order/service/OrderStatusMachine.java
39 order/repo/OrderRepository.java inventory/repo/StockRepository.java
31 settlement/service/BillService.java order/service/OrderService.java
12 order/service/OrderService.java user/service/UserService.java第一行说明订单与状态机是一体的。第二行是关键:订单仓储和库存仓储在 39 次提交里一起被改,它们分属两个域,却共享同一段扣减逻辑。直接按业务域拆,就会把逻辑切成两半,凭空造出一个跨服务事务。
步骤 2:给模块边界装一道构建期闸门
决定"先不拆"的模块也要治理,否则半年后边界会自然烂掉。用 ArchUnit 把依赖规则写成测试,违反就构建失败。
@AnalyzeClasses(packages = "com.example.order")
class ModuleBoundaryTest {
@ArchTest
static final ArchRule 订单模块不得直接访问他域仓储 =
noClasses().that().resideInAPackage("..order..")
.should().dependOnClassesThat()
.resideInAnyPackage("..inventory.repo..", "..settlement.repo..");
@ArchTest
static final ArchRule 模块间只能通过 api 包调用 =
classes().that().resideInAPackage("..order.internal..")
.should().onlyBeAccessed().byAnyPackage("..order..");
}运行结果(存量项目首次执行,会一次性暴露所有历史违规):
ModuleBoundaryTest > 订单模块不得直接访问他域仓储 FAILED
Architecture Violation [Priority: MEDIUM] - Rule '...' was violated (41 times):
Method <com.example.order.service.OrderService.reserve(...)> calls method
<com.example.inventory.repo.StockRepository.lock(...)> in (OrderService.java:213)
...
41 violations41 处违规不要一次修完。建白名单冻结住,CI 校验条数只减不增。这让"暂时不拆"有了收敛路径:白名单降到 0 时再复评。
步骤 3:把拆分的年化成本算成数字
立项材料通常只写收益。补上成本那一半,谈判才有依据。
services = 3
instances_per_service = 3
cost_per_instance_month = 350 # 4C8G 按量约 350 元/月
sre_ratio = 0.6 # 1 名 SRE 分摊 60% 工时
sre_year = 350000
trace_gb_per_day = 40
trace_price_per_gb = 1.9
resource = services * instances_per_service * cost_per_instance_month * 12
people = sre_year * sre_ratio
observe = trace_gb_per_day * 365 * trace_price_per_gb
total = resource + people + observe
print(f"资源 {resource/10000:.1f} 万 / 人力 {people/10000:.1f} 万 / 可观测 {observe/10000:.1f} 万")
print(f"年化新增 {total/10000:.1f} 万元")预期输出:
资源 3.8 万 / 人力 21.0 万 / 可观测 2.8 万
年化新增 27.6 万元这个量级值得记住:3 个服务的年化新增成本在 25 万到 45 万,人力占七成。真正要付的不是服务器,是你必须多养的那部分运维和协调人力。
常见误解
误解一:微服务能提升开发速度。它缩短的是"单次改动的影响范围",不是"完成时间"。第一次更快,因为不用理解整个代码库;从第三个月起,联调、契约对齐、环境准备的固定开销会稳定吃掉一部分时间。交付时间从 9 天变 14 天就是这张账单。
误解二:先把服务拆开,团队自然会跟着调整。顺序反了。组织调整有阻力、要动汇报线,通常比技术改造慢一个季度以上。先定团队归属和发布责任,再按团队边界拆服务;反过来做,拆出来的服务长期没人认领。
误解三:模块化单体只是过渡态,早晚要拆。它可以就是终点。一家 40 人的公司维护一套模块化单体,边界由 ArchUnit 守着,一周发布两次,这套配置能撑很多年,运维成本只有微服务的三分之一。
小结
- 微服务换四样:独立部署、独立扩缩、故障隔离、技术异构;付四样代价:网络不可靠、最终一致、分布式追踪、运维面积乘法。
- 系统结构镜像沟通结构。逆康威操作是先改组织再改架构,反过来会得到分布式单体。
- 分布式单体看四个信号:共享数据库、锁步发布、同步调用链、共享领域模型库,都可以数出来。
- 三形态看团队规模和运维人力两条硬条件,其余是加速条件。多数团队的正确终点是模块化单体加 2 到 4 个服务。
- "先不拆"也要治理:构建期规则冻结现有违规,白名单只减不增,边界才有收敛路径。
相关主题
这一章停在"该不该拆"。下一步具体得多:线该画在哪里。《服务拆分:领域边界与数据归属》讲领域边界与数据归属,核心不是画一张漂亮的上下文图,而是回答两个会被追问的问题——这张表归谁,跨两个域的那次查询谁来承担代价。