Diretório de artigos
prefácio
ws-rs implementa o padrão WebSockets RFC6455 da MIO. Ele permite lidar com várias conexões em um único thread e até gerar novas conexões de cliente no mesmo thread. Isso torna os WebSockets muito rápidos e eficientes em termos de recursos. O design da API abstrai a parte subjacente do protocolo WebSocket, permitindo que os desenvolvedores se concentrem no código do aplicativo sem se preocupar com a consistência do protocolo.
1. Crie um projeto
Antes de tudo, ainda é a velha regra, primeiro crie o projeto necessário para o conteúdo desta edição.Como esta edição é um Websocket de comunicação, dois projetos precisam ser preparados, um servidor e um cliente.
1. Crie um projeto de servidor
cargo new ws_rs_server
Em seguida, adicione as dependências e adicione o seguinte conteúdo ao projeto Cargo.toml, conforme mostrado na figura abaixo
ws = "0.9.2"
env_logger = "0.6"
2. Crie um projeto de cliente
cargo new ws_rs_client
Em seguida, adicione dependências, adicione também as dependências agora,
ws = "0.9.2"
env_logger = "0.6"
2. Escreva o código de teste
1. Servidor
O primeiro é o código da parte do servidor. Para usar esta biblioteca, você precisa introduzirws::listen
use ws::listen;
Em seguida, chame-o no main para realizar a operação de monitoramento, por exemplo
// 监听地址并为每个连接调用闭包
if let Err(error) = listen("127.0.0.1:3012", |out| {
// 处理程序需要获取out的所有权，因此我们使用move
move |msg| {
// 处理在此连接上接收的消息
println!("服务器收到消息 '{}'. ", msg);
// 使用输出通道发送消息
out.send(msg)
}
}) {
// 通知用户故障
println!("创建Websocket失败，原因： {:?}", error);
}
listen precisa passar em dois parâmetros, um é o endereço de escuta e a porta, que é usada aqui 127.0.0.1:3012, e depois é uma função anônima, passando out, obtendo a propriedade, e depois usando palavras-chave para capturar automaticamente outdentro dela , que é o servidor recebeu a notícia, no desenvolvimento do servidor, o processamento principal é esta parte do conteúdo.movemsgmsg
A lógica de processar as mensagens do cliente aqui é muito simples,
- Mensagens de saída recebidas do cliente
- Retorna a mensagem enviada pelo cliente
Ou seja, na verdade é um eco, mas ainda tem uma pequena diferença, esse só retorna uma vez.
2. Cliente
A parte do cliente precisa ser introduzida connectpara se conectar ao servidor e introduzida CloseCodepara fechar a conexão.
use ws::{
connect, CloseCode};
Então ele é mainchamado em primeiro lugar connect, seu método de chamada é o mesmo serverde , você precisa passar em dois parâmetros,listen
- wss connection, por exemplo
ws://127.0.0.1:3012, quews://significa usar o protocolo websocket,127.0.0.1é o endereço ip,3012é a porta, vale ressaltar que deve corresponder ao servidor, caso contrário a conexão falhará - Uma função anônima de fechamento, passada em
out
A função anônima de fechamento do cliente faz principalmente duas coisas,
- enviar mensagem para o servidor
- Lidar com mensagens do servidor
O código de exemplo aqui é o seguinte
// 连接到url并调用闭包
if let Err(error) = connect("ws://127.0.0.1:3012", |out| {
// 将WebSocket打开时要发送的消息排队
if out.send("Hello WebSocket").is_err() {
println!("Websocket无法初始消息排队")
} else {
println!("Client 发送消息 'Hello WebSocket'. ")
}
// 处理程序需要获取out的所有权，因此我们使用move
move |msg| {
// 处理在此连接上接收的消息
println!("Client 收到消息 '{}'. ", msg);
// 关闭连接
out.close(CloseCode::Normal)
}
}) {
// 通知用户故障
println!("Failed to create WebSocket due to: {:?}", error);
}
Como você pode ver, a lógica desse código é,
- Envie
Hello WebSocketprimeiro para o servidor e, ao mesmo tempo, julgue se há um erro no processo de envio. Se houver um erro no envio, ele será enviado.Websocket无法初始消息排队Se o envio for bem-sucedido, ele será exibido na interface do clienteClient 发送消息 'Hello WebSocket'. - Processando mensagens do servidor, você pode ver que isso é muito semelhante ao servidor, após receber a mensagem, output
Client 收到消息 '{}'., que{}é um espaço reservado para a mensagem do servidor, e desconectar o servidor diretamente após receber a mensagem
3. Efeito da operação
executar servidor
executar cliente
Resumir
Nesta edição, você aprendeu o framework de comunicação websocket do Rust ws-rs e escreveu dois pequenos casos oficiais. Através do estudo desta edição, você aprendeu a usar Rust para escrever programas websocket, o que é um marco no desenvolvimento Sim, o programa que você write pode ser usado para transmissão de dados pela Internet, o que faz com que o programa traga uma melhor experiência aos usuários e torne seu programa mais colorido.
código completo
Servidor
use ws::listen;
fn main() {
// 初始化日志
env_logger::init();
// 监听地址并为每个连接调用闭包
if let Err(error) = listen("127.0.0.1:3012", |out| {
// 处理程序需要获取out的所有权，因此我们使用move
move |msg| {
// 处理在此连接上接收的消息
println!("服务器收到消息 '{}'. ", msg);
// 使用输出通道发送消息
out.send(msg)
}
}) {
// 通知用户故障
println!("创建Websocket失败，原因： {:?}", error);
}
}
cliente
use ws::{
connect, CloseCode};
fn main() {
// 初始化日志
env_logger::init();
// 连接到url并调用闭包
if let Err(error) = connect("ws://127.0.0.1:3012", |out| {
// 将WebSocket打开时要发送的消息排队
if out.send("Hello WebSocket").is_err() {
println!("Websocket无法初始消息排队")
} else {
println!("Client 发送消息 'Hello WebSocket'. ")
}
// 处理程序需要获取out的所有权，因此我们使用move
move |msg| {
// 处理在此连接上接收的消息
println!("Client got message '{}'. ", msg);
// 关闭连接
out.close(CloseCode::Normal)
}
}) {
// 通知用户故障
println!("Failed to create WebSocket due to: {:?}", error);
}
}
Criei 一起学Rustuma comunidade e convido os amigos interessados em ferrugem a se juntarem .
http://t.csdn.cn/AsEZ9