Redis-Client für Rust: Überblick über die Bibliothek redis-rs

Redis-Client für Rust: die Bibliothek redis-rs

Die Bibliothek redis-rs ist der wichtigste und beliebteste Client für die Arbeit mit Redis im Rust-Ökosystem. Sie bietet einen vollständigen Satz von Funktionen für die Interaktion mit Redis: von einfachen GET/SET-Befehlen bis hin zu komplexen Transaktionen, Pipelines und Pub/Sub. Dank der Unterstützung sowohl synchroner als auch asynchroner (async/await) Modi eignet sich redis-rs für jedes Projekt – von Skripten bis hin zu hochbelasteten Webservern.

Die Bibliothek ist in reinem Rust geschrieben, nutzt sichere Speicherverwaltung und Typsicherheit, was Laufzeitfehler minimiert. Alle gängigen Redis-Datentypen werden unterstützt: Strings, Listen, Sets, Hashes, sortierte Sets, Bitmaps, HyperLogLog und Streams.

Installation und Einbindung

Fügen Sie die Abhängigkeit in Ihre Cargo.toml-Datei ein:

[dependencies]redis = { version = "0.27", features = ["tokio-comp"] }

Für die synchrone Nutzung reicht einfach redis = "0.27". Für asynchrone Nutzung wählen Sie einen der Executors: tokio-comp (Standard) oder async-std-comp.

Grundlegende Verwendung (synchroner Modus)

Beispiel für die Verbindung zu einem lokalen Redis und die Ausführung einfacher Befehle:

use redis::Commands;

fn main() -> redis::RedisResult<()> {    let client = redis::Client::open("redis://127.0.0.1:6379/")?;    let mut con = client.get_connection()?;

    con.set("my_key", "hello world")?;    let value: String = con.get("my_key")?;    println!("Erhaltener Wert: {}", value);

    // Arbeiten mit Hashes    con.hset("user:1", "name", "Alice")?;    con.hset("user:1", "age", "30")?;    let name: String = con.hget("user:1", "name")?;    println!("Benutzername: {}", name);

    Ok(())}

Beachten Sie die automatische Deserialisierung: Sie geben den Typ an, in den das Ergebnis konvertiert werden soll (String, i32, Vec<String> usw.), und die Bibliothek erledigt den Rest.

Asynchroner Modus mit Tokio

Für leistungsstarke Anwendungen verwenden Sie die asynchrone API:

use redis::AsyncCommands;use tokio;

#[tokio::main]async fn main() -> redis::RedisResult<()> {    let client = redis::Client::open("redis://127.0.0.1:6379/")?;    let mut con = client.get_multiplexed_async_connection().await?;

    // Setzen mit TTL (Lebensdauer des Schlüssels)    con.set_ex("temp_key", "temporärer Wert", 60).await?;    let val: Option<String> = con.get("temp_key").await?;    println!("Wert: {:?}", val);

    // Arbeiten mit Listen    con.lpush("queue", "task1").await?;    con.lpush("queue", "task2").await?;    let tasks: Vec<String> = con.lrange("queue", 0, -1).await?;    println!("Aufgaben in der Warteschlange: {:?}", tasks);

    Ok(())}

Der asynchrone Client verwendet multiplexierte Verbindungen (ein TCP-Socket für viele Anfragen), was die Leistung erheblich steigert.

Erweiterte Funktionen

Pipelines (Pipeline-Verarbeitung)

Ermöglicht das Senden mehrerer Befehle in einem einzigen Netzwerkaufruf, was Batch-Operationen beschleunigt:

use redis::pipe;

fn main() -> redis::RedisResult<()> {    let client = redis::Client::open("redis://127.0.0.1:6379/")?;    let mut con = client.get_connection()?;

    let (val1, val2): (i32, i32) = redis::pipe()        .cmd("INCR").arg("counter_a").ignore()        .cmd("INCR").arg("counter_b").ignore()        .cmd("GET").arg("counter_a").query(&mut con)?        .cmd("GET").arg("counter_b").query(&mut con)?;

    println!("Zähler: {}, {}", val1, val2);    Ok(())}

Pub/Sub (Publisher-Subscriber)

Beispiel für das Abonnieren von Kanälen:

use redis::pubsub::PubSubCommands;

fn main() -> redis::RedisResult<()> {