当前位置：网站首页>Rust web (I) -- self built TCP server

Rust web (I) -- self built TCP server

2022-07-27 02:54:00 【Shi Shang がりへ】

I learned a little some time ago Rust Basic content of , Out of learning Web Development requirements , Also to consolidate what I learned Rust Basics , Just try to record your study Rust Web A little bit of ;
Implement environment
OS: Ubuntu 14.0
IDE: PyCharm
This article is a personal study note , About Rust The basic part of does not mention too much , It is inevitable that there will be omissions in some details , Please also consult carefully ;

Catalog

Rust Web（ One ）—— build by oneself TCP Server

One 、 Project creation

Preliminary operation

3、 ... and 、TCP Client

Library Introduction

Running effect

Four 、 Message sending and receiving

Server

Client

Running effect

5、 ... and 、 The overall structure of the project

Rust Web（ One ）—— build by oneself TCP Server

One 、 Project creation

Use at your choice cargo Create the initial project , It's called pro1;

Enter project directory , Create two more sub projects , Respectively tcpserver、tcpclient;

open pro1 Medium Cargo.toml file , Add subprojects to the current workspace , As follows ：

Two 、TCP Server

Enter subproject tcpserver, open src Next Of mian.rs file ;
The following is the specific design process ：

Library Introduction

introduce Rust Self contained network programming library std::net::TcpListener

Listener binding

Create one with specific IP:port Bound listening instance ;

Message reception

For message reception , There are two options ：
One is Only accept once The operation ends immediately after the message （ It's not commonly used ）;
The other is except for artificial interruption Infinite loop receive , This kind of scheme is more used in actual design ;
The specific implementation reference is as follows

One time reception

Cyclic reception

In right formula stream Belong to std::result::Result<> type , So you need to use unwrap() Simple exception handling ;

use std::net::TcpListener;

fn main() {
    let listener = TcpListener::bind("127.0.0.1:2333").unwrap();
    println!("Running on port 2333...");

    for stream in listener.incoming() {
        let _stream = stream.unwrap();
        println!("Connection established!");
    }
}

Preliminary operation

Here's how it works ;

3、 ... and 、TCP Client

Enter subproject tcpclient, go to src/main.rs;
The specific steps are as follows ：

Library Introduction

introduce Rust Bring your own library std::net::TcpStream;
Create a data flow instance to connect to the server at the specified address ;

use std::net::TcpStream;

fn main() {
    let stream = TcpStream::connect("127.0.0.1:2333").unwrap();
}

Running effect

Client

Server

Four 、 Message sending and receiving

Because the network programming library introduced realizes Read and write Trait, So we need to introduce two Trait
std::io::{Read, Write}
TCP Reading and writing in message transmission Original byte string form ;

Server

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

fn main() {
    let listener = TcpListener::bind("127.0.0.1:2333").unwrap();
    println!("Running on port 2333...");

    for stream in listener.incoming() {
        let mut stream = stream.unwrap();
        println!("Connection established!");

        let mut buffer = [0; 1024];
        stream.read(&mut buffer).unwrap();
        stream.write(&mut buffer).unwrap();
    }
}

Client

Additional warehousing is required at the client std::str

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

fn main() {
    let mut stream = TcpStream::connect("127.0.0.1:2333").unwrap();
    stream.write("Here's CLient End".as_bytes()).unwrap();

    let mut buffer = [0; 17]; //  Here  17  Is to match the length of the message 
    stream.read(&mut buffer).unwrap();

    println!("Response from server: {:?}",
             str::from_utf8(&mut buffer).unwrap() // utf-8 Receive in encoded form 
    );
}