grpc-build-core：Rust gRPC构建工具使用指南

介绍

grpc-build-core是一个专为Rust设计的gRPC构建工具，能够高效生成gRPC客户端和服务端代码。该库作为prost-build的扩展，提供了更简洁的配置方式和更强大的代码生成能力，特别适合需要高性能gRPC通信的Rust项目。

主要特性

• 基于prost和tonic构建
• 支持proto3语法
• 自动生成异步客户端和服务端代码
• 可配置的代码生成选项
• 与Cargo构建系统无缝集成

安装方法

在Cargo.toml中添加依赖：

[dependencies]
grpc-build-core = "0.1"
prost = "0.11"
tonic = "0.8"

[build-dependencies]
grpc-build-core = "0.1"

使用方法

1. 创建build.rs构建脚本

// build.rs
use grpc_build_core::Builder;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    Builder::new()
        .build_server(true)
        .build_client(true)
        .out_dir("src/generated")
        .compile(&["proto/hello.proto"], &["proto/"])?;
    Ok(())
}

2. 定义Proto文件

// proto/hello.proto
syntax = "proto3";

package hello;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
    string name = 1;
}

message HelloResponse {
    string message = 1;
}

3. 使用生成的代码

服务端实现示例：

// src/main.rs
mod generated;
use generated::hello::{greeter_server::{Greeter, GreeterServer}, HelloRequest, HelloResponse};
use tonic::{transport::Server, Request, Response, Status};

#[derive(Default)]
pub struct MyGreeter {}

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloResponse>, Status> {
        let reply = HelloResponse {
            message: format!("Hello {}!", request.into_inner().name),
        };
        Ok(Response::new(reply))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let greeter = MyGreeter::default();

    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;

    Ok(())
}

客户端使用示例：

// src/client.rs
mod generated;
use generated::hello::{greeter_client::GreeterClient, HelloRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = GreeterClient::connect("http://[::1]:50051").await?;
    
    let request = tonic::Request::new(HelloRequest {
        name: "World".into(),
    });
    
    let response = client.say_hello(request).await?;
    println!("RESPONSE={:?}", response);
    
    Ok(())
}

配置选项

Builder::new()
    .build_server(true)        // 生成服务端代码
    .build_client(true)        // 生成客户端代码
    .out_dir("src/generated")  // 输出目录
    .type_attribute(".", "#[derive(serde::Serialize, serde::Deserialize)]") // 添加属性
    .compile_protos(&["proto/hello.proto"], &["proto/"])?;

注意事项

1. 确保protobuf编译器（protoc）已安装并在PATH中
2. 生成的代码会在每次构建时更新
3. 建议将生成的文件加入.gitignore
4. 支持自定义代码生成选项和扩展

这个工具极大简化了Rust项目中gRPC代码的生成和使用过程，让开发者能够更专注于业务逻辑的实现。

完整示例demo

以下是一个完整的gRPC服务示例，包含服务端和客户端的完整实现：

项目结构：

my-grpc-project/
├── Cargo.toml
├── build.rs
├── proto/
│   └── hello.proto
└── src/
    ├── main.rs
    └── client.rs

Cargo.toml:

[package]
name = "my-grpc-project"
version = "0.1.0"
edition = "2021"

[dependencies]
grpc-build-core = "0.1"
prost = "0.11"
tonic = "0.8"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

[build-dependencies]
grpc-build-core = "0.1"

build.rs:

use grpc_build_core::Builder;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    Builder::new()
        .build_server(true)
        .build_client(true)
        .out_dir("src/generated")
        .compile(&["proto/hello.proto"], &["proto/"])?;
    Ok(())
}

proto/hello.proto:

syntax = "proto3";

package hello;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloResponse);
    rpc SayHelloStream (HelloRequest) returns (stream HelloResponse);
}

message HelloRequest {
    string name = 1;
    int32 count = 2;
}

message HelloResponse {
    string message = 1;
    int32 sequence = 2;
}

src/main.rs (服务端):

// 引入生成的gRPC代码
mod generated;
use generated::hello::{
    greeter_server::{Greeter, GreeterServer},
    HelloRequest, HelloResponse
};
use tonic::{transport::Server, Request, Response, Status};
use tokio_stream::wrappers::ReceiverStream;
use tokio::sync::mpsc;

// 实现Greeter服务
#[derive(Default)]
pub struct MyGreeter {}

#[tonic::async_trait]
impl Greeter for MyGreeter {
    // 简单的SayHello方法
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloResponse>, Status> {
        let req = request.into_inner();
        let reply = HelloResponse {
            message: format!("Hello {}!", req.name),
            sequence: 0,
        };
        Ok(Response::new(reply))
    }

    // 流式响应的SayHelloStream方法
    async fn say_hello_stream(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<Self::SayHelloStreamStream>, Status> {
        let req = request.into_inner();
        let (tx, rx) = mpsc::channel(4);
        
        // 在后台任务中生成流式响应
        tokio::spawn(async move {
            for i in 0..req.count {
                let response = HelloResponse {
                    message: format!("Hello {} - message {}", req.name, i + 1),
                    sequence: i as i32 + 1,
                };
                
                if tx.send(Ok(response)).await.is_err() {
                    break;
                }
                
                tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
            }
        });

        Ok(Response::new(ReceiverStream::new(rx)))
    }
}

type SayHelloStreamStream = 
    tonic::codec::Streaming<Result<HelloResponse, Status>>;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let greeter = MyGreeter::default();

    println!("gRPC server starting on {}", addr);

    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;

    Ok(())
}

src/client.rs (客户端):

// 引入生成的gRPC代码
mod generated;
use generated::hello::{greeter_client::GreeterClient, HelloRequest};
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 连接到gRPC服务器
    let mut client = GreeterClient::connect("http://[::1]:50051").await?;
    
    // 测试普通RPC调用
    println!("Testing simple RPC call...");
    let request = tonic::Request::new(HelloRequest {
        name: "World".into(),
        count: 0,
    });
    
    let response = client.say_hello(request).await?;
    println!("Simple response: {:?}", response.into_inner());
    
    // 测试流式RPC调用
    println!("\nTesting streaming RPC call...");
    let stream_request = tonic::Request::new(HelloRequest {
        name: "Streaming".into(),
        count: 5,
    });
    
    let mut stream = client.say_hello_stream(stream_request).await?.into_inner();
    
    while let Some(item) = stream.next().await {
        match item {
            Ok(response) => println!("Stream response: {:?}", response),
            Err(e) => eprintln!("Error in stream: {}", e),
        }
    }
    
    Ok(())
}

运行说明：

1. 首先确保安装了protobuf编译器：

# Ubuntu/Debian
sudo apt-get install protobuf-compiler

# macOS
brew install protobuf

1. 启动服务端：

cargo run

1. 在另一个终端运行客户端：

cargo run --bin client

这个完整示例展示了如何使用grpc-build-core创建一个支持普通RPC调用和流式RPC调用的完整gRPC服务，包含了服务端和客户端的完整实现。