学完这篇,你能在同步 RPC(gRPC)和异步消息队列之间做出有依据的选择,并写出最小可运行的 Go 代码骨架。
第一步:先判断是「问结果」还是「通知事情」
选型只看一个问题:调用方需不需要立刻拿到对方的返回值。
- 需要拿返回值(查用户、扣库存、算价格)→ 用 RPC,同步请求-响应。
- 只是通知「事情发生了」(下单成功要发短信、加积分、刷榜单)→ 用消息队列,异步解耦。
常见错误是拿消息队列硬凑同步调用:生产者发一条,然后阻塞等回复 topic。这等于自己实现了一个更差的 RPC,还丢掉了超时和错误语义。反过来,把发短信这种下游故障不该影响主流程的动作塞进 RPC 链路里串行等待,一个短信网关抖动就能拖垮下单接口。
注意:判断标准不是「哪个技术更新」,而是「调用方是否依赖返回结果继续执行」。依赖就走 RPC,不依赖就走 MQ。
第二步:RPC 选 gRPC,先写 proto
Go 生态里跨语言、带强类型契约的 RPC,直接上 gRPC。新建 proto/order.proto:
syntax = "proto3";
package order.v1;
option go_package = "example.com/demo/order/v1;orderv1";
service OrderService {
rpc GetOrder(GetOrderRequest) returns (GetOrderResponse);
}
message GetOrderRequest { string order_id = 1; }
message GetOrderResponse { string order_id = 1; string status = 2; }
生成代码:
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
protoc --go_out=. --go_opt=paths=source_relative \
--go-grpc_out=. --go-grpc_opt=paths=source_relative \
proto/order.proto
会得到 order.pb.go 和 order_grpc.pb.go 两个文件,服务端实现接口、客户端拿 stub,都不用自己写序列化。
注意:--go_out 和 --go-grpc_out 两行都不能少,只跑第一个会生成消息结构但没有服务定义,编译时报 undefined: orderv1.NewOrderServiceClient。
第三步:服务端与客户端的两个必设参数
服务端注册:
s := grpc.NewServer(
grpc.UnaryInterceptor(logInterceptor), // 日志/鉴权/恢复 panic 放这里
)
orderv1.RegisterOrderServiceServer(s, &server{})
s.Serve(lis)
拦截器里统一处理超时和 panic 恢复,别在每个 handler 里重复写。
客户端最容易被忘的是超时:
ctx, cancel := context.WithTimeout(context.Background(), 800*time.Millisecond)
defer cancel()
resp, err := client.GetOrder(ctx, &orderv1.GetOrderRequest{OrderId: id})
if err != nil {
st, _ := status.FromError(err)
// st.Code() 判断是 DeadlineExceeded 还是 NotFound
}
超时值按下游 P99 定,一般 300ms~1s。父 context 要一路往下传,HTTP 入口的 context 直接透传到 gRPC 调用,这样上游断开时下游也能及时取消。
注意:不设 WithTimeout 的 gRPC 调用会无限等,上游一个慢查询就能把你的 goroutine 全部堆住,表现为内存缓慢上涨、连接数暴涨。
第四步:消息队列选型与最小生产消费
选型按团队规模来:中小规模、要轻量,用 NATS JetStream;要长期留痕、高吞吐、生态成熟,用 Kafka;要复杂路由(延迟队列、死信、优先级),用 RabbitMQ。这里以 Kafka 为例,用 segmentio/kafka-go。
生产端:
w := &kafka.Writer{
Addr: kafka.TCP("localhost:9092"),
Topic: "order.created",
Balancer: &kafka.LeastBytes{},
}
defer w.Close()
err := w.WriteMessages(ctx, kafka.Message{
Key: []byte(orderID), // 同一个订单进同一分区,保证局部有序
Value: payload,
})
消费端:
r := kafka.NewReader(kafka.ReaderConfig{
Brokers: []string{"localhost:9092"},
GroupID: "notify-worker",
Topic: "order.created",
})
defer r.Close()
for {
m, err := r.FetchMessage(ctx) // 手动提交,处理成功后再提交
if err != nil { break }
if err := handle(m); err != nil {
continue // 不提交,等重投
}
r.CommitMessages(ctx, m)
}
GroupID 相同的一组消费者会自动分摊分区;不同 GroupID 各自收到全量消息,所以新增一个下游只要起一个新 group,不用改生产端。
注意:Kafka 是至少一次投递,不是恰好一次。handle 可能被重复执行,必须幂等——用消息里的业务 ID 建唯一索引或写入去重表,别指望队列替你保证只执行一次。
第五步:组合用法才是常态
一个订单服务典型链路:网关 → gRPC 调订单服务(同步,用户等结果)→ 订单落库成功后发 order.created 消息 → 积分、通知、榜单各自消费(异步,失败重试不影响下单)。
原则是:主流程用 RPC 保证强一致和明确错误,副作用全部丢给 MQ。RPC 调用数控制在 3 层以内,超过就是服务边界没划清。
小结
- 需要返回值走 gRPC,只是通知走消息队列,别用 MQ 模拟同步调用。
- proto 文件同时产出消息结构和服务定义,两条 protoc 命令都要跑。
- gRPC 客户端必须设
WithTimeout,父 context 一路透传;panic 恢复和日志放拦截器。
- Kafka 用业务 ID 做 Message Key 保证同键有序,用 GroupID 做消费组隔离。
- 消息队列至少一次投递,消费端幂等是硬性要求,不是可选项。
- 真实系统是 RPC 主干 + MQ 副作用的组合,不是二选一。