rust入门——TCP客户端与服务端通讯

服务端代码 tcp-server.rs

use std::net::{TcpListener, TcpStream};
use std::thread;
use std::io::{Read, Write, Error};
// Handles a single client
fn handle_client(mut stream: TcpStream) -> Result<(), Error> {
    println!("Incoming connection from: {}", stream.peer_addr()?);
    let mut buf = [0; 512];
    loop {
        let bytes_read = stream.read(&mut buf)?;
        if bytes_read == 0 { return Ok(()); }
        stream.write(&buf[..bytes_read])?;
    }
}
fn main() {
    let listener = TcpListener::bind("0.0.0.0:8888")
    .expect("Could not bind");
    for stream in listener.incoming() {
    match stream {
        Err(e) => { eprintln!("failed: {}", e) }
        Ok(stream) => {
            thread::spawn(move || {
                handle_client(stream)
                .unwrap_or_else(|error| eprintln!("{:?}", error));
                });
            }
        }
    }
}

　　

编译 rustc tcp-server.rs

客户端代码 tcp-client.rs

use std::net::TcpStream;
use std::str;
use std::io::{self, BufRead, BufReader, Write};

fn main(){
    let mut stream = TcpStream::connect("127.0.0.1:8888")
    .expect("could not connect to server");

    loop{
        let mut input = String::new();
        let mut buffer: Vec<u8> = Vec::new();
        io::stdin().read_line(&mut input)
        .expect("Failed to read from stdin");

        match input.trim() == "exit"{
            true => break,
            _ => {
                println!("input is {}", input);
            },
        }

        // if input.trim() == "exit"{
        //     println!("bye :-)");
        //     break;
        // }

        stream.write(input.as_bytes())
        .expect("faild to write to server");
        let mut reader = BufReader::new(&stream);

        reader.read_until(b'\n', &mut buffer)
        .expect("Could not read into buffer");
        print!("{}", str::from_utf8(&buffer)
        .expect("Could not write buffer as string"));

    }
}

　　

编译 rustc tcp-client.rs