gRPC 和传统 RPC 有啥不一样？

mrkong

现在大家做系统开发，都喜欢搞“微服务架构”——简单说就是把一个大系统拆成很多小服务，这样更灵活也更容易扩展。那这些服务之间怎么沟通呢？就得靠一种技术叫 RPC（远程过程调用）。今天我们就来聊聊它的“进化版”：gRPC，看看它和传统的 RPC 到底有啥不一样。

一、先搞懂几个概念什么是 RPC？

可以把它理解成“跨机器调用函数”的方式。就像你在本地调用一个函数一样，但其实它是在另一台服务器上运行的。传统 RPC 有很多种实现，比如 XML-RPC、JSON-RPC、SOAP 等，数据格式多是 XML 或 JSON。

那 gRPC 是啥？

Google 出品的一个更高效的 RPC 框架，基于 HTTP/2 协议，数据格式使用 Protocol Buffers（Protobuf）。性能好、效率高，还能自动生成代码，听起来就很香对吧？

二、gRPC 和传统 RPC 的几大区别（白话版）[td]

对比点	传统 RPC	gRPC
传输协议	HTTP/1 或 TCP	HTTP/2，多路复用、速度快
数据格式	XML/JSON，可读但体积大	Protobuf，体积小、解析快
代码生成	多为手写	支持自动生成客户端/服务端代码
流式处理	一般不支持	支持四种调用模式，支持双向流
跨语言支持	较麻烦	官方支持多语言（Go、Python、Java、C++等）
错误处理	HTTP 状态码处理	标准错误码机制 + 详细描述

三、举个例子更直观用传统 JSON-RPC 调接口（Go 示例）

1. package main
   
2. 
   
3. import (
   
4.     "bytes"
   
5.     "encoding/json"
   
6.     "fmt"
   
7.     "net/http"
   
8. )
   
9. 
   
10. func main() {
    
11.     payload := map[string]interface{}{
    
12.         "jsonrpc": "2.0",
    
13.         "method":  "getUserProfile",
    
14.         "params": map[string]interface{}{
    
15.             "userId":         123,
    
16.             "includeDetails": true,
    
17.         },
    
18.         "id": 1,
    
19.     }
    
20. 
    
21.     data, _ := json.Marshal(payload)
    
22.     resp, _ := http.Post("http://localhost:8000", "application/json", bytes.NewReader(data))
    
23.     defer resp.Body.Close()
    
24. 
    
25.     var result map[string]interface{}
    
26.     json.NewDecoder(resp.Body).Decode(&result)
    
27. 
    
28.     fmt.Printf("结果: %+v\n", result)
    
29. }

复制代码

用 gRPC + Protobuf（Go 示例）

Protobuf 协议定义：

1. syntax = "proto3";
   
2. 
   
3. service UserService {
   
4.   rpc GetUserProfile(UserRequest) returns (UserProfile) {}
   
5. }
   
6. 
   
7. message UserRequest {
   
8.   int32 user_id = 1;
   
9.   bool include_details = 2;
   
10. }
    
11. 
    
12. message UserProfile {
    
13.   int32 user_id = 1;
    
14.   string username = 2;
    
15.   string email = 3;
    
16. }
    

复制代码

Go 客户端调用：

1. conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
   
2. defer conn.Close()
   
3. 
   
4. client := pb.NewUserServiceClient(conn)
   
5. req := &pb.UserRequest{UserId: 123, IncludeDetails: true}
   
6. res, _ := client.GetUserProfile(context.Background(), req)
   
7. 
   
8. fmt.Printf("用户名: %s\n", res.Username)
   

复制代码

结构更清晰、体积更小、传输效率更高。

四、请求处理方式对比
传统 RPC 的调用方式（Go 示例）

1. client, _ := xmlrpc.NewClient("http://localhost:8000", nil)
   
2. 
   
3. var result string
   
4. _ = client.Call("get_user_info", []interface{}{123}, &result)
   
5. fmt.Println("用户信息:", result)
   
6. 
   
7. // 再调另一个方法，又要重新连接
   
8. var product string
   
9. _ = client.Call("get_product_details", []interface{}{456}, &product)
   
10. fmt.Println("商品信息:", product)
    

复制代码

每次调用都像重新打一次电话，很慢。

gRPC 的调用方式（Go 示例）

1. conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
   
2. defer conn.Close()
   
3. 
   
4. client := pb.NewUserServiceClient(conn)
   
5. 
   
6. // 同一个连接可以复用多次调用
   
7. userRes, _ := client.GetUser(context.Background(), &pb.GetUserRequest{UserId: 123})
   
8. productRes, _ := client.GetProduct(context.Background(), &pb.GetProductRequest{ProductId: 456})
   
9. 
   
10. fmt.Println("用户:", userRes.Username)
    
11. fmt.Println("商品:", productRes.Name)
    
12. 
    
13. // 流式接收商品列表
    
14. stream, _ := client.ListProducts(context.Background(), &pb.ListProductsRequest{Category: "手机"})
    
15. for {
    
16.     product, err := stream.Recv()
    
17.     if err == io.EOF {
    
18.         break
    
19.     }
    
20.     fmt.Printf("产品: %s, 价格: %.2f\n", product.Name, product.Price)
    
21. }
    

复制代码

gRPC 就像是拉了一条专线，调用高效还支持流式处理。

五、性能差距有多大？REST（HTTP/1 + JSON）版本（Go 示例）

1. start := time.Now()
   
2. users := []map[string]interface{}{}
   
3. 
   
4. for i := 0; i < 1000; i++ {
   
5.     resp, _ := http.Get(fmt.Sprintf("http://api.example.com/users/%d", i))
   
6.     var user map[string]interface{}
   
7.     json.NewDecoder(resp.Body).Decode(&user)
   
8.     users = append(users, user)
   
9.     resp.Body.Close()
   
10. }
    
11. 
    
12. fmt.Printf("REST API: 获取了 %d 个用户，耗时 %.2f 秒\n", len(users), time.Since(start).Seconds())
    

复制代码

gRPC 版本（Go 示例）

1. conn, _ := grpc.Dial("api.example.com:50051", grpc.WithInsecure())
   
2. defer conn.Close()
   
3. 
   
4. client := pb.NewUserServiceClient(conn)
   
5. 
   
6. start := time.Now()
   
7. res, _ := client.GetUsers(context.Background(), &pb.GetUsersRequest{Limit: 1000})
   
8. 
   
9. fmt.Printf("gRPC: 获取了 %d 个用户，耗时 %.2f 秒\n", len(res.Users), time.Since(start).Seconds())

复制代码

gRPC 更快的原因：

• 支持连接复用
• 使用 Protobuf，数据轻量
• 支持流式、批量处理
  
  

六、错误处理方式对比REST 错误处理（Go 示例）

1. resp, _ := http.Get("http://api.example.com/users/12345")
   
2. if resp.StatusCode != http.StatusOK {
   
3.     var errResp map[string]interface{}
   
4.     json.NewDecoder(resp.Body).Decode(&errResp)
   
5.     fmt.Printf("错误: %v\n", errResp["error"])
   
6. }
   

复制代码

靠 HTTP 状态码和自定义结构，客户端处理比较麻烦。

gRPC 错误处理（Go 示例）

服务端代码：

1. func (s *UserServiceServer) GetUser(ctx context.Context, req *pb.GetUserRequest) (*pb.UserProfile, error) {
   
2.     user := db.FindUser(req.UserId)
   
3.     if user == nil {
   
4.         return nil, status.Errorf(codes.NotFound, "找不到用户 %d", req.UserId)
   
5.     }
   
6.     return user, nil
   
7. }
   

复制代码

客户端代码：

1. res, err := client.GetUser(context.Background(), &pb.GetUserRequest{UserId: 12345})
   
2. if err != nil {
   
3.     st, _ := status.FromError(err)
   
4.     if st.Code() == codes.NotFound {
   
5.         fmt.Println("错误: 用户不存在 -", st.Message())
   
6.     } else {
   
7.         fmt.Println("RPC错误:", st.Code(), "-", st.Message())
   
8.     }
   
9. }
   

复制代码

gRPC 错误处理就像捕获本地异常一样自然。

七、实际应用场景选择用 REST API 的情况：

• 浏览器调用接口：如前端页面 fetch('/api/products')
• 对接第三方平台：比如微信支付、支付宝，接口是 REST 的
• 中小项目：追求开发效率即可，不追求性能极致
  
  

用 gRPC 的情况：

• 微服务通信：服务与服务之间高频通信，高性能必选 gRPC
• 实时数据推送
  
  

Go 示例：

1. func (s *StockServer) PriceStream(req *pb.StockRequest, stream pb.StockService_PriceStreamServer) error {
   
2.     for {
   
3.         price := getPrice(req.Symbol)
   
4.         stream.Send(&pb.StockPrice{
   
5.             Symbol:    req.Symbol,
   
6.             Price:     price,
   
7.             Timestamp: time.Now().Unix(),
   
8.         })
   
9.         time.Sleep(1 * time.Second)
   
10.     }
    
11. }
    

复制代码

• 移动端通信：节省流量，响应更快
• 多语言系统：Go 调 Java、Java 调 Python，gRPC 都能搞定
  
  

八、总结

REST API 就像普通话，大家都能听懂；gRPC 像高速公路，虽然门槛高些，但速度飞快！

• 如果你在做面向用户的 Web 接口，或者项目简单，REST API 足够。
• 如果你在构建微服务、高性能系统、多语言协作，那就果断上 gRPC！