在.NET Core API 微服务中使用 gRPC：从通信模式到场景选型

[一、gRPC 基础：为什么它适合微服务？](#一、gRPC 基础：为什么它适合微服务？)

[二、gRPC 的四种通信模式及.NET Core 实现](#二、gRPC 的四种通信模式及.NET Core 实现)

[1. 一元 RPC（Unary RPC）：最基础的请求 - 响应模式](#1. 一元 RPC（Unary RPC）：最基础的请求 - 响应模式)

[2. 服务器流式 RPC（Server Streaming RPC）：服务端批量推送数据](#2. 服务器流式 RPC（Server Streaming RPC）：服务端批量推送数据)

[3. 客户端流式 RPC（Client Streaming RPC）：客户端批量提交数据](#3. 客户端流式 RPC（Client Streaming RPC）：客户端批量提交数据)

[4. 双向流式 RPC（Bidirectional Streaming RPC）：实时双向交互](#4. 双向流式 RPC（Bidirectional Streaming RPC）：实时双向交互)

[三、gRPC 在微服务中的核心使用场景](#三、gRPC 在微服务中的核心使用场景)

[四、gRPC vs RESTful API：优劣势对比](#四、gRPC vs RESTful API：优劣势对比)

五、总结：如何在微服务中选择？

在微服务架构中，服务间通信的效率、可靠性和灵活性直接影响系统整体性能。gRPC 作为一种高性能的远程过程调用（RPC）框架，基于 HTTP/2 协议和 Protocol Buffers（Protobuf）序列化机制，已成为.NET Core 微服务间通信的热门选择。本文将详细解析 gRPC 的四种通信模式、适用场景，并与 RESTful API 进行对比，帮助你在微服务架构中合理选型。

一、gRPC 基础：为什么它适合微服务？

gRPC 是由 Google 开发的开源 RPC 框架，其核心优势源于两大技术基石：

HTTP/2 协议：支持多路复用、二进制帧传输、服务器推送等特性，解决了 HTTP/1.1 的连接阻塞问题。

Protocol Buffers：一种强类型二进制序列化格式，相比 JSON/XML，序列化后体积更小、解析速度更快，且自带接口定义能力。

在.NET Core 中，gRPC 通过Grpc.AspNetCore包提供原生支持，可与ASP.NET Core 生态无缝集成，尤其适合微服务间的高频、低延迟通信场景。

二、gRPC 的四种通信模式及.NET Core 实现

gRPC 基于 "服务定义" 和 "消息类型" 构建通信契约，通过.proto文件定义接口，再生成客户端和服务端代码。其四种通信模式覆盖了几乎所有微服务交互场景：

1. 一元 RPC（Unary RPC）：最基础的请求 - 响应模式

定义：客户端发送一个请求，服务端返回一个响应，类似传统的 HTTP 接口调用。

流程：

客户端调用生成的方法，发送请求消息。
服务端接收请求并处理。
服务端返回响应消息，一次交互结束。

代码示例：

.proto文件定义：

TypeScript 复制代码

syntax = "proto3";
service UserService {
  // 一元RPC：根据ID查询用户
  rpc GetUserById (UserIdRequest) returns (UserResponse);
}

message UserIdRequest {
  int32 user_id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

服务端实现（.NET Core）：

cs 复制代码

public class UserService : UserService.UserServiceBase
{
    public override Task<UserResponse> GetUserById(UserIdRequest request, ServerCallContext context)
    {
        // 模拟查询数据库
        var user = new UserResponse { Id = request.UserId, Name = "张三", Email = "zhangsan@example.com" };
        return Task.FromResult(user);
    }
}

客户端调用：

TypeScript 复制代码

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new UserService.UserServiceClient(channel);
var response = await client.GetUserByIdAsync(new UserIdRequest { UserId = 1 });
Console.WriteLine($"用户名称：{response.Name}");

适用场景：简单的查询或命令操作，如 "根据 ID 查询资源""提交表单数据" 等单次交互场景。

2. 服务器流式 RPC（Server Streaming RPC）：服务端批量推送数据

定义：客户端发送一个请求，服务端返回一个持续的数据流（多个响应），直到服务端主动结束流。

流程：

客户端发送请求。
服务端接收后，通过流多次返回响应（如分页数据、实时日志）。
服务端关闭流，客户端接收完成。

代码示例：

.proto文件定义：

TypeScript 复制代码

service OrderService {
  // 服务器流式RPC：获取订单历史（分页推送）
  rpc GetOrderHistory (OrderHistoryRequest) returns (stream OrderResponse);
}

message OrderHistoryRequest {
  int32 user_id = 1;
}

message OrderResponse {
  int32 order_id = 1;
  string product = 2;
  double amount = 3;
}

服务端实现：

cs 复制代码

public class OrderService : OrderService.OrderServiceBase
{
    public override async Task GetOrderHistory(OrderHistoryRequest request, IServerStreamWriter<OrderResponse> responseStream, ServerCallContext context)
    {
        // 模拟分批返回数据
        var orders = new List<OrderResponse>
        {
            new() { OrderId = 1, Product = "手机", Amount = 5999 },
            new() { OrderId = 2, Product = "电脑", Amount = 8999 },
            new() { OrderId = 3, Product = "耳机", Amount = 999 }
        };

        foreach (var order in orders)
        {
            await responseStream.WriteAsync(order);
            await Task.Delay(500); // 模拟延迟
        }
    }
}

客户端调用：

TypeScript 复制代码

var client = new OrderService.OrderServiceClient(channel);
using var call = client.GetOrderHistory(new OrderHistoryRequest { UserId = 1 });
await foreach (var order in call.ResponseStream.ReadAllAsync())
{
    Console.WriteLine($"订单ID：{order.OrderId}，商品：{order.Product}");
}

适用场景：需要服务端持续返回数据的场景，如 "分页查询大量数据""实时日志推送""股票价格更新" 等。

3. 客户端流式 RPC（Client Streaming RPC）：客户端批量提交数据

定义：客户端通过流多次发送请求，服务端在接收完所有请求后返回一个响应。

流程：

客户端通过流多次发送数据（如分批上传文件）。
服务端接收所有数据后处理。
服务端返回一个最终响应。

代码示例：

.proto文件定义：

TypeScript 复制代码

service FileService {
  // 客户端流式RPC：上传文件（分片）
  rpc UploadFile (stream FileChunkRequest) returns (FileUploadResponse);
}

message FileChunkRequest {
  bytes chunk_data = 1;
  string file_name = 2;
  bool is_last_chunk = 3;
}

message FileUploadResponse {
  bool success = 1;
  string file_path = 2;
}

服务端实现：

cs 复制代码

public class FileService : FileService.FileServiceBase
{
    public override async Task<FileUploadResponse> UploadFile(IAsyncStreamReader<FileChunkRequest> requestStream, ServerCallContext context)
    {
        var filePath = Path.Combine("uploads", Guid.NewGuid().ToString());
        using var fs = new FileStream(filePath, FileMode.Create);

        while (await requestStream.MoveNextAsync())
        {
            var chunk = requestStream.Current;
            await fs.WriteAsync(chunk.ChunkData.ToArray());
            if (chunk.IsLastChunk) break;
        }

        return new FileUploadResponse { Success = true, FilePath = filePath };
    }
}

客户端调用：

TypeScript 复制代码

var client = new FileService.FileServiceClient(channel);
using var call = client.UploadFile();

// 模拟分片上传
var chunks = new List<FileChunkRequest>
{
    new() { ChunkData = ByteString.CopyFromUtf8("第一部分数据"), FileName = "test.txt", IsLastChunk = false },
    new() { ChunkData = ByteString.CopyFromUtf8("第二部分数据"), FileName = "test.txt", IsLastChunk = true }
};

foreach (var chunk in chunks)
{
    await call.RequestStream.WriteAsync(chunk);
}
await call.RequestStream.CompleteAsync();

var response = await call.ResponseAsync;
Console.WriteLine($"上传结果：{response.Success}，路径：{response.FilePath}");

适用场景：客户端需要批量提交数据的场景，如 "大文件分片上传""批量数据导入""传感器批量上报数据" 等。

4. 双向流式 RPC（Bidirectional Streaming RPC）：实时双向交互

定义：客户端和服务端通过各自的流双向发送数据，双方可独立发送 / 接收，无需等待对方响应，类似 "即时通讯"。

流程：

客户端和服务端建立流连接。
客户端可随时发送数据，服务端也可随时返回数据。
任意一方关闭流，交互结束。

代码示例：

.proto文件定义：

TypeScript 复制代码

service ChatService {
  // 双向流式RPC：实时聊天
  rpc Chat (stream ChatMessageRequest) returns (stream ChatMessageResponse);
}

message ChatMessageRequest {
  string user = 1;
  string message = 2;
}

message ChatMessageResponse {
  string timestamp = 1;
  string user = 2;
  string message = 3;
}

服务端实现：

cs 复制代码

public class ChatService : ChatService.ChatServiceBase
{
    public override async Task Chat(IAsyncStreamReader<ChatMessageRequest> requestStream, IServerStreamWriter<ChatMessageResponse> responseStream, ServerCallContext context)
    {
        // 并行处理：一边读客户端消息，一边写响应
        var readTask = Task.Run(async () =>
        {
            while (await requestStream.MoveNextAsync())
            {
                var request = requestStream.Current;
                // 广播消息（简化处理，实际需维护连接池）
                await responseStream.WriteAsync(new ChatMessageResponse
                {
                    Timestamp = DateTime.Now.ToString("HH:mm:ss"),
                    User = request.User,
                    Message = request.Message
                });
            }
        });

        await readTask;
    }
}

客户端调用：

cs 复制代码

var client = new ChatService.ChatServiceClient(channel);
using var call = client.Chat();

// 发送消息的任务
var sendTask = Task.Run(async () =>
{
    while (true)
    {
        Console.Write("输入消息（退出请输入q）：");
        var msg = Console.ReadLine();
        if (msg == "q") break;

        await call.RequestStream.WriteAsync(new ChatMessageRequest
        {
            User = "客户端A",
            Message = msg
        });
    }
    await call.RequestStream.CompleteAsync();
});

// 接收消息的任务
var receiveTask = Task.Run(async () =>
{
    await foreach (var response in call.ResponseStream.ReadAllAsync())
    {
        Console.WriteLine($"[{response.Timestamp}] {response.User}：{response.Message}");
    }
});

await Task.WhenAll(sendTask, receiveTask);

适用场景：需要实时双向交互的场景，如 "即时通讯""多人协作编辑""实时游戏对战" 等。

三、gRPC 在微服务中的核心使用场景

结合上述四种模式，gRPC 在微服务中的典型应用场景包括：

高频内部服务调用：微服务间的同步通信（如订单服务调用支付服务），利用 gRPC 的高性能降低延迟。
实时数据推送：如物流系统的位置实时更新（服务器流式）、监控系统的指标实时上报（客户端流式）。
大数据传输：通过流式传输避免单次请求数据量过大导致的超时（如数据备份、日志同步）。
双向实时交互：如客服系统的实时对话、协作工具的实时状态同步。

四、gRPC vs RESTful API：优劣势对比

|----------|-----------------------------------------------|------------------------------------------|
| 维度 | gRPC | RESTful API |
| 性能 | 极高：HTTP/2 多路复用 + 二进制协议，吞吐量是 REST 的 5-10 倍。 | 中等：HTTP/1.1 文本协议（JSON/XML），解析耗时。 |
| 契约定义 | 强类型：通过.proto文件严格定义接口，支持自动生成代码，编译期校验。 | 弱类型：依赖文档（如 Swagger），需手动保证客户端与服务端一致。 |
| 通信模式 | 支持四种模式（一元、服务端流、客户端流、双向流），灵活应对复杂场景。 | 仅支持请求 - 响应模式（扩展需 WebSocket 等）。 |
| 兼容性 | 较差：二进制协议不适合浏览器直接调用，需通过网关转换。 | 极好：基于 HTTP/1.1 文本协议，浏览器、Postman 等工具直接支持。 |
| 学习成本 | 较高：需学习 Protobuf 语法、gRPC 概念及工具链。 | 较低：基于 HTTP 标准，开发者熟悉度高。 |
| 生态工具 | 正在完善：.NET Core 集成良好，但调试工具（如浏览器 DevTools）支持有限。 | 成熟：Swagger、Postman 等工具生态丰富。 |
| 适用场景 | 微服务内部通信、实时交互、高性能需求场景。 | 面向用户的 API（BFF 层）、简单的跨系统交互。 |

五、总结：如何在微服务中选择？

gRPC 凭借高性能 和灵活的流式通信，成为.NET Core 微服务内部通信的首选方案，尤其适合需要实时性、高吞吐量的场景。但如果你的服务需要直接暴露给浏览器或第三方（非微服务场景），RESTful API 仍是更稳妥的选择。

在实际架构中，可采用 "内外分离" 策略：内部微服务用 gRPC 提升效率，外部通过 BFF 层（Backend For Frontend）将 gRPC 转换为 RESTful API 供前端调用，兼顾性能与兼容性。

希望本文能帮助你快速掌握 gRPC 在.NET Core 微服务中的应用，不妨从一个简单的一元 RPC 接口开始尝试，逐步扩展到流式场景，体验其带来的性能提升！