Rust如何在Linux中实现网络通信 - 问答

在Linux中使用Rust进行网络通信，你可以使用标准库中的std::net模块，或者使用第三方库如tokio、mio等。以下是使用std::net模块进行基本的网络通信的示例。

TCP通信

服务器端

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 1024];
    loop {
        match stream.read(&mut buffer) {
            Ok(0) => break, // 连接关闭
            Ok(size) => {
                println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
                stream.write_all(b"ACK!") // 发送确认消息
                    .expect("Failed to send response");
            }
            Err(_) => {
                eprintln!("Error reading from socket");
                break;
            }
        }
    }
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;
    println!("Server listening on port 7878");

    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }
            Err(err) => {
                eprintln!("Error: {}", err);
            }
        }
    }

    Ok(())
}

客户端

use std::io::{Read, Write};
use std::net::TcpStream;

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:7878")?;
    println!("Connected to server");

    stream.write_all(b"Hello, server!")?;

    let mut buffer = [0; 1024];
    let size = stream.read(&mut buffer)?;
    println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

UDP通信

发送端

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:0")?;
    socket.connect("127.0.0.1:7878")?;

    socket.send_to(b"Hello, UDP server!", "127.0.0.1:7878")?;
    println!("Message sent to UDP server");

    Ok(())
}

接收端

use std::net::{UdpSocket};

fn main() -> std::io::Result<()> {
    let socket = UdpSocket::bind("127.0.0.1:7878")?;
    println!("UDP server listening on port 7878");

    let mut buffer = [0; 1024];
    let (size, _) = socket.recv_from(&mut buffer)?;
    println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

异步网络通信

对于需要高性能的应用程序，可以使用tokio这样的异步运行时库。以下是使用tokio进行TCP通信的简单示例。

异步TCP服务器

use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:7878").await?;
    println!("Server listening on port 7878");

    loop {
        let (mut socket, _) = listener.accept().await?;

        tokio::spawn(async move {
            let mut buffer = [0; 1024];
            loop {
                match socket.read(&mut buffer).await {
                    Ok(0) => break,
                    Ok(size) => {
                        println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));
                        if socket.write_all(b"ACK!").await.is_err() {
                            eprintln!("Failed to send response");
                            break;
                        }
                    }
                    Err(_) => {
                        eprintln!("Error reading from socket");
                        break;
                    }
                }
            }
        });
    }
}

异步TCP客户端

use tokio::net::TcpStream;
use tokio::io::{AsyncWriteExt, AsyncReadExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut stream = TcpStream::connect("127.0.0.1:7878").await?;
    println!("Connected to server");

    stream.write_all(b"Hello, async server!").await?;

    let mut buffer = [0; 1024];
    let size = stream.read(&mut buffer).await?;
    println!("Received: {}", String::from_utf8_lossy(&buffer[..size]));

    Ok(())
}

在使用这些示例之前，请确保你的Linux系统上已经安装了Rust编程语言。如果没有，你可以访问Rust官网下载并安装。对于异步示例，你需要添加tokio作为依赖项到你的Cargo.toml文件中：

[dependencies]
tokio = { version = "1", features = ["full"] }

然后运行cargo build来编译你的项目。

0 赞

0 踩