Lær at programmere i Rust · Lektion

JSON og state

Delt state og serialisering

Lektion 3 af 413 trin

JSON og state er en gratis Lær at programmere i Rust-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lær at programmere i Rust, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Returnering af JSON

Axum gør JSON-svar nemme. Pak enhver Serialize-type ind i Json, så angiver den indholdstypen og serialiserer brødteksten.

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

Serialisering af samlinger

En Vec med serialiserbare elementer bliver til et JSON-array. Der kræves ikke yderligere arbejde.

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

Modellering af JSON i almindelig Rust

JSON-serialisering er blot at omdanne en struktur til en streng. Med serde_json kalder du to_string. Her vises idéen med manuel formatering.

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

Hvad er delt tilstand?

Delt tilstand er data, som alle håndteringsfunktioner kan få adgang til, f.eks. en databasepulje eller konfiguration. Axum fører den igennem med State-udtrækkeren.

Definition af appens tilstand

Definér en struktur, der indeholder dine delte data. Ofte omslutter den en Arc, så kloning er billig.

use std::sync::Arc;

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

Tilknytning af tilstand til routeren

Giv tilstanden til with_state. Axum gemmer den og stiller den til rådighed for håndteringsfunktioner, der anmoder om den.

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æsning af tilstand i en håndteringsfunktion

Tilføj en State-parameter for at modtage en klon af din tilstand inde i håndteringsfunktionen.

use axum::extract::State;

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

Foranderlig delt tilstand

Data, der ændrer sig, skal beskyttes med en lås som Mutex bag en Arc. Det giver sikker samtidig ændring.

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

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

Ændring bag en Mutex

Lås mutexen, modificér værdien, og lad derefter låsevagten blive frigivet. Dette kørbare eksempel afspejler den forøgelse, en håndteringsfunktion ville udføre.

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

Modtagelse og gentagelse af JSON

Kombinér JSON-input og -output: deserialisér brødteksten, transformér den, og returnér JSON. Det er et almindeligt mønster, hvor du opretter noget og derefter svarer.

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

Deltilstand med FromRef

Når tilstanden indeholder flere dele, kan du udlede FromRef, så håndteringsfunktioner kun kan udtrække den del, de har brug for.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Hurtigt tjek

Test din forståelse af JSON og tilstand.

Besvar den i den interaktive lektion

Opsummering

Du har lært om JSON og delt tilstand:

Pak Serialize-typer ind i Json for at sende svar
Definér en Clone-tilstandsstruktur, som ofte omslutter Arc
Tilknyt den med with_state, og læs den med State
Brug Arc<Mutex> til foranderlige delte data og FromRef til deltilstande

Næste trin: middleware med tower-lag.

Gratis at komme i gang

Lær Rust med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 39
Lektioner: 144

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “JSON og state” gratis?

Ja — alle 3 lektioner i læringssporet Lær at programmere i Rust, inklusive “JSON og state”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lær at programmere i Rust-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “JSON og state”?

Delt state og serialisering Du øver dig i Lær at programmere i Rust med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lær at programmere i Rust?

Der kræves ingen tidligere erfaring. Lær at programmere i Rust på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “JSON og state”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lær at programmere i Rust-lektion?

Ja. Alle Lær at programmere i Rust-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lær at programmere i Rust