WebSocket-Bibliotheken für Rust: Tokio-tungstenite und async-tungstenite für Echtzeit

WebSocket-Bibliotheken für Rust: Tokio-tungstenite und async-tungstenite

In der modernen Webentwicklung ist das WebSocket-Protokoll zum Standard für die Erstellung von Echtzeitanwendungen geworden: Chats, Online-Spiele, Finanzticker und Benachrichtigungssysteme. Das Rust-Ökosystem bietet leistungsstarke und sichere Werkzeuge für die Arbeit mit WebSocket, unter denen sich tokio-tungstenite und async-tungstenite hervorheben. Diese Bibliotheken basieren auf der beliebten asynchronen Laufzeitumgebung Tokio und dem leistungsstarken WebSocket-Stack tungstenite.

Was sind Tokio-tungstenite und async-tungstenite?

Tokio-tungstenite ist eine asynchrone WebSocket-Bibliothek für Rust, die in die Laufzeitumgebung Tokio integriert ist. Sie bietet praktische Abstraktionen zum Erstellen von WebSocket-Servern und -Clients unter Verwendung der standardmäßigen Tokio-Typen (TcpListener, TcpStream).

Async-tungstenite ist eine allgemeinere Version, die mit jeder asynchronen Laufzeitumgebung (Tokio, async-std, smol) über die Traits AsyncRead und AsyncWrite funktioniert. Beide Bibliotheken bieten vollständige Unterstützung für RFC 6455, einschließlich Nachrichtenfragmentierung, Ping/Pong und Maskierung.

Wichtige Funktionen

• Asynchronität — nicht-blockierende Operationen mit async/await
• Hohe Leistung — minimaler Overhead durch Zero-Copy-Parsing
• Typsicherheit — Nachrichten werden als streng typisierte Strukturen dargestellt
• Flexibilität — Unterstützung sowohl für Server- als auch für Client-Seiten
• SSL/TLS — integrierte Unterstützung für sichere Verbindungen über rustls oder native-tls
• Automatische Verbindungsverwaltung — Behandlung von Verbindungsabbrüchen und Wiederverbindungen

Installation

Fügen Sie in Cargo.toml hinzu:

[dependencies]tokio = { version = "1", features = ["full"] }tokio-tungstenite = "0.21"futures-util = "0.3"

Beispiel: WebSocket-Server

Erstellen wir einen einfachen Echo-Server, der die empfangene Nachricht zurücksendet:

use tokio::net::TcpListener;use tokio_tungstenite::accept_async;use futures_util::{SinkExt, StreamExt};use std::error::Error;

#[tokio::main]async fn main() -> Result<(), Box> {    let listener = TcpListener::bind("127.0.0.1:8080").await?;    println!("WebSocket-Server gestartet auf ws://127.0.0.1:8080");

    while let Ok((stream, addr)) = listener.accept().await {        println!("Neue Verbindung: {}", addr);        tokio::spawn(handle_connection(stream));    }    Ok(())}

async fn handle_connection(stream: tokio::net::TcpStream) {    let ws_stream = accept_async(stream).await.expect("Handshake-Fehler");    let (mut write, mut read) = ws_stream.split();

    while let Some(Ok(msg)) = read.next().await {        if msg.is_text() || msg.is_binary() {            // Sende die Nachricht zurück            if let Err(e) = write.send(msg).await {                eprintln!("Fehler beim Senden: {}", e);                break;            }        }    }    println!("Verbindung geschlossen");}

Beispiel: WebSocket-Client

Verbinden wir uns mit dem Server und senden eine Begrüßung:

use tokio_tungstenite::connect_async;use futures_util::{SinkExt, StreamExt};use url::Url;

#[tokio::main]async fn main() -> Result<(), Box> {    let url = Url::parse("ws://127.0.0.1:8080")?;    let (ws_stream, _) = connect_async(url).await?;    println!("Mit Server verbunden");

    let (mut write, mut read) = ws_stream.split();

    // Sende eine Nachricht    write.send("Hallo, Welt!".into()).await?;    println!("Gesendet: Hallo, Welt!");

    // Lese die Antwort    if let S