Learn Rust Coding · Lektion

JSON und State

Gemeinsamer State und Serialisierung

JSON und State ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

JSON zurückgeben

Mit Axum lassen sich JSON-Responses einfach erstellen. Umschließen Sie jeden Typ, der Serialize implementiert, mit Json; dadurch werden der Content-Type gesetzt und der Body serialisiert.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct User { id: u32, name: String }

async fn get_user() -> Json<User> {
    Json(User { id: 1, name: "Alice".into() })
}

Collections serialisieren

Ein Vec serialisierbarer Elemente wird zu einem JSON-Array. Es ist keine zusätzliche Arbeit erforderlich.

use axum::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Item { id: u32 }

async fn list() -> Json<Vec<Item>> {
    Json(vec![Item { id: 1 }, Item { id: 2 }])
}

JSON in einfachem Rust modellieren

JSON-Serialisierung bedeutet einfach, ein Struct in eine Zeichenkette umzuwandeln. Mit serde_json rufen Sie to_string auf. Hier sehen Sie die Idee anhand eines manuellen Formats.

struct User { id: u32, name: String }

fn to_json(u: &User) -> String {
    format!("{{\"id\":{},\"name\":\"{}\"}}", u.id, u.name)
}

fn main() {
    let u = User { id: 1, name: "Alice".to_string() };
    println!("{}", to_json(&u));
}

Was ist gemeinsamer Zustand?

Gemeinsamer Zustand sind Daten, auf die jeder Handler zugreifen kann, etwa ein Datenbankpool oder eine Konfiguration. Axum stellt sie über den Extractor State bereit.

Anwendungszustand definieren

Definieren Sie ein Struct, das Ihre gemeinsamen Daten enthält. Häufig umschließt es ein Arc, damit das Klonen kostengünstig ist.

use std::sync::Arc;

#[derive(Clone)]
struct AppState {
    name: Arc<String>,
}

Zustand an den Router anhängen

Übergeben Sie den Zustand an with_state. Axum speichert ihn und stellt ihn Handlern bereit, die ihn anfordern.

use axum::{Router, routing::get};

async fn handler() -> &'static str { "ok" }

fn app(state: AppState) -> Router {
    Router::new().route("/", get(handler)).with_state(state)
}

Zustand in einem Handler lesen

Fügen Sie einen State-Parameter hinzu, um innerhalb des Handlers eine Kopie Ihres Zustands zu erhalten.

use axum::extract::State;

async fn handler(State(state): State<AppState>) -> String {
    state.name.to_string()
}

Veränderlicher gemeinsamer Zustand

Schützen Sie veränderliche Daten mit einer Sperre wie Mutex hinter einem Arc. Dadurch sind sichere gleichzeitige Änderungen möglich.

use std::sync::{Arc, Mutex};

#[derive(Clone)]
struct Counter {
    count: Arc<Mutex<u32>>,
}

Hinter einem Mutex ändern

Sperren Sie den Mutex, ändern Sie den Wert, und lassen Sie anschließend den Guard verfallen. Dieses ausführbare Beispiel bildet die Erhöhung nach, die ein Handler durchführen würde.

use std::sync::{Arc, Mutex};

fn main() {
    let count = Arc::new(Mutex::new(0u32));
    {
        let mut guard = count.lock().unwrap();
        *guard += 1;
    }
    println!("count = {}", *count.lock().unwrap());
}

JSON annehmen und zurückgeben

Kombinieren Sie JSON-Eingabe und -Ausgabe: Deserialisieren Sie den Body, verarbeiten Sie ihn, und geben Sie JSON zurück. Dies ist ein gängiges Muster zum Erstellen und anschließenden Antworten.

use axum::Json;
use serde::{Serialize, Deserialize};

#[derive(Deserialize)]
struct Input { name: String }
#[derive(Serialize)]
struct Output { greeting: String }

async fn greet(Json(i): Json<Input>) -> Json<Output> {
    Json(Output { greeting: format!("Hi {}", i.name) })
}

Substate mit FromRef

Wenn der Zustand mehrere Bestandteile enthält, leiten Sie FromRef ab, damit Handler nur den benötigten Teil extrahieren können.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

#[derive(Clone, FromRef)]
struct AppState {
    pool: Pool,
}

Kurzer Test

Testen Sie Ihr Verständnis von JSON und Zustand.

Zusammenfassung

Sie haben JSON und gemeinsamen Zustand kennengelernt:

Umschließen Sie Serialize-Typen mit Json, um sie zurückzugeben
Definieren Sie ein Clone-State-Struct, das häufig ein Arc umschließt
Hängen Sie es mit with_state an und lesen Sie es mit State
Verwenden Sie Arc<Mutex> für veränderliche gemeinsame Daten und FromRef für Substates

Als Nächstes folgen Middleware mit Tower-Layern.

Häufig gestellte Fragen

Ist die Lektion „JSON und State“ kostenlos?

Ja — der vollständige Text von „JSON und State“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „JSON und State“?

Gemeinsamer State und Serialisierung Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „JSON und State“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding