[package]
name = "rust_client"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1.14.0", features = ["full"] }
use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
#[tokio::main]
async fn main() -> io::Result<()> {
let mut stream = TcpStream::connect("127.0.0.1:7878").await?;
let (mut rd, mut wr) = stream.split();
let mut buf = vec![0; 1024];
loop {
let n = match rd.read(&mut buf).await {
Ok(n) if n == 0 => {
println!("read zero data, finish");
return Ok(());
}
Ok(n) => {
let msg = String::from_utf8_lossy(&buf[..n]).to_string();
println!("read {} bytes'data : {}", n, msg);
n
}
Err(e) => {
println!("failed to read from socket; err = {}", e);
return Err(e);
}
};
match wr.write_all(&buf[0..n]).await {
Ok(_) => {
println!("write data to server success");
()
}
Err(e) => {
println!("failed to write to socket; err = {}", e);
return Err(e);
}
}
wr.flush().await?;
}
}
[package]
name = "rust_server"
version = "0.1.0"
edition = "2021"
[dependencies]
tokio = { version = "1.14.0", features = ["full"] }
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let listener = TcpListener::bind("127.0.0.1:7878").await?;
loop {
let (mut stream, _) = listener.accept().await?;
tokio::spawn(async move {
let (mut rd, mut wr) = stream.split();
println!("read and write socket spilt success");
let data = "Hello, world!\n";
wr.write_all(data.as_bytes()).await;
println!("write data success");
let mut buf = vec![0; 1024];
match rd.read(&mut buf).await {
Ok(n) => {
let msg = String::from_utf8_lossy(&buf[..n]);
println!("read data : {}", msg);
},
Err(e) => eprintln!("Failed to read from socket; err = {}", e),
}
});
}
}
String::from_utf8_lossy() 函数将字节数组转换为字符串
接受一个字节数组作为参数,并尝试将其转换为 UTF-8 编码的字符串
如果字节数组包含无效的 UTF-8 字符,则这些字符将被替换为问号 ?
from_utf8_lossy() 函数返回一个 Cow 类型的对象
这个对象实现了 ToString trait
所以可以使用 to_string() 方法将其转换为 String 类型的字符串
如果字节数组的长度很大,这个函数还可以使用 &str 类型来节省内存
Cow 是一个“借用或拥有(borrow or own)”字符串类型
其中的 Cow 是“借用或拥有(borrow or own)”的缩写。
它的定义如下:
pub enum Cow<'a, B>
where
B: 'a + ToOwned + ?Sized,
{
Borrowed(&'a B),
Owned(<B as ToOwned>::Owned),
}
在 Rust 中,字符串通常采用 String 或 &str 两种类型。
String 类型是一个可变的字符串类型,实际内容被存储在堆上,并且拥有内存所有权。
&str 类型是一个不可变的字符串切片类型,它的实际内容被存储在其他地方,比如堆上或者栈上,并且不拥有内存所有权。
Cow 类型可以用于同时支持 String 和 &str 两种类型。它的第一个泛型参数 'a 用于指定借用的生命周期,可以是任意标识符,表示 'a 参数对类型的所有权没有影响。第二个泛型参数 B 是一个类型参数,用于指定实际的数据类型。
在 Cow 中,Borrowed(&'a B) 表示借用另一个类型 B 的内容,而 Owned(::Owned) 表示拥有 B 类型的所有权。
如果 B 类型已经拥有内存所有权,则返回 Owned 类型,否则返回 Borrowed 类型。
这使得 Cow 类型在不需要分配内存的情况下,可以支持可变类型和不可变类型的字符串。