Lär dig programmera i Rust · Lektion

JSON och tillstånd

Delat tillstånd och serialisering

Lektion 3 av 413 steg

JSON och tillstånd är en gratis lektion i Lär dig programmera i Rust på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lär dig programmera i Rust, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Returnera JSON

Axum gör JSON-svar enkla. Omslut valfri Serialize-typ i Json, så anges innehållstypen och bodyn serialiseras.

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

Serialisera samlingar

En Vec med serialiserbara objekt blir en JSON-array. Inget extra arbete behövs.

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

Modellera JSON i vanlig Rust

JSON-serialisering innebär helt enkelt att omvandla en struct till en sträng. Med serde_json anropar ni to_string. Här visas idén med ett manuellt format.

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

Vad är delat tillstånd?

Delat tillstånd är data som alla handlers kan komma åt, till exempel en databaspool eller konfiguration. Axum förmedlar det med extractorn State.

Definiera appens tillstånd

Definiera en struct som innehåller era delade data. Ofta omsluter den en Arc så att det går snabbt att klona den.

use std::sync::Arc;

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

Koppla tillstånd till routern

Skicka tillståndet till with_state. Axum lagrar det och tillhandahåller det till handlers som begär det.

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

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

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

Läsa tillstånd i en handler

Lägg till en State-parameter för att ta emot en klon av tillståndet i handlern.

use axum::extract::State;

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

Muterbart delat tillstånd

För data som ändras skyddar ni den med ett lås, till exempel Mutex bakom en Arc. Det möjliggör säker samtidig mutation.

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

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

Mutera bakom en Mutex

Lås mutexen, ändra värdet och låt sedan vakten tas bort. Det här körbara exemplet motsvarar den ökning som en handler skulle utföra.

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

Ta emot och återsända JSON

Kombinera JSON för indata och utdata: deserialisera bodyn, omvandla den och returnera JSON. Det är ett vanligt mönster för att skapa och sedan svara.

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

Delat tillstånd med FromRef

När tillståndet innehåller flera delar kan ni härleda FromRef så att handlers bara extraherar den del de behöver.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Snabbkontroll

Testa era kunskaper om JSON och tillstånd.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er om JSON och delat tillstånd:

Omslut Serialize-typer i Json för att svara
Definiera en Clone-bar tillståndsstruct, ofta med en Arc inuti
Koppla den med with_state och läs den med State
Använd Arc<Mutex> för muterbara delade data och FromRef för deltillstånd

Nästa steg: middleware med tower-lager.

Gratis att börja

Lär dig Rust med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 144

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”JSON och tillstånd” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lär dig programmera i Rust, inklusive ”JSON och tillstånd”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lär dig programmera i Rust innehåller totalt 4 lektioner.

Vad lär jag mig i ”JSON och tillstånd”?

Delat tillstånd och serialisering Ni övar på Lär dig programmera i Rust med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lär dig programmera i Rust?

Du behöver inga förkunskaper. Utbildningen i Lär dig programmera i Rust på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”JSON och tillstånd”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lär dig programmera i Rust-lektionen?

Ja. Varje Lär dig programmera i Rust-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lär dig programmera i Rust