Rust HTTP接口库wrpc-interface-http使用指南

概述

wrpc-interface-http是一个轻量级RPC通信框架，专注于提供高性能的HTTP协议交互解决方案。该库结合了RPC的简洁性和HTTP协议的通用性，特别适合构建微服务架构和分布式系统。

主要特性

• 轻量级设计，低资源消耗
• 基于HTTP/1.1和HTTP/2协议
• 异步/await支持
• 类型安全的接口定义
• 自动序列化/反序列化
• 连接池管理和负载均衡

安装方法

在Cargo.toml中添加依赖：

[dependencies]
wrpc-interface-http = "0.3.0"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }

基本使用方法

1. 定义服务接口

use wrpc_interface_http::*;
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct User {
    id: u64,
    name: String,
    email: String,
}

#[rpc_interface]
trait UserService {
    async fn get_user(&self, id: u64) -> Result<User, RpcError>;
    async fn create_user(&self, user: User) -> Result<u64, RpcError>;
    async fn update_user(&self, user: User) -> Result<(), RpcError>;
}

2. 实现服务端

use wrpc_interface_http::server::*;

struct UserServiceImpl;

#[async_trait]
impl UserService for UserServiceImpl {
    async fn get_user(&self, id: u64) -> Result<User, RpcError> {
        // 实现获取用户逻辑
        Ok(User {
            id,
            name: "John Doe".to_string(),
            email: "john@example.com".to_string(),
        })
    }
    
    async fn create_user(&self, user: User) -> Result<u64, RpcError> {
        // 实现创建用户逻辑
        Ok(1)
    }
    
    async fn update_user(&self, user: User) -> Result<(), RpcError> {
        // 实现更新用户逻辑
        Ok(())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let service = UserServiceImpl;
    let server = HttpServer::bind("127.0.0.1:8080").await?;
    server.serve(service.into_rpc()).await?;
    Ok(())
}

3. 客户端调用

use wrpc_interface_http::client::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建客户端连接
    let client = HttpClient::connect("http://127.0.0.1:8080").await?;
    
    // 调用远程方法
    let user = client.get_user(1).await?;
    println!("User: {:?}", user);
    
    // 创建新用户
    let new_user = User {
        id: 0,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };
    let user_id = client.create_user(new_user).await?;
    println!("Created user with ID: {}", user_id);
    
    Ok(())
}

高级配置

自定义序列化格式

use wrpc_interface_http::config::*;

let config = RpcConfig::default()
    .with_serializer(SerializerType::Json) // 或 MessagePack、Bincode
    .with_timeout(std::time::Duration::from_secs(30));

中间件支持

use wrpc_interface_http::middleware::*;

let server = HttpServer::bind("127.0.0.1:8080")
    .await?
    .with_middleware(LoggerMiddleware::new())
    .with_middleware(AuthMiddleware::new("secret-token"));

错误处理

use wrpc_interface_http::error::RpcError;

async fn handle_user_request() -> Result<(), RpcError> {
    match client.get_user(123).await {
        Ok(user) => {
            println!("Success: {:?}", user);
            Ok(())
        }
        Err(RpcError::NetworkError(e)) => {
            eprintln!("Network error: {}", e);
            Err(RpcError::NetworkError(e))
        }
        Err(RpcError::SerializationError(e)) => {
            eprintln!("Serialization error: {}", e);
            Err(RpcError::SerializationError(e))
        }
        Err(e) => {
            eprintln!("Other error: {}", e);
            Err(e)
        }
    }
}

性能优化建议

1. 启用HTTP/2协议以获得更好的性能
2. 使用连接池管理HTTP连接
3. 配置合适的超时时间
4. 使用二进制序列化格式（如MessagePack）减少数据传输量
5. 启用压缩减少网络带宽使用

这个库提供了简单易用的API，同时保持了高性能和灵活性，是构建Rust微服务应用的优秀选择。

完整示例demo

以下是一个完整的wrpc-interface-http使用示例，包含服务端和客户端的完整实现：

// Cargo.toml 依赖配置
/*
[dependencies]
wrpc-interface-http = "0.3.0"
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
async-trait = "0.1"
*/

// 服务端代码 server.rs
use wrpc_interface_http::*;
use wrpc_interface_http::server::*;
use serde::{Deserialize, Serialize};
use async_trait::async_trait;

// 定义用户数据结构
#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: u64,
    name: String,
    email: String,
}

// 定义RPC服务接口
#[rpc_interface]
trait UserService {
    async fn get_user(&self, id: u64) -> Result<User, RpcError>;
    async fn create_user(&self, user: User) -> Result<u64, RpcError>;
    async fn update_user(&self, user: User) -> Result<(), RpcError>;
}

// 实现用户服务
struct UserServiceImpl;

#[async_trait]
impl UserService for UserServiceImpl {
    async fn get_user(&self, id: u64) -> Result<User, RpcError> {
        // 模拟从数据库获取用户数据
        println!("获取用户 ID: {}", id);
        Ok(User {
            id,
            name: format!("用户{}", id),
            email: format!("user{}@example.com", id),
        })
    }
    
    async fn create_user(&self, user: User) -> Result<u64, RpcError> {
        // 模拟创建用户并返回用户ID
        println!("创建用户: {:?}", user);
        Ok(user.id + 1000) // 返回模拟的用户ID
    }
    
    async fn update_user(&self, user: User) -> Result<(), RpcError> {
        // 模拟更新用户信息
        println!("更新用户: {:?}", user);
        Ok(())
    }
}

// 服务端主函数
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("启动用户服务...");
    
    let service = UserServiceImpl;
    let server = HttpServer::bind("127.0.0.1:8080").await?;
    
    println!("服务运行在: 127.0.0.1:8080");
    server.serve(service.into_rpc()).await?;
    
    Ok(())
}

// 客户端代码 client.rs
use wrpc_interface_http::client::*;
use serde::{Deserialize, Serialize};

// 用户数据结构（需要与服务端保持一致）
#[derive(Serialize, Deserialize, Debug)]
pub struct User {
    id: u64,
    name: String,
    email: String,
}

// 客户端主函数
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("连接用户服务...");
    
    // 创建客户端连接
    let client = HttpClient::connect("http://127.0.0.1:8080").await?;
    println!("连接成功!");
    
    // 测试获取用户
    println!("\n测试获取用户:");
    let user = client.get_user(1).await?;
    println!("获取的用户: {:?}", user);
    
    // 测试创建用户
    println!("\n测试创建用户:");
    let new_user = User {
        id: 0,
        name: "测试用户".to_string(),
        email: "test@example.com".to_string(),
    };
    let user_id = client.create_user(new_user).await?;
    println!("创建的用户ID: {}", user_id);
    
    // 测试更新用户
    println!("\n测试更新用户:");
    let update_user = User {
        id: user_id,
        name: "更新后的用户".to_string(),
        email: "updated@example.com".to_string(),
    };
    client.update_user(update_user).await?;
    println!("用户更新成功!");
    
    Ok(())
}

运行说明

1. 首先启动服务端：

cargo run --bin server

1. 然后运行客户端测试：

cargo run --bin client

这个完整示例展示了如何使用wrpc-interface-http库构建一个完整的RPC服务，包括服务端实现和客户端调用。示例包含了错误处理、数据序列化和基本的RPC通信功能。