Skip to content

Rust使用Websocket

ws-rs

GitHub

https://ws-rs.org/

https://ws-rs.org/docs

https://crates.io/

https://crates.io/crates/websocket

1
2
3
[dependencies.ws]

git = "https://github.com/housleyjk/ws-rs"

客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
extern crate ws;

use ws::{connect, Handler, Sender, Handshake, Result, Message, CloseCode, Error};

struct Client {
    out: Sender,
}
impl Handler for Client {
    fn on_open(&mut self, _: Handshake) -> Result<()> {
        println!("on_open connect to ws://127.0.0.1:8080");
        Ok(())
    }
    fn on_message(&mut self, msg: Message) -> Result<()> {
        println!("Got message: {}", msg);
        Ok(())
    }
    fn on_close(&mut self, code: CloseCode, reason: &str) {
        println!("on_close code = {:?}, reason = {}", code, reason);
    }
    fn on_error(&mut self, err: Error) {
        println!("on_error err = {}", err);
    }
}

fn main() {
  connect("ws://127.0.0.1:8080", |out| Client { out: out } ).unwrap()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
extern crate ws;
extern crate url;
use ws::{Sender, Result, CloseCode, WebSocket};

fn main() -> Result<()> {
    let f = |out: Sender| {
        move |msg| {
            println!("Got message: {}", msg);
            out.close(CloseCode::Normal)
        }
    };
    let mut ws = WebSocket::new(f)?;
    let url = url::Url::parse("ws://hq.sinajs.cn/wskt?list=s_sh000001").unwrap();
    ws.connect(url)?;
    ws.run()?;
    Ok(())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
extern crate ws;

use ws::{connect, CloseCode};

fn main() {


    if let Err(error) = connect("ws://echo.websocket.org", |out| {
        // Queue a message to be sent when the WebSocket is open
        if out.send("Hello WebSocket").is_err() {
            println!("Websocket couldn't queue an initial message.")
        } else {
            println!("Client sent message 'Hello WebSocket'. ")
        }

        // The handler needs to take ownership of out, so we use move
        move |msg| {
            // Handle messages received on this connection
            println!("Client got message '{}'. ", msg);

            // Close the connection
            out.close(CloseCode::Normal)
        }
    }) {
        // Inform the user of failure
        println!("Failed to create WebSocket due to: {:?}", error);
    }
}

服务端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
extern crate ws;

use ws::listen;

fn main() {
    if let Err(error) = listen("127.0.0.1:3012", |out| {

        // The handler needs to take ownership of out, so we use move
        move |msg| {

            // Handle messages received on this connection
            println!("Server got message '{}'. ", msg);

            // Use the out channel to send messages back
            out.send(msg)
        }

    }) {
        // Inform the user of failure
        println!("Failed to create WebSocket due to {:?}", error);
    }
}

协程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
extern crate ws;

use std::thread;
use std::thread::sleep;
use std::time::Duration;

use ws::{connect, listen, CloseCode, Sender, Handler, Message, Result, Error, Handshake};
use tokio::io::{self, AsyncReadExt};
use tokio::time::delay_for;
use tokio::task;

#[tokio::main]
async fn main () {
    struct Server {
        out: Sender,
    }

    impl Handler for Server {

        fn on_message(&mut self, msg: Message) -> Result<()> {
            println!("Server got message '{}'. ", msg);
            self.out.send(msg)
        }

        fn on_close(&mut self, code: CloseCode, reason: &str) {
            println!("WebSocket closing for ({:?}) {}", code, reason);
        }
    }

    struct Client {
        out: Sender,
    }
    impl Handler for Client {
        fn on_open(&mut self, _: Handshake) -> Result<()> {
            println!("on_open connect to ws://127.0.0.1:8080");
            Ok(())
        }
        fn on_message(&mut self, msg: Message) -> Result<()> {
            println!("Got message: {}", msg);
            Ok(())
        }
        fn on_close(&mut self, code: CloseCode, reason: &str) {
            println!("on_close code = {:?}, reason = {}", code, reason);
        }
        fn on_error(&mut self, err: Error) {
            println!("on_error err = {}", err);
        }
    }
    let server = task::spawn(async move {
        listen("127.0.0.1:3012", |out| {

            Server { out: out }

        }).unwrap()
    });

    sleep(Duration::from_millis(10));

    let client = task::spawn(async move {
        connect("ws://127.0.0.1:8080", |out| {
            Client { out: out }
        }).unwrap()
    });

    server.await;
    client.await;

    println!("All done.")
}

多线程

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
extern crate ws;

use std::thread;
use std::thread::sleep;
use std::time::Duration;

use ws::{connect, listen, CloseCode, Sender, Handler, Message, Result, Error, Handshake};

fn main () {
    // Server WebSocket handler
    struct Server {
        out: Sender,
    }

    impl Handler for Server {

        fn on_message(&mut self, msg: Message) -> Result<()> {
            println!("Server got message '{}'. ", msg);
            self.out.send(msg)
        }

        fn on_close(&mut self, code: CloseCode, reason: &str) {
            println!("WebSocket closing for ({:?}) {}", code, reason);
            // self.out.shutdown().unwrap();
        }
    }

    // Server thread
    let server = thread::spawn(move || {
        listen("127.0.0.1:3012", |out| {

            Server { out: out }

        }).unwrap()
    });

    // Give the server a little time to get going
    sleep(Duration::from_millis(10));
    struct Client {
        out: Sender,
    }
    impl Handler for Client {
        fn on_open(&mut self, _: Handshake) -> Result<()> {
            println!("on_open connect to ws://127.0.0.1:8080");
            Ok(())
        }
        fn on_message(&mut self, msg: Message) -> Result<()> {
            println!("Got message: {}", msg);
            Ok(())
        }
        fn on_close(&mut self, code: CloseCode, reason: &str) {
            println!("on_close code = {:?}, reason = {}", code, reason);
        }
        fn on_error(&mut self, err: Error) {
            println!("on_error err = {}", err);
        }
    }
    // Client thread
    let client = thread::spawn(move || {

        connect("ws://127.0.0.1:8080", |out| {
            Client { out: out }
        }).unwrap()

    });

    let _ = server.join();
    let _ = client.join();

    println!("All done.")
}

rust-websocket

GitHub

http://websockets-rs.github.io/rust-websocket/doc/websocket/

https://docs.rs/websocket/0.24.0/websocket/

hhttps://docs.rs/

客户端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
extern crate websocket;

fn main() {
    use websocket::ClientBuilder;
    use websocket::OwnedMessage;
    use websocket::WebSocketError;

    let mut client = ClientBuilder::new("ws://127.0.0.1:8080").unwrap()
                        .connect(None).unwrap();
    // let mut client = ClientBuilder::new("ws://hq.sinajs.cn/wskt?list=s_sh000001").unwrap()
    //                     .connect(None).unwrap();

    for message in client.incoming_messages() {
        match message {
            Ok(s) =>  if s.is_data() {
                println!("{:?}", s)
            },
            Err(e) => continue,
        }

    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
use chrono::prelude::*;
use std::{thread, time};
use tokio::io::{self, AsyncReadExt};
use std::error::Error;
use std::time::Duration;
use tokio::time::delay_for;
use tokio::task;
use websocket::ClientBuilder;
use websocket::OwnedMessage;

#[tokio::main]
async fn main() {
    let mut local: DateTime<Local> = Local::now();
    println!("{}", local);
    let five_seconds = time::Duration::new(5, 0);
    // delay_for(Duration::from_secs(2)).await;
    // delay_for(Duration::from_secs(2)).await;

    let join = task::spawn(async {
        // ...
        delay_for(Duration::from_secs(2)).await;
        println!("hello world!");
    });
    let join2 = task::spawn(async {
        // ...
        delay_for(Duration::from_secs(2)).await;
        println!("hello world!2");
    });
    let join3 = task::spawn(async {
        // ...
        let mut client = ClientBuilder::new("ws://hq.sinajs.cn/wskt?list=s_sh000001").unwrap()
                        .connect(None).unwrap();
        for message in client.incoming_messages() {
            match message {
                Ok(s) =>  if s.is_data() {
                    println!("{:?}", s);
                },
                Err(e) => continue,
            }

        }
        println!("hello world!3");
    });
    join3.await;
    join.await;
    join2.await;
    local = Local::now();
    println!("{}", local);
}

服务端

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
extern crate websocket;

fn main() {    
    use std::thread;
    use websocket::Message;
    use websocket::sync::Server;

    let server = Server::bind("127.0.0.1:1234").unwrap();

    for connection in server.filter_map(Result::ok) {
        // Spawn a new thread for each connection.
        thread::spawn(move || {
            let mut client = connection.accept().unwrap();

            let message = Message::text("Hello, client!");
            let _ = client.send_message(&message);

                // ...
        });
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
use chrono::prelude::*;
use std::{thread, time};
use tokio::io::{self, AsyncReadExt};
use std::error::Error;
use std::time::Duration;
use tokio::time::delay_for;
use tokio::task;
use websocket::ClientBuilder;
use websocket::OwnedMessage;
use websocket::sync::Server;
use websocket::Message;

#[tokio::main]
async fn main() {
    let mut local: DateTime<Local> = Local::now();
    println!("{}", local);
    let five_seconds = time::Duration::new(5, 0);
    // delay_for(Duration::from_secs(2)).await;
    // delay_for(Duration::from_secs(2)).await;

    let join = task::spawn(async {
        // ...
        delay_for(Duration::from_secs(2)).await;
        println!("hello world!");
    });
    let join2 = task::spawn(async {
        // ...
        let server = Server::bind("127.0.0.1:1234").unwrap();

        for connection in server.filter_map(Result::ok) {
            // Spawn a new thread for each connection.
            thread::spawn(move || {
                let mut client = connection.accept().unwrap();

                let message = Message::text("Hello, client!");
                let _ = client.send_message(&message);

                // ...
            });
        }
    });
    let join3 = task::spawn(async {
        // ...
        // let mut client = ClientBuilder::new("ws://hq.sinajs.cn/wskt?list=s_sh000001").unwrap()
        //                 .connect(None).unwrap();
        let mut client = ClientBuilder::new("ws://127.0.0.1:8080").unwrap()
                            .connect_insecure().unwrap();
        for message in client.incoming_messages() {
            match message {
                Ok(s) =>  if s.is_data() {
                    println!("{:?}", s);
                } else if s.is_control() {
                    println!("ping {:?}", s);
                },
                Err(e) => {
                    println!("error: {:?}", e);
                    break;
                },
            }

        }
        println!("hello world!3");
    });
    join3.await;
    join.await;
    join2.await;
    local = Local::now();
    println!("{}", local);
}