一家公司的订单系统跑了六年,代码 38 万行,业务加运维一共 21 个人维护。发布窗口固定在每周二和周四的晚上,一次全量发布 45 分钟,出问题回滚再花 30 分钟。改一句下单页的提示文案,要经过三个团队的代码评审,因为那串文案被放在一个被十几处引用的公共模块里。季度复盘会上,有人把这些数字投在屏幕上,结论很一致:单体太糟了,拆。

他们花了四个月,拆出 14 个服务。订单、库存、支付、优惠券各一个,还按技术层拆了用户中心、消息中心、文件中心。第一个月大家很满意,每个服务都能单独发布。到第三个月,问题开始冒头:下单接口的 p99 从 90 毫秒涨到 320 毫秒,一次普通需求平均要动 2.6 个服务,联调排期比拆之前更长,库存服务一次超时能让整个下单页白屏。发布确实变独立了,但没人敢连着发。

这不是说拆分错了,而是拆之前没人算过账。单体的毛病和微服务的毛病不是同一类:前者是耦合,后者是分布式。这篇不劝你拆,也不劝你不拆,只把两边的成本摆到桌面上,再给一套能照着走的判断方法。

七个信号:分清单体的问题和别的问题

下面这些现象,很多团队都统称为「单体的问题」。但其中只有一部分真跟单体有关,剩下的属于发布流程、测试覆盖、团队结构,拆成微服务也不会消失,只会换个地方出现,而且往往更难查。

现象真实原因第一步查什么
改一行文案要等三个团队评审文案常量放在公共模块,十几个调用方共享同一个构建统计这次改动落在哪些模块,谁有评审权
一次发布 45 分钟,回滚 30 分钟全量构建加全量回归,没有增量发布能力量构建耗时和回归用例数,看瓶颈在构建还是在测试
一个模块内存泄漏,整台机器重启所有模块在同一个进程里,共享一个堆,故障域没有边界看进程内模块清单和内存曲线,确认是否共用堆
拆分后下单 p99 从 90 涨到 320 毫秒一次请求跨 5 个服务,每跳都有序列化、排队和重试数一次请求经过几个进程、几道网关
拆完发布更慢,没人敢发14 套流水线、14 份配置、跨服务联调统计一次改动的跨服务变更数和联调等待时间
库存服务超时,下单页整页白屏同步强依赖没有超时,也没有降级路径画出调用链,标注哪些是同步调用、超时设了多少
天天开会同步接口字段服务边界按技术层划,一个业务改动横跨多层看每个服务由几个团队共同修改、改动是否总是一起发生

七条里,前三条确实和单体有关,它们分别是构建耦合、发布耦合和故障域耦合。中间三条是拆分本身带来的新成本,严格说不是「拆分失败」,而是「拆分没配套」。最后一条最隐蔽,它说明边界划错了,拆完之后你得到的是一个由 14 个进程组成的单体,业内管它叫分布式单体。

把这三类分开之后,判断就清楚了:如果痛点集中在前三条,并且业务确实需要独立发布和独立扩容,拆分值得做;如果痛点主要在流程慢、测试少、评审链长,那属于工程效能问题,拆服务只会把一条慢流程复制成十四条。

单体的成本藏在四种耦合里

单体真正的成本不是「代码乱」。乱代码在微服务里一样乱,只是从一个大仓库散到十四个小仓库。单体贵在四种耦合,它们经常同时出现,所以人容易把四种都记成「单体的错」。

构建耦合所有模块共享一个构建产物。改一行也要重新编译全部,构建时间随代码总量增长,谁也无法只发布自己那部分。
发布耦合所有模块共享一个发布窗口。任何一个模块没准备好,所有人都得等;一次发布失败,所有模块一起回滚。
数据耦合所有表在同一个库里,模块之间直接读对方的表。改一个字段要先问一圈人,谁也不敢保证没有隐式依赖。
组织耦合所有改动共享一条评审链和一个上线审批。团队再多,也只有一条发布通道,人数增加不会带来发布次数增加。

四种里,构建耦合和发布耦合最容易量化,也最容易在不动架构的前提下改善:把构建缓存做起来,把回归测试按模块切片,把发布改成灰度加自动回滚,很多「必须拆」的理由会直接消失一半。数据耦合最难,因为它牵扯到事务边界,这部分留到本组最后一篇展开。

组织耦合最容易被忽略。21 个人维护 38 万行代码,本身不算离谱,但如果这 21 个人被分成 6 个小组,每组都要改同一个公共模块才能完成需求,那问题不在代码量,而在边界。拆服务能缓解它,但前提是拆完之后每个服务真的归一个小组负责,而不是仍然六个人一起改。

拆分真正能买到的只有三样东西

拆成微服务能带来的收益,说到底是三样,而且三样都来自同一个词:独立。

独立发布。一个服务改完就能发,不用等别人。这条收益的前提是发布流水线、配置、数据库变更都能跟着服务走。如果十四套流水线共用一个人审批,独立发布只是名义上的。

按需扩容。下单高峰只扩订单和库存,报表服务不用跟着扩。单机时代只能整机加,扩容粒度是「一台机器」;拆分之后粒度是「一个服务」,成本结构会变。但如果所有服务仍然共用一个数据库,扩容最先撞到的还是数据库,计算层的弹性会被存储层卡住。

故障隔离。一个服务崩了,不至于把整个进程带走。这条收益最容易被高估,因为隔离只在「调用方有超时和降级、依赖不是同步强依赖」时才成立。没有这两条,拆开只是把一次进程内崩溃换成一次跨进程超时,用户看到的结果一样。

还有一样东西经常被算成技术收益,其实属于组织收益:团队自治。服务边界清楚,团队可以自己决定排期和技术选型。它真实存在,但成本也真实:每个服务都要有自己的值班、监控、发布和文档,这些开销不会因为服务小而按比例缩小。

拆分的收益来自「独立」,不来自「小」。一个 3000 行的服务如果仍然和别人共库、共发布窗口、共审批链,它带来的只有跨进程开销。

跨进程一次到底贵多少:一组本机实测

讨论拆分时,最缺的往往是一个具体数字。下面是本机跑出来的一组对照:同一段逻辑,分别用进程内调用、直连服务、再过一道网关三种方式执行。

进程内调用: 200000 次, 合计 1.1ms, 单次约 0.0000ms
直连服务: 300 次, p50 15.50ms, p99 17.51ms
过网关(鉴权+转发): 300 次, p50 30.87ms, p99 34.62ms

这组数字是在本机 Windows 环境跑的环回 HTTP,含定时器精度误差,绝对数字不代表生产环境。它的价值不在绝对值,而在比例:进程内调用几乎零成本,二十万次加起来才 1.1 毫秒;同样的事情改成跨进程,一次就多出十五毫秒左右;再加一道网关做鉴权和转发,又多出十五毫秒。生产环境走真实网络、过交换机、穿容器网络插件,这个数字只会更大。

每多一跳,多出来的不只是「网络传输」。一次跨进程调用至少要付这些钱:请求和响应的序列化与反序列化,连接池的获取与归还,内核态和用户态的切换,目标服务的线程排队,网关里的鉴权查缓存,以及失败时的重试。单看每一项都不大,叠在一起就是十几毫秒。

更麻烦的是调用链是串行的,延迟按跳数相加。按上面这组实测数字做一次纯算术推演,一道网关加四个下游服务,p50 大致是这样:

网关(鉴权+转发)      p50 30.87ms
订单服务             p50 15.50ms
库存服务             p50 15.50ms
优惠券服务           p50 15.50ms
支付服务             p50 15.50ms
串行合计             p50 约 92.87ms

这还是每跳都顺利的情况。真实系统里,p99 会被最慢的那一跳拖走:某一跳偶发卡顿 200 毫秒,整条链路的 p99 就跟着变成 200 毫秒以上。这就是为什么很多系统单看每个服务的监控都正常,用户端却一直喊慢。后面讲链路追踪的那篇会专门拆这个问题。

还有一层放大效应:重试。如果每一跳失败都重试两次,一条五跳的链路在最坏情况下会产生几十次实际调用,下游被打爆,延迟继续往上滚。拆分让「重试」从进程内的一个循环,变成了跨服务的流量放大器。

边界按业务能力和数据所有权划,不按技术层划

拆分最难的一步不是把代码切开,而是决定在哪切。一个实用的起点是领域驱动设计里的「限界上下文」:一块业务里,同一批词的含义能保持一致的最小范围。下单流程里的「订单」和报表里的「订单」含义不同,它们就该属于两个上下文。

落到操作层面,有三个判据:

数据所有权。一张表只能有一个服务负责写,其他服务只能通过接口拿。这条最硬,违反它就会出现两个服务同时改一份数据,后面必然要靠分布式事务擦屁股。

变更频率。总是一起改的东西放一起,一年都不一起改的可以分开。变更频率比「业务概念像不像」更能反映真实耦合,因为它记录的是历史行为,不是设计者的想象。

团队边界。系统结构会照着组织的沟通结构长,这条规律叫康威定律。如果一个服务需要三个团队共同维护,它迟早会变成一个会议黑洞。拆之前先看组织图,比看领域模型更现实。

按技术层拆

把 controller、service、dao 各拆成一个服务,或者按「用户中心、消息中心、文件中心」这种技术职能拆。看起来整齐,但一个业务改动仍然横跨多个服务,发布还是得一起发,只是从进程内调用变成了跨进程调用。

按业务能力拆

下单、库存、支付、履约各自一个服务,每个服务拥有自己的数据,对外只暴露业务动作。一个需求通常落在一个服务里,发布可以真正独立,故障也能被限制在一个业务范围内。

按技术层拆是分布式单体的典型来源。它的症状很好认:一次需求要同时改三个服务,三个服务必须一起发版,联调会议开得比拆之前还多。如果已经拆成这样,补救办法不是继续拆,而是把同一业务链路上的几个服务合并回去,先把边界理顺。

五个问题,判断现在该不该拆

不用一上来就做架构评审,按顺序问五个问题,能挡掉大部分冲动拆分。

1. 这次改动是否只落在一个业务能力上?     否 -> 边界没划对,先别拆
2. 这个模块是否需要独立扩容?            否 -> 可以先不拆,做水平扩容
3. 它挂了,业务能否降级或绕开?          否 -> 拆了也会拖垮全站
4. 有没有自动化发布和基本可观测性?      否 -> 先补平台,再谈拆分
5. 有没有至少两个人能长期负责它?        否 -> 拆了也没人维护

五个问题里如果有三个答「否」,现在拆大概率是亏的。尤其是第四题:没有自动化发布、没有统一日志和指标,拆完之后你会有十四个「看不见」的进程,排障时间会比单体更长。单体至少只有一个日志文件、一个进程要盯。

另一个常被忽略的前置条件是调用链的可观测性。单体里一次请求的完整路径就在一个进程里,加个日志就能串起来;拆开之后,没有 traceId 串联,你连「慢在哪一跳」都说不清。这项能力不是拆分之后慢慢补的,应该先有。

如果五个问题里多数答「是」,也不用一次拆到位。先挑一个变更最频繁、依赖最少的边缘业务做试点,跑三个月,量三件事:发布频率有没有真的提高、p99 涨了多少、故障影响范围有没有缩小。三项里至少两项明显变好,再继续。

边界与代价

分布式事务会跟着来。单体里一个数据库事务能保证的事,拆开之后要靠在应用层补偿。这不是「多做一点」,而是换了一套正确性模型,后面那篇讲跨服务一致性会详细说。

运维成本按服务数增长,不按代码量增长。每个服务都要有监控、告警、值班、容量评估、证书、依赖升级。十四个服务就是十四份,小团队很容易被这些固定开销拖住,业务反而没时间做。

调试和排障变难。单体里一个断点能看到全流程,拆开之后要在多个进程、多台机器之间对时间线。没有链路追踪和统一日志,一次线上问题的定位时间可能翻几倍。

拆分容易,合并难。服务一旦被别的团队依赖,想合回去就要处理接口下线、数据迁移、调用方改造。很多「拆错了」的系统最后不是合并,而是又叠加一层网关或聚合服务,结构越来越绕。

团队太小就别拆。常说的两个披萨团队,意思是两顿饭能喂饱的人负责一个服务。三五个人维护的系统,拆成十个服务,每个人要同时当开发、运维和值班,哪一项都做不深。这种规模下,把单体内部的模块边界划清楚、把发布流程理顺,收益往往比拆服务更高。

别为了简历拆。微服务是手段,不是目标。用户感知不到你用了几个服务,只感知到页面快不快、功能稳不稳。拆之前先写清楚「拆完要改善哪三个指标」,写不出来就说明还没到拆的时候。

当天可以自验的五件事

  1. 导出最近一个月 git 提交,按目录统计「总是一起修改的文件组」。一起改得最频繁的那几组,就是当前真实的模块边界。
  2. 量一次完整发布:从合并到上线用了多久,其中构建、测试、等待审批各占多少。如果等待占了一半以上,先优化流程而不是拆服务。
  3. 挑一个你认为「该拆」的模块,列出它写哪些表、读哪些表。如果它和别的模块共写同一张表,先解决数据所有权。
  4. 找一条最长的同步调用链,数一数经过几个进程、几个网关。按每跳十几毫秒估算,看串行总延迟是否已经接近用户的忍耐上限。
  5. 写下三个你希望拆分后改善的指标,例如发布频率、p99、故障影响面。三个月后拿同样的口径再量一次,用数据判断拆得值不值。

下一篇讲服务发现与注册。假设你已经决定要拆,第一个撞上的问题就是「服务地址从哪来」:进程一起一停,地址就变,配置里写死的 IP 迟早失效。服务注册与发现解决的正是这件事,但它自己的缓存也会过期。