Rust网络通信库solar-interface使用指南

简介

solar-interface是一个高性能的Rust网络通信库，专注于跨平台数据交互和接口管理。它提供了简洁的API和强大的功能，适用于构建分布式系统、微服务架构以及需要高效网络通信的应用。

主要特性

• 跨平台支持（Windows/Linux/macOS）
• 高性能异步通信
• 简洁的接口管理
• 多种协议支持（TCP/UDP/WebSocket）
• 内置序列化/反序列化支持

安装

在Cargo.toml中添加依赖：

[dependencies]
solar-interface = "0.3"
tokio = { version = "1.0", features = ["full"] }

基本使用方法

1. 创建TCP服务器

use solar_interface::net::tcp::TcpServer;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut server = TcpServer::bind("127.0.0.1:8080").await?;
    
    while let Ok((mut stream, _)) = server.accept().await {
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            
            // 读取客户端数据
            let n = stream.read(&mut buf).await.unwrap();
            println!("Received: {}", String::from_utf8_lossy(&buf[..n]));
            
            // 发送响应
            stream.write_all(b"Hello from server!").await.unwrap();
        });
    }
    
    Ok(())
}

2. 创建TCP客户端

use solar_interface::net::tcp::TcpClient;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = TcpClient::connect("127.极速.0.1:8080").await?;
    
    // 发送数据
    client.write_all(b"Hello from client!").await?;
    
    // 接收响应
    let mut buf = [0; 1024];
    let n = client.read(&mut buf).await?;
    println!("Server response: {}", String::from_utf8_lossy(&buf[..n]));
    
    Ok(())
}

3. 使用接口管理功能

solar-interface提供了强大的接口管理功能，可以方便地定义和调用远程接口：

use solar_interface::interface::{Interface, RemoteCall};
use serde::{Serialize, Deserialize};

// 定义接口
#[derive(Interface)]
pub trait MathService {
    async fn add(&self, a: i32, b: i32) -> i32;
    async fn multiply(&self, a: i32, b: i32) -> i32;
}

// 服务端实现
struct MathServiceImpl;

#[async_trait::async_trait]
impl MathService for MathServiceImpl {
    async fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
    
    async fn multiply(&self, a: i32, b: i32) -> i32 {
        a * b
    }
}

// 客户端调用
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 服务端注册服务
    let service = MathServiceImpl;
    solar_interface::export_interface!("127.0.0.1:8081", service);
    
    // 客户端调用
    let client: RemoteCall<dyn MathService> = 
        solar_interface::import_interface!("127.0.0.1:8081");
    
    let result = client.add(5, 3).await?;
    println!("5 + 3 = {}", result);
    
    let result = client.multiply(5, 3).await?;
    println!("5 * 3 = {}", result);
    
    Ok(())
}

4. 使用WebSocket通信

use solar_interface::net::websocket::{WebSocketServer, WebSocketClient};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

// WebSocket服务器
#[tokio::main]
async fn ws_server() -> Result<(), Box<dyn std::error::Error>> {
    let mut server = WebSocketServer::bind("127.0.0.1:8082").await?;
    
    while let Ok((mut stream, _)) = server.accept().await {
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            let n = stream.read(&mut buf).await.unwrap();
            println!("WS Received: {}", String::from_utf8_lossy(&buf[..n]));
            
            stream.write_all(b"WS Hello from server!").await.unwrap();
        });
    }
    
    Ok(())
}

// WebSocket客户端
#[tokio::main]
async fn ws_client() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = WebSocketClient::connect("ws://127.0.0.1:8082").await?;
    
    client.write_all(b"Hello from WS client!").await?;
    
    let mut buf = [0; 1024];
    let n = client.read(&mut buf).await?;
    println!("WS Server response: {}", String::from_utf8_lossy(&buf[..n]));
    
    Ok(())
}

高级功能

自定义协议

use solar_interface::protocol::{Protocol, Message};
use bytes::Bytes;

struct MyProtocol;

#[async_trait::async_trait]
impl Protocol for MyProtocol {
    async fn encode(&self, msg: Message) -> Result<Bytes, Box<dyn std::error::Error>> {
        // 自定义编码逻辑
        Ok(msg.into_bytes())
    }
    
    async fn decode(&self, data: Bytes) -> Result<Message, Box<dyn std::error::Error>> {
        // 自定义解码逻辑
        Ok(Message::from(data))
    }
}

// 使用自定义协议创建服务器
let server = TcpServer::with_protocol("127.0.0.1:8083", MyProtocol).await?;

性能优化配置

use solar_interface::config::NetworkConfig;

let config = NetworkConfig {
    tcp_nodelay: true,    // 禁用Nagle算法
    tcp_buffer_size: 8192, // 设置缓冲区大小
    max_connections: 1000, // 最大连接数
    ..Default::default()
};

let server = TcpServer::with_config("127.0.0.1:8084", config).await?;

完整示例

下面是一个完整的TCP聊天服务器和客户端示例：

TCP聊天服务器

use solar_interface::net::tcp::TcpServer;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::collections::HashMap;
use tokio::sync::Mutex;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let clients = Arc::new(Mutex::new(HashMap::new()));
    let mut server = TcpServer::bind("127.0.0.1:8080").await?;
    
    println!("Chat server started on 127.0.0.1:8080");

    while let Ok((mut stream, addr)) = server.accept().await {
        let clients = clients.clone();
        
        tokio::spawn(async move {
            let mut buf = [0; 1024];
            let name = match stream.read(&mut buf).await {
                Ok(n) if n > 0 => String::from_utf8_lossy(&buf[..n]).to_string(),
                _ => return,
            };
            
            println!("{} connected", name);
            clients.lock().await.insert(name.clone(), stream);
            
            // 广播欢迎消息
            broadcast(&clients, &format!("{} joined the chat", name)).await;
            
            loop {
                let n = match stream.read(&mut buf).await {
                    Ok(n) if n > 0 => n,
                    _ => {
                        clients.lock().await.remove(&name);
                        broadcast(&clients, &format!("{} left the chat", name)).await;
                        break;
                    }
                };
                
                let msg = String::from_utf8_lossy(&buf[..n]).to_string();
                broadcast(&clients, &format!("{}: {}", name, msg)).await;
            }
        });
    }
    
    Ok(())
}

async fn broadcast(clients: &Arc<Mutex<HashMap<String, TcpStream>>>, msg: &str) {
    let mut clients = clients.lock().await;
    for (_, stream) in clients.iter_mut() {
        let _ = stream.write_all(msg.as_bytes()).await;
    }
}

TCP聊天客户端

use solar_interface::net::tcp::TcpClient;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::sync::mpsc;
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    println!("Enter your name:");
    let mut name = String::new();
    std::io::stdin().read_line(&mut name)?;
    let name = name.trim();
    
    let mut client = TcpClient::connect("127.0.0.1:8080").await?;
    client.write_all(name.as_bytes()).await?;
    
    let (tx, mut rx) = mpsc::channel(100);
    
    // 读取用户输入
    tokio::spawn(async move {
        loop {
            let mut input = String::new();
            std::io::stdin().read_line(&mut input).unwrap();
            tx.send(input).await.unwrap();
        }
    });
    
    // 接收服务器消息
    tokio::spawn(async move {
        let mut buf = [0; 1024];
        loop {
            match client.read(&mut buf).await {
                Ok(n) if n > 0 => {
                    println!("{}", String::from_utf8_lossy(&buf[..n]));
                }
                _ => break,
            }
        }
    });
    
    // 发送用户输入
    while let Some(msg) = rx.recv().await {
        client.write_all(msg.as_bytes()).await?;
    }
    
    Ok(())
}

总结

solar-interface为Rust开发者提供了强大的网络通信能力，通过简单的API即可实现高性能的跨平台数据交互。无论是基础的TCP/UDP通信，还是高级的接口管理和WebSocket支持，solar-interface都能满足需求。其模块化设计也使得扩展和自定义变得非常简单。

对于需要构建分布式系统或高性能网络服务的Rust项目，solar-interface是一个值得考虑的选择。