rust 使用tokio实现socket多人聊天

最新推荐文章于 2024-04-29 08:57:11 发布
最新推荐文章于 2024-04-29 08:57:11 发布
阅读量3.5k 收藏 16
点赞数 6
分类专栏： rust 文章标签： rust 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24682855/article/details/126112211
版权

首先我们实现多人聊天，首先要有服务端和客户端，
在这里插入图片描述

服务端只有一个，客户端有很多个，看上面的图，客户端1如果要给客户端2 3 4 发送一条消息，首先需要发送给服务端，然后转发给其余的3个客户端，明白了他们之前发送消息的流程，下面我们实现服务端，

//创建监听ip和端口
let addr = "127.0.0.1:5555".parse().unwrap();
//创建tcpSocket
let socket = TcpSocket::new_v4().unwrap();
//socket绑定地址
let _ = socket.bind(addr);
//socket开始监听
let listen = socket.listen(1024).unwrap();
//创建通道
let (tx,_rx) = tokio::sync::broadcast::channel(1024);

然后使用accept()等待客户端连接，客户端连接成功后处理消息和发送消息，因为是有很多个客户端所以使用loop循环进行监听
//等待客户端连接

let (mut tcp_stream,_) = listen.accept().await.unwrap();

如果有客户端连接到服务端，后面会处理消息和发送消息。

loop {
        //等待客户端的连接
        let (mut tcp_stream,_) = listen.accept().await.unwrap();

        let tx = tx.clone();
        let mut rx = tx.subscribe();
        //启动线程
        tokio::spawn(async move{
            //循环处理事件
            loop {
                //只要是返回一个就接结束等待的其他线程
                tokio::select! {
                    //处理消息
                    result = process(&mut tcp_stream,&tx) => {
                        //如果出现异常结束循环
                        if !result {
                            break;
                        }
                    }
                    //发送消息
                    result = rx.recv() => {
                        let (msg,addr) = result.unwrap();
                        //判断给除了自己的客户端发送消息
                        if addr != tcp_stream.peer_addr().unwrap(){
                            let _ = tcp_stream.write_all(msg.as_bytes()).await; 
                        } 
                    }
                }
            }
            //获取客户端地址
            let ip = tcp_stream.peer_addr().unwrap();
            println!("{:?}:断开连接",ip);
        });
        
    }
    ```
处理消息的方法
```rust
async fn process(tcp_stream:&mut TcpStream,tx: &Sender<(String,SocketAddr)>)-> bool{
    let (mut read_half,_write_half) = tcp_stream.split();
    
    let mut buf = vec![0;1024];
    
    //读取消息
    match read_half.read_buf(&mut buf).await {
        
        Ok(_n) => {
            //转换字符串
            let res = String::from_utf8(buf).unwrap();
            //println!("size:{},content:{}",n,res);
            let peer_addr = tcp_stream.peer_addr().unwrap();
            //通过通道发送
            tx.send((res,peer_addr)).unwrap();
            return true;
        }
        Err(err) => {   
            println!("err : {:?}",err);
            return false;
        }
    }
}

接下来编写客户端
客户端主要是接收服务端的消息和给服务端发送消息，我们给客户端开启一个线程用来接收消息，用loop循环给服务端发送消息。
首先是连接socket

let socket = TcpSocket::new_v4().unwrap();
let addr = "127.0.0.1:5555".parse().unwrap();
let mut tcp_stream = socket.connect(addr).await.unwrap();

连接socket成功后处理消息

//这个地方是因为下面线程中使用后他自动推导不出类型，所以在这个地方添加一个空的字符串
tx.send(String::new()).unwrap();
//开启线程处理消息和给服务端发送消息
tokio::spawn(async move {
    loop {
        let (mut read_half,mut write_half) = tcp_stream.split();
        let mut buf = vec![0;1024];
        tokio::select! {
            //读取服务端的消息
            result = read_half.read_buf(&mut buf) => {
                match result {
                    Ok(num) => {
                        //这个地方是因为每次接收到消息，总是会出现空消息，如果接收到不是空消息就不是1024大小
                        if num != 1024 {
                            //转换字符
                            let content = String::from_utf8(buf).unwrap();
                            //输出消息
                            print!("size = {},receive = {}",num,content);
                        }
                    }
                    Err(err) => {
                        println!("服务器连接断开！err={:?}",err);
                        //如果服务端断开则退出程序
                        std::process::exit(0);
                    }
                }

            }
            //读取通道的消息发送给服务端
            result = rx.recv() => {
                let send = result.unwrap();
                //发送给服务端
                let _ = write_half.write_all(send.as_bytes()).await;
                let _ = write_half.flush();
            }
        }
    }
});

loop循环读取控制台文字

loop {
    //创建string
    let mut send = String::new();
    //读取控制台文字
    std::io::stdin().read_line(&mut send).unwrap();
    //通过通道发送
    tx.send(send).unwrap();
}

完整的服务端代码

[dependencies]
tokio = { version = "1", features = ["full"] }
use std::net::SocketAddr;
use tokio::sync::broadcast::{Sender};

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

async fn process(tcp_stream:&mut TcpStream,tx: &Sender<(String,SocketAddr)>)-> bool{
    let (mut read_half,_write_half) = tcp_stream.split();
    
    let mut buf = vec![0;1024];
    
    //读取消息
    match read_half.read_buf(&mut buf).await {
        
        Ok(_n) => {
            //转换字符串
            let res = String::from_utf8(buf).unwrap();
            //println!("size:{},content:{}",n,res);
            let peer_addr = tcp_stream.peer_addr().unwrap();
            //通过通道发送
            tx.send((res,peer_addr)).unwrap();
            return true;
        }
        Err(err) => {   
            println!("err : {:?}",err);
            return false;
        }
    }
}


#[tokio::main]
async fn main() -> Result<(),Error> {
    
    println!(r"
    _                                  
_ __ _   _ ___| |_   ___  ___ _ ____   _____ _ __ 
| '__| | | / __| __| / __|/ _ \ '__\ \ / / _ \ '__|
| |  | |_| \__ \ |_  \__ \  __/ |   \ V /  __/ |   
|_|   \__,_|___/\__| |___/\___|_|    \_/ \___|_|   
                                     ");

   

    let addr = "127.0.0.1:5555".parse().unwrap();

    let socket = TcpSocket::new_v4().unwrap();
    let _ = socket.bind(addr);
    let listen = socket.listen(1024).unwrap();

    println!("服务启动成功,端口:5555");

    let (tx,_rx) = tokio::sync::broadcast::channel(1024);

    loop {
        //等待客户端的连接
        let (mut tcp_stream,_) = listen.accept().await.unwrap();

        let tx = tx.clone();
        let mut rx = tx.subscribe();
        //启动线程
        tokio::spawn(async move{
            //循环处理事件
            loop {
                //只要是返回一个就接结束等待的其他线程
                tokio::select! {
                    //处理消息
                    result = process(&mut tcp_stream,&tx) => {
                        //如果出现异常结束循环
                        if !result {
                            break;
                        }
                    }
                    //发送消息
                    result = rx.recv() => {
                        let (msg,addr) = result.unwrap();
                        //判断给除了自己的客户端发送消息
                        if addr != tcp_stream.peer_addr().unwrap(){
                            let _ = tcp_stream.write_all(msg.as_bytes()).await; 
                        } 
                    }
                }
            }
            //获取客户端地址
            let ip = tcp_stream.peer_addr().unwrap();
            println!("{:?}:断开连接",ip);
        });
        
    }
}

完整的客户端代码

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

use tokio::io::AsyncReadExt;
use tokio::{net::TcpSocket, io::AsyncWriteExt};
use tokio::sync::broadcast::{self};


#[tokio::main]
async fn main() {

    println!(r"
    _          _ _            _   
_ __ _   _ ___| |_    ___| (_) ___ _ __ | |_ 
| '__| | | / __| __|  / __| | |/ _ \ '_ \| __|
| |  | |_| \__ \ |_  | (__| | |  __/ | | | |_ 
|_|   \__,_|___/\__|  \___|_|_|\___|_| |_|\__|");

    let socket = TcpSocket::new_v4().unwrap();
    let addr = "127.0.0.1:5555".parse().unwrap();
    let mut tcp_stream = socket.connect(addr).await.unwrap();
    
    println!("连接成功：{:?}",addr);

    let (tx,mut rx) = broadcast::channel(1024);
    
    //这个地方是因为下面线程中使用后他自动推导不出类型，所以在这个地方添加一个空的字符串
    tx.send(String::new()).unwrap();
    //开启线程处理消息和给服务端发送消息
    tokio::spawn(async move {
        loop {
            let (mut read_half,mut write_half) = tcp_stream.split();
            let mut buf = vec![0;1024];
            tokio::select! {
                //读取服务端的消息
                result = read_half.read_buf(&mut buf) => {
                    match result {
                        Ok(num) => {
                            //这个地方是因为每次接收到消息，总是会出现空消息，如果接收到不是空消息就不是1024大小
                            if num != 1024 {
                                //转换字符
                                let content = String::from_utf8(buf).unwrap();
                                //输出消息
                                print!("size = {},receive = {}",num,content);
                            }
                        }
                        Err(err) => {
                            println!("服务器连接断开！err={:?}",err);
                            //如果服务端断开则退出程序
                            std::process::exit(0);
                        }
                    }
                    
                }
                //读取通道的消息发送给服务端
                result = rx.recv() => {
                    let send = result.unwrap();
                    //发送给服务端
                    let _ = write_half.write_all(send.as_bytes()).await;
                    let _ = write_half.flush();
                }
            }
        }
    });
    loop {
        //创建string
        let mut send = String::new();
        //读取控制台文字
        std::io::stdin().read_line(&mut send).unwrap();
        //通过通道发送
        tx.send(send).unwrap();
    }
}

github-client：socket-client
github-server：socket-server

若梦网络编程
关注
  • 6
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
rust 基于 tokio protobuf tls websocket demo 版 chat server
02-22
rust 基于tokio-websockets actor tls demo chat server(websocket) 聊天服务器，全异步实现，使用protobuf协议，所属分类 后端没有rust 这里只好下载c++
rsocket-rust:使用Tokio的RSocket Rust实现
05-09
rsocket-rust是Rust（1.39+）中RSocket协议的实现。 它是Alpha版本，仍在积极开发中。 不要在生产环境中使用它！ 例子 以下是一些示例代码，这些代码显示RSocket在Rust中的工作方式。 依存关系 在Cargo.toml添加...
使用Rust搭建一个简单的聊天室(一) | “不得不学的编程语言——Rust”
陈某狗
06-11 3615
Rust聊天室   这篇文章，我将带大家使用Rust来搭建一个简单的聊天室。这个聊天室我们分两部分来实现：服务端和客户端； 一、服务端 二、客户端
136、Rust与WebSocket：实现实时通信的利器
最新发布
silenceallat的博客
04-29 1343
本文介绍了WebSocket协议及如何在Rust语言中实现WebSocket通信。WebSocket协议支持全双工通信，广泛应用于实时通信场景。Rust以其出色的性能和安全性，成为实现高效WebSocket服务的理想选择。文章涵盖了WebSocket服务器的创建、客户端的实现、消息的发送与接收，以及高级功能如身份验证、消息加密等。通过实例和技巧，本文旨在帮助读者掌握WebSocket通信，并在Rust中实现实时互动。
Rust websocket 客户端实现
生活是个圈的博客
06-16 2903
目前rust websocket文档较少，最近为了实现部分工作需要使用rust去做websocket链接网上找了不少，很多没有太多参考价值，websocket 在rust中要保持长连接，期间需要不停的去ping，不然会中断，但是使用线程在常规情况下闭包又无法在循环数据的时候持续的ping，所以引入了一下第三方包。 ...
听GPT 讲Rust Tokio源代码(10)
techdashen的博客
01-13 904
该结构体包括了一个Id字段表示任务的唯一标识符，一个Status字段表示任务的状态（包括Running、Blocked等），一个Name字段表示任务的名称，一个Loc字段表示任务对应的源代码位置，一个SubTasks字段表示任务的子任务（Task列表），以及一些其他与任务有关的字段。宏的作用是用于生成一个线程本地存储的“全局变量”，每个线程内都有一个该变量的副本，而不同线程之间的副本是相互隔离的。当有任务完成时，宏会根据完成的任务的分支，执行对应的逻辑代码块，并返回对应的。
rust学习（tokio中tcp_stream调用的问题）
一个白馒头的专栏
04-08 365
我们涉及了一个socket连接的类，每次收到数据以后，我们都会把tokio::net::TcpStream对应的tcp_stream传递给其他线程。2.由于线程1一直在等数据，所以线程2只能在这里2处卡住。1.stream直接move给TarNetStream。2.回调函数中采用了Arc智能指针。1.没有数据，这里卡死。
004 Rust 网络编程，使用 SocketAddr
令狐一冲
05-02 1271
介绍 SocketAddr定义如下： pub enum SocketAddr { V4(SocketAddrV4), V6(SocketAddrV6), } 使用示例 SocketAddr中提供了一些方法，使用如下： use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; fn main() { let mut s...
rust-tokio-retry:Futurestokio的可扩展异步重试行为
05-07
tokio-retry = " 0.3 " 例子 use tokio_retry :: Retry; use tokio_retry :: strategy :: {ExponentialBackoff, jitter}; async fn action () -> Result < u64> { // do some real-world stuff here... Err (()) }...
nano-rs：使用Tokio在Rust中实现Nano
02-05
【nano-rs：使用Tokio在Rust中实现Nano】是一个开源项目，旨在用Rust编程语言重构Nano（原名Raiblocks）这种去中心化的加密货币。Nano以其独特的架构和近乎即时的交易速度而闻名，它采用了工作量证明（Proof-of-Work...
tk-http：用于rusttokio的全功能HTTP和Websockets库
02-03
tk-http：用于rusttokio的全功能HTTP和Websockets库
tungstenite-rs, 基于轻量级流的Rust web socket实现.zip
10-09
tungstenite-rs, 基于轻量级流的Rust web socket实现 Tungstenite基于轻量级流的 Rust web socket实现。use std::net::TcpListener;use std::thread::spawn;use tungstenite::ser
rust-socketio:用Rust编程语言编写的socket.io客户端的实现
03-13
Rust-socketio客户端 用Rust编程语言编写的socket.io客户端的实现。 此实现当前支持socket.io协议的修订版5，因此支持engine.io协议的修订版4。 如果与此客户端有任何连接问题，请确保服务器至少使用engine.io协议的修订版4。 用法示例 use rust_socketio :: {SocketBuilder, Payload, Socket}; use serde_json :: json; use std :: time :: Duration; // define a callback which is called when a payload is received // this callback gets the payload as well as an instance of the // socket to communicate
rust-http2:Rusttokio中的HTTP2实现
05-03
基于tokio的Rust中的HTTP / 2客户端和服务器实现。 当前，它用作实现。 示例服务器 签出源代码并执行命令： cargo run --example server 服务器将在上可用。 您需要任何具有HTTP / 2支持的现代浏览器来打开页面...
Rust之Websocket 服务端【Warp】
每天进步一点点
08-25 2130
【代码】Rust之Websocket【Warp】
Socket网络编程之组播实现（C++，Rust）
热门推荐
让我思考一下
07-11 1万+
实际项目中，经常需要使用组播，本文给出了组播代码示例......
Tokio学习
笨笨D幸福 - 后花园
02-23 2614
Tokio 学习 原本想直接学习Actix-Web，一层层看下来，发现内容太多，杂乱，没有目的。所以，一层层剥下来，最终落脚到Tokio上，现在先了解Tokio的相关内容，最终学习Actix相关内容。 Tokio是Rust的一个异步编程库，它是一个事件驱动，使用非阻塞IO编写异步程序的库。总的来说，有几个特点： 多线程、基于调度的任务窃取(work-stealing) 一个reactor后端，通...
【投稿】刀哥：Rust学习笔记 5
Rust语言学习交流
08-30 502
@[TOC](Rust 学习心得＜5＞：异步代码的几种写法)Rust历史不长，仍然处于快速发展的历程中。关于异步编程的模式，现在已经发展到async/await协程的高级阶段。大概是因为...
rust实现socket通信
04-27
好的，我来给您介绍一下如何使用 Rust 语言进行 socket 通信。 首先，您需要在 Cargo.toml 文件中添加以下依赖： ```toml [dependencies] tokio = { version = "0.2", features = ["full"] } ``` 然后，您可以在 Rust 代码中使用以下代码来创建一个 socket 连接： ```rust use tokio::net::TcpStream; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let stream = TcpStream::connect("127.0.0.1:8080").await?; println!("Connected to the server!"); Ok(()) } ``` 如果要发送数据，您可以使用 tokio 库中的 `tokio::io::AsyncWriteExt` trait 中的 `write_all` 函数。例如： ```rust use tokio::io::AsyncWriteExt; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let mut stream = TcpStream::connect("127.0.0.1:8080").await?; let data = b"hello world"; stream.write_all(data).await?; Ok(()) } ``` 如果要接收数据，您可以使用 tokio 库中的 `tokio::io::AsyncReadExt` trait 中的 `read_exact` 函数。例如： ```rust use tokio::io::{AsyncReadExt, AsyncWriteExt}; #[tokio::main] async fn main() -> Result<(), Box<dyn std::error::Error>> { let mut stream = TcpStream::connect("127.0.0.1:8080").await?; let mut buffer = [0; 1024]; stream.read_exact(&mut buffer).await?; println!("Received data: {:?}", &buffer[..]); Ok(()) } ``` 希望这些信息能帮到您！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

若梦网络编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值