Leer programmeren met Rust · Les

JSON en state

Gedeelde state en serialisatie

Les 3 van 413 stappen

JSON en state is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

JSON teruggeven

Axum maakt JSON-antwoorden eenvoudig. Wikkel elk type dat Serialize implementeert in Json; dit stelt het inhoudstype in en serialiseert de hoofdtekst.

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() })
}

Verzamelingen serialiseren

Een Vec met serialiseerbare items wordt een JSON-array. Er is geen extra werk nodig.

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 modelleren in gewone Rust

JSON-serialisatie is gewoon een structuur omzetten naar een tekenreeks. Met serde_json roept u to_string aan. Hier ziet u het idee met een handmatige indeling.

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));
}

Wat is gedeelde toestand?

Gedeelde toestand zijn gegevens waartoe elke afhandelingsfunctie toegang heeft, zoals een databasepool of configuratie. Axum geeft deze door met de extractor State.

De toestand van de applicatie definiëren

Definieer een structuur die uw gedeelde gegevens bevat. Vaak wikkelt deze een Arc in, zodat klonen goedkoop is.

use std::sync::Arc;

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

Toestand aan de router koppelen

Geef de toestand door aan with_state. Axum slaat deze op en geeft hem aan afhandelingsfuncties die erom vragen.

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

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

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

Toestand in een afhandelingsfunctie lezen

Voeg een parameter van het type State toe om binnen de afhandelingsfunctie een kloon van uw toestand te ontvangen.

use axum::extract::State;

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

Veranderlijke gedeelde toestand

Bescherm gegevens die veranderen met een vergrendeling, zoals Mutex achter een Arc. Zo zijn gelijktijdige wijzigingen veilig.

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

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

Wijzigen achter een Mutex

Vergrendel de mutex, wijzig de waarde en laat vervolgens de bewaker vallen. Dit uitvoerbare voorbeeld bootst de verhoging na die een afhandelingsfunctie zou uitvoeren.

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 ontvangen en terugsturen

Combineer JSON-invoer en -uitvoer: deserialiseer de hoofdtekst, verwerk deze en geef JSON terug. Dit is een veelgebruikt patroon waarbij u iets aanmaakt en daarna een antwoord geeft.

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) })
}

Subtoestand met FromRef

Wanneer de toestand meerdere onderdelen bevat, kunt u FromRef afleiden zodat afhandelingsfuncties alleen het benodigde onderdeel kunnen extraheren.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Korte controle

Test uw begrip van JSON en toestand.

Beantwoord dit in de interactieve les

Samenvatting

U hebt JSON en gedeelde toestand geleerd:

Wikkel typen die Serialize implementeren in Json om te antwoorden
Definieer een toestandstructuur met Clone, vaak met een ingepakte Arc
Koppel deze met with_state en lees deze met State
Gebruik Arc<Mutex> voor veranderlijke gedeelde gegevens en FromRef voor subtoestanden

Volgende: middleware met tower-lagen.

Gratis beginnen

Leer Rust met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “JSON en state” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “JSON en state”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

Wat leer ik in “JSON en state”?

Gedeelde state en serialisatie Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “JSON en state”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Leer programmeren met Rust