Skip to content

服务通信:REST、gRPC 与序列化 ​

本篇要点:读完能为一条调用链选出合适的协议,并把超时、重试、连接、幂等这四件事的参数配到互相不打架。前置要求:你知道 HTTP 状态码的含义,写过至少一个对外提供 JSON 接口的服务。

为什么需要它 ​

2026 年 5 月,一个团队把内部 43 个 REST 接口改成了 gRPC,理由很朴素:压测里 JSON 太重了。改完同机房 200 并发下,库存查询的 P99 从 12 毫秒降到 3.4 毫秒,他们很满意。

两周后大促,库存服务被打挂了。复盘数据很干净:库存 QPS 是平时 6 倍,但用户下单量只有 1.4 倍,多出的 4.6 倍全是重试。他们的配置是这样的——网关超时 3 秒,gRPC 客户端超时 2 秒、配了 3 次重试,网关侧还有 2 次重试。于是一个用户请求在下游过载时最多变成 6 次调用,每一次都带着完整的 2 秒预算,而下游本就因为变慢才超时。

协议换对了,参数把他们埋了。这一章讲的不是"REST 和 gRPC 谁快",而是链路上有四个参数必须一起算:协议怎么选、契约怎么演进、超时怎么分层、重试怎么设上限。少算一个,前面三个都可能白做。

核心概念 ​

概念一:差别不在快慢,在契约由谁保证 ​

REST(Representational State Transfer)是围绕资源组织的接口风格:URL 表示资源,HTTP 方法表示动作,状态码表示结果,载荷通常是 JSON。好处是自描述:一次 curl 就能看懂全部信息,网关、缓存、日志都认识它。

gRPC 是 Google 开源的高性能调用框架:先写 .proto 定义服务和消息,再生成强类型代码;传输用 HTTP/2,载荷是二进制帧,内建四种流式调用(单向、服务端流、客户端流、双向流)。

真正的差别是契约归属。REST 的契约在文档里,userId 传字符串还是数字靠联调和运行时校验;gRPC 的契约在编译器里,类型不对编译不过。服务到十几个之后,这条比 3 毫秒延迟值钱得多——反例是 userId 用 JSON 数字传,超过 2^53 的雪花 ID 在 JS 前端被截断,登录直接报"用户不存在"。第二个差别是传输:HTTP/1.1 一个连接同时只跑一个请求,并发靠堆连接数;HTTP/2 一个连接能跑上百个并发的流(stream),这也是 gRPC 的 Channel 能被整个进程共享的原因。对照见表 4-1。

维度REST / JSONgRPC
契约OpenAPI 文档,运行时校验.proto 编译期生成强类型 stub
传输HTTP/1.1 或 HTTP/2,文本HTTP/2,二进制帧,头部压缩
多路复用1.1 需要多连接;2 可以复用单连接跑多路 stream
流式要另上 SSE 或 WebSocket四种流内建
浏览器直调原生支持需要 grpc-web 代理
排查手段curl、浏览器、网关日志grpc_cli、反射,需要工具链
典型位置对外 API、网关层内网高频调用、多语言栈

表 4-1 REST 与 gRPC 的对照

选型口径很短:对外的、给浏览器或第三方调的、要被网关缓存的用 REST;内网服务之间、调用量大、要流式或跨语言的用 gRPC。同一系统里共存是常态——网关对外 REST,到内网 gRPC。

截至 2026 年 11 月,grpc-java 主线是 1.8x,Spring Boot 4.1(4.1.1 于 2026 年 8 月发布)已提供 gRPC 自动配置,引入成本从"一周搭骨架"降到"半天跑通第一个接口"。

概念二:兼容性靠字段号,不靠字段名 ​

Protobuf 序列化时写进流里的是字段编号(field number),不是字段名。字段名只是代码里的别名,字段号才是线上协议。由此有四条硬规则。

改名安全,改号等于换字段。sku_id 改成 product_id 不影响线上,2 号还是 2 号;把 2 号改成 3 号,老客户端会把新字段当未知字段丢掉,读到默认值。

删掉的号必须 reserved。不占位的话,半年后有人觉得"5 号空着可惜"拿来放新字段,那批没升级的客户端就会用旧类型去解析新数据。

1 到 15 号更省空间,留给高频字段。字段号编码进 tag 后,1 到 15 号占 1 字节,16 到 2047 号占 2 字节。每秒几十万次的调用里这是真实带宽。

枚举第一个值必须是 0,且叫 XXX_UNSPECIFIED。proto3 里 0 是默认值,如果 0 被定义成 STATUS_RESERVED,一个没设置该字段的消息就会被当成"已预占"。

反例:某团队把订单状态从 int32 改成 string,字段号 3 没动,以为"号没变就兼容"。灰度期间老客户端按 int32 解析字符串得到 0,两千多笔订单落到"待支付"。

概念三:超时是预算,要逐层递减 ​

单体内调用没有超时——方法要么返回要么抛异常。跨进程之后,超时是你能给下游的唯一承诺:最多等你这么久,超过我就走开。

问题在每一层都自己设超时,数字由不同的人拍。上游 3 秒、下游 5 秒,结果下游还在算、上游已放弃,没人要的结果还占着线程和连接。

正确做法是把超时当预算(deadline budget):入口分配总预算,每经过一跳减去已消耗的时间和留给自己的余量,再把剩下的传给下游。gRPC 的 deadline 就是这个模型——客户端设绝对时间点,框架用 grpc-timeout 头传剩余时间,服务端 Context.current().getDeadline() 拿到的已经是扣减过的值。预算走势如图 4-1 所示。

图 4-1 一次请求的超时预算如何逐层递减

图 4-1 里有两处容易被忽略:网关只用 40 毫秒就转发,说明它没做重活;库存拿到 640 毫秒只用 180 毫秒,把余量还给了上游。没有递减机制,库存会用满 800 毫秒,订单服务早已超时。

这也解释了为什么下游超时该比上游短。上游 3 秒、下游 5 秒,等于允许下游在没人等时继续烧 2 秒资源。

概念四:重试放大与连接复用 ​

重试是唯一一种在故障时主动增加负载的"可用性手段":下游过载变慢,超时变多,重试变多,负载更高,三分钟就能把局部抖动变成雪崩。

算一下就清楚:客户端 3 次、网关 2 次是 6 倍;三层各 3 次就是 27 倍。上面那次事故,库存承受 4.6 倍额外流量。

所以重试要满足三个前提:方法幂等、有全局上限(重试请求不超过总请求的 10%,这个上限叫重试预算,retry budget)、有退避加抖动(exponential backoff with jitter)。只对 UNAVAILABLE 重试,别把 DEADLINE_EXCEEDED 加进去——超时说明下游已经慢了,再打一次只会更慢。

连接复用的道理类似。HTTP/1.1 靠堆连接,所以有连接池,要配 maxTotal 和 maxPerRoute;gRPC 用 HTTP/2,一个 Channel 内可并发跑多路 stream,因此 Channel 是进程级单例,随应用启动创建、随应用关闭销毁。每次 ManagedChannelBuilder.forTarget(...).build() 都要付一次 TCP 握手加 TLS 协商,同机房约 2 个往返,跨可用区 5 到 10 毫秒,比你省下的 8 毫秒序列化开销贵得多。

两个坑:滚动发布时服务端发 GOAWAY 帧,客户端要允许重建连接;长连接过 NAT 或负载均衡会被静默丢弃,keepAlive 间隔要短于中间设备的空闲超时。

概念五:幂等不是"重试不出错",是"重试也不出错" ​

幂等(idempotency)指同样输入执行一次和 N 次,产生的副作用相同。注意是副作用相同,不是返回值相同——第二次返回"已处理"也算幂等。

POST 创建订单天然不幂等,用户点两次就是两单。三种写法可以解决。幂等键(idempotency key):客户端生成 UUID 放进 Idempotency-Key 头,服务端拿它做唯一约束,第一次执行后把结果存下来,后续同 key 直接返回存下的结果;Stripe 的支付接口自 2017 年起就是这个做法,键保留 24 小时。

状态机前置校验:扣库存只允许从"已锁定"转到"已扣减",重复请求在状态检查那一行就被挡住。这种写法不需要额外的表,但要求状态流转显式建模。一次性令牌:优惠券、验证码这类资源做成"消费即失效",用行锁或 Redis 原子操作保证只有一个请求成功。

三种里幂等键最通用,因为能覆盖"服务端执行成功但响应丢了"——客户端不知道成没成只能重发;服务端不存结果就会重复扣款。

动手实践 ​

步骤 1:写 proto,让 buf 拦住不兼容的改动 ​

先装 buf(截至 2026 年 11 月为 1.x 线),建 buf.yaml,写第一个消息。下面这段故意埋了一个错误。

protobuf
syntax = "proto3";
package inventory.v1;

option java_package = "com.example.inventory.v1";
option java_multiple_files = true;

message ReserveResponse {
  enum Status {
    STATUS_UNSPECIFIED   = 0;
    STATUS_RESERVED      = 1;
    STATUS_OUT_OF_STOCK  = 2;
  }
  Status status = 1;
  string reservation_id = 2;
  int32  priority = 5;      // 5 号原来是 warehouse_code,被删掉后又被复用
}

运行结果:

$ buf lint
$ buf breaking --against '.git#branch=main'
inventory/v1/inventory.proto:16:3:Previously present field "5" with name "warehouse_code" on message "ReserveResponse" was deleted.

buf lint 通过说明风格没问题,buf breaking 拦的是语义问题:5 号被删了又被复用。修法是把 5 号占住,新字段换号:

protobuf
  reserved 5;
  reserved "warehouse_code";
  int32  priority = 7;

预期输出:buf breaking 无输出,退出码 0。把这条放进 CI,字段号复用就能在合并前拦住,而不是等灰度时被解析成 0。

步骤 2:给客户端配 deadline 与重试,并算出放大倍数 ​

这段是客户端配置。注意 deadline 和重试一起算:3 次尝试共享同一个 deadline,不是每次重新计时。

java
ManagedChannel channel = ManagedChannelBuilder.forTarget("dns:///inventory:9090")
    .usePlaintext()
    .keepAliveTime(30, TimeUnit.SECONDS)
    .keepAliveTimeout(10, TimeUnit.SECONDS)
    .defaultServiceConfig("""
        {"methodConfig":[{
          "name":[{"service":"inventory.v1.InventoryService","method":"Reserve"}],
          "retryPolicy":{
            "maxAttempts":3,
            "initialBackoff":"0.05s",
            "maxBackoff":"0.4s",
            "backoffMultiplier":2.0,
            "retryableStatusCodes":["UNAVAILABLE"]
          }
        }]}
        """)
    .enableRetry()
    .build();   // 进程级单例,别放到方法里

InventoryServiceGrpc.InventoryServiceBlockingStub stub =
    InventoryServiceGrpc.newBlockingStub(channel)
        .withDeadlineAfter(600, TimeUnit.MILLISECONDS);

运行结果(注入 UNAVAILABLE 后抓的客户端日志):

14:22:07.311 attempt 1 UNAVAILABLE, backoff 52ms
14:22:07.363 attempt 2 UNAVAILABLE, backoff 104ms
14:22:07.723 attempt 3 OK, elapsed 412ms, deadline remaining 188ms

三次尝试共 412 毫秒,仍在 600 毫秒的 deadline 内。maxAttempts 上限是 5,写 6 会被判为配置错误;方法不幂等时把 maxAttempts 设成 1 才对——配 3 只是在放大重复扣款。

步骤 3:用唯一约束把幂等做成数据库保证 ​

幂等键的存储别只靠代码"先查再写",两个请求同时查到"没有"会都往下走。用主键冲突,是数据库层面唯一的原子判断。

sql
CREATE TABLE idempotency_record (
  idem_key      varchar(64)  PRIMARY KEY,
  request_hash  char(64)     NOT NULL,
  response_body jsonb        NOT NULL,
  created_at    timestamptz  NOT NULL DEFAULT now()
);

INSERT INTO idempotency_record (idem_key, request_hash, response_body)
VALUES ('ord-9f3a-20261116-01', :hash, :body)
ON CONFLICT (idem_key) DO NOTHING
RETURNING idem_key;

预期输出(同一个 key 发 5 次并发请求,rowCount 是首次插入的返回行数):

-- 第 1 次:插入成功,返回 1 行
 idem_key
------------------------
 ord-9f3a-20261116-01
(1 row)

-- 第 2 至 5 次:RETURNING 为空,走"读已有结果"分支
(0 rows)

行数为 0 的请求读 response_body 返回,5 个并发只产生一次扣减。request_hash 存请求体摘要,防止同一个 key 提交两个不同订单——这种冲突要报 409。

常见误解 ​

误解一:gRPC 一定比 REST 快,所以内网全换。快的那部分来自二进制编码和 HTTP/2 多路复用,低并发、小载荷时差别只有一两毫秒,跨公网还会被 TLS 和网络抖动吃掉。真正的收益在契约强度和流式能力。如果团队没有 proto 工具链、CI 里也没有代码生成,换 gRPC 会先换出一堆"接口对不上"的问题。

误解二:超时设大一点更安全。超时本质上是资源占用时长,设 30 秒意味着下游挂掉时每个请求占线程 30 秒,200 个并发就能把连接池占满,故障从下游扩散到上游。超时值应由下游 P99.9 反推加一点余量,而不是由"怕失败"决定。

误解三:重试能提高可用性。只在下游故障瞬时、且方法幂等时成立。前提不满足,重试就是把抖动放大成雪崩的那根杠杆。判断很简单:看服务端 QPS 与用户请求数的比值,超过 1.5 说明重试已在放大负载。

小结 ​

  • 选型的差别在契约归属与传输层,不在那几毫秒。对外用 REST,内网高频和流式用 gRPC,两者共存是常态。
  • Protobuf 的字段号是线上协议。改名安全,删字段必须 reserved,枚举 0 值必须是 UNSPECIFIED。
  • 超时按预算逐层递减,下游永远比上游短。上游 3 秒下游 5 秒,是最常见的配置错误。
  • 重试要三个前提:幂等、有预算上限、有退避加抖动。层数乘起来就是放大倍数,3 层各 3 次等于 27 倍。
  • 幂等靠唯一约束和结果落库,不靠代码里先查后写。

相关主题 ​

这一章把调用跑通了,但它有个前提:.proto 和 OpenAPI 里的字段一旦发出去,就不能随便改。《API 契约与版本演进》讲 API 契约与版本演进——怎么用契约优先的方式开发,哪些改动属于破坏性变更,以及在没有停机窗口的前提下,如何让一个字段体面地下线。