Directorio de artículos
prefacio
ws-rs implementa el estándar WebSockets RFC6455 de MIO. Permite manejar múltiples conexiones en un solo hilo e incluso generar nuevas conexiones de clientes en el mismo hilo. Esto hace que WebSockets sea muy rápido y eficiente en recursos. El diseño de la API abstrae la parte subyacente del protocolo WebSocket, lo que permite a los desarrolladores centrarse en el código de la aplicación sin preocuparse por la coherencia del protocolo.
1. Crea un proyecto
En primer lugar, todavía es la regla anterior, primero cree el proyecto requerido para el contenido de este problema. Dado que este problema es un Websocket de comunicación, se deben preparar dos proyectos, un servidor y un cliente.
1. Crear un proyecto de servidor
cargo new ws_rs_server
Luego agregue dependencias y agregue el siguiente contenido al proyecto Cargo.toml, como se muestra en la figura a continuación
ws = "0.9.2"
env_logger = "0.6"
2. Crear un proyecto de cliente
cargo new ws_rs_client
Luego agregue dependencias, también agregue las dependencias ahora mismo,
ws = "0.9.2"
env_logger = "0.6"
2. Escribir código de prueba
1. Servidor
El primero es el código de la parte del servidor. Para usar esta biblioteca, debe introducirws::listen
use ws::listen;
Luego llámelo en main para realizar la operación de monitoreo, por ejemplo
// 监听地址并为每个连接调用闭包
if let Err(error) = listen("127.0.0.1:3012", |out| {
// 处理程序需要获取out的所有权，因此我们使用move
move |msg| {
// 处理在此连接上接收的消息
println!("服务器收到消息 '{}'. ", msg);
// 使用输出通道发送消息
out.send(msg)
}
}) {
// 通知用户故障
println!("创建Websocket失败，原因： {:?}", error);
}
listen necesita pasar dos parámetros, uno es la dirección de escucha y el puerto, que se usa aquí 127.0.0.1:3012, y luego es una función anónima, pasa out, obtiene la propiedad y luego usa palabras clave para capturar automáticamente outdentro de él , que es el servidor recibido La noticia, en el desarrollo del servidor, el procesamiento principal es esta parte del contenido.movemsgmsg
La lógica de procesar los mensajes de los clientes aquí es muy simple,
- Mensajes de salida recibidos del cliente
- Devolver el mensaje enviado por el cliente
En otras palabras, en realidad es un eco, pero todavía hay una pequeña diferencia, esto solo regresa una vez.
2. Cliente
La parte del cliente debe introducirse connectpara conectarse al servidor e introducirse CloseCodepara cerrar la conexión.
use ws::{
connect, CloseCode};
Luego se mainllama, en primer lugar connect, su método de llamada es el mismo que serverel de , debe pasar dos parámetros,listen
- conexión wss, por ejemplo
ws://127.0.0.1:3012, quews://significa usar el protocolo websocket,127.0.0.1es la dirección ip,3012es el puerto, cabe señalar que debe corresponder al servidor, de lo contrario la conexión fallará - Una función anónima de cierre, pasada
out
La función de cierre anónimo del cliente hace principalmente dos cosas,
- enviar mensaje al servidor
- Manejar mensajes del servidor
El código de muestra aquí es el siguiente
// 连接到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 puede ver, la lógica de este código es,
- Envíe
Hello WebSocketprimero al servidor y, al mismo tiempo, juzgue si hay un error en el proceso de envío. Si hay un error en el envío, se enviará. SiWebsocket无法初始消息排队el envío es exitoso, se enviará a la interfaz del cliente.Client 发送消息 'Hello WebSocket'. - Al procesar los mensajes del servidor, puede ver que esto es muy similar al servidor, después de recibir el mensaje, salida
Client 收到消息 '{}'., que{}es un marcador de posición para el mensaje del servidor, y desconecte el servidor directamente después de recibir el mensaje.
3. Efecto de operación
ejecutar servidor
ejecutar cliente
Resumir
En este problema, aprendió el marco de comunicación ws-rs de websocket de Rust y escribió dos pequeños casos oficiales. A través del estudio de este problema, aprendió a usar Rust para escribir programas websocket, lo cual es un hito en el desarrollo. Sí, el programa que write se puede usar para la transmisión de datos a través de Internet, lo que hace que el programa brinde una mejor experiencia a los usuarios y hace que su programa sea más 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);
}
}
Creé 一起学Rustuna comunidad e invito a los amigos que estén interesados en el óxido a unirse .
http://t.csdn.cn/AsEZ9