Learn Rust Coding · Lezione

JSON e stato

Stato condiviso e serializzazione

JSON e stato è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Restituire JSON

Axum semplifica le risposte JSON. Racchiuda qualsiasi tipo Serialize in Json: il tipo di contenuto viene impostato e il corpo viene serializzato automaticamente.

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

Serializzare le collezioni

Un Vec di elementi serializzabili diventa un array JSON. Non serve altro.

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

Modellare JSON in Rust semplice

La serializzazione JSON consiste semplicemente nel trasformare una struct in una stringa. Con serde_json si chiama to_string. Ecco l'idea usando una formattazione manuale.

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

Che cos'è lo stato condiviso?

Lo stato condiviso è costituito dai dati a cui ogni handler può accedere, come un pool di connessioni al database o la configurazione. Axum lo rende disponibile tramite l'estrattore State.

Definire lo stato dell'app

Definisca una struct che contenga i dati condivisi. Spesso racchiude un Arc, così la clonazione è poco costosa.

use std::sync::Arc;

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

Collegare lo stato al router

Passi lo stato a with_state. Axum lo memorizza e lo fornisce agli handler che lo richiedono.

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

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

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

Leggere lo stato in un handler

Aggiunga un parametro State per ricevere una copia dello stato all'interno dell'handler.

use axum::extract::State;

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

Stato condiviso mutabile

Per i dati che cambiano, li protegga con un lock come Mutex all'interno di un Arc. Questo consente modifiche concorrenti sicure.

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

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

Modificare dati protetti da Mutex

Acquisisca il lock del mutex, modifichi il valore e poi lasci che la guardia venga eliminata. Questo esempio eseguibile riproduce l'incremento che eseguirebbe un handler.

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

Accettare e restituire JSON

Combini input e output JSON: deserializzi il corpo, lo trasformi e restituisca JSON. È un modello comune per creare una risorsa e rispondere.

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

Sotto-stato con FromRef

Quando lo stato contiene più elementi, derivi FromRef per consentire agli handler di estrarre solo la parte necessaria.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Verifica rapida

Verifichi la Sua comprensione di JSON e dello stato.

Riepilogo

Ha imparato a usare JSON e lo stato condiviso:

Racchiuda i tipi Serialize in Json per rispondere
Definisca una struct di stato Clone, spesso con un Arc
La colleghi con with_state e la legga con State
Usi Arc<Mutex> per i dati condivisi mutabili e FromRef per i sotto-stati

Prossimo argomento: middleware con i layer di tower.

Domande Frequenti

La lezione «JSON e stato» è gratuita?

Sì — il testo completo di «JSON e stato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «JSON e stato»?

Stato condiviso e serializzazione Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «JSON e stato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Learn Rust Coding