Learn Rust Coding · Lekcja

JSON i stan

Współdzielony stan i serializacja

JSON i stan to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Zwracanie JSON

Axum ułatwia zwracanie odpowiedzi JSON. Owiń dowolny typ implementujący Serialize w Json, a Axum ustawi typ zawartości i zserializuje ciało.

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

Serializowanie kolekcji

Vec elementów, które można serializować, staje się tablicą JSON. Nie trzeba wykonywać żadnych dodatkowych czynności.

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

Modelowanie JSON w zwykłym Rust

Serializacja JSON polega po prostu na zamianie struktury w ciąg znaków. W serde_json wywołuje się to_string. Oto ta idea przedstawiona przy użyciu ręcznego formatowania.

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

Czym jest współdzielony stan?

Współdzielony stan to dane, do których każdy handler może uzyskać dostęp, takie jak pula połączeń z bazą danych lub konfiguracja. Axum przekazuje je za pomocą extractora State.

Definiowanie stanu aplikacji

Zdefiniuj strukturę przechowującą współdzielone dane. Często owija ona Arc, aby klonowanie było tanie.

use std::sync::Arc;

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

Dołączanie stanu do routera

Przekaż stan do with_state. Axum przechowuje go i udostępnia handlerom, które o niego poproszą.

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

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

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

Odczytywanie stanu w handlerze

Dodaj parametr State, aby otrzymać kopię stanu wewnątrz handlera.

use axum::extract::State;

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

Zmienny współdzielony stan

Dane, które się zmieniają, zabezpiecz blokadą, taką jak Mutex, umieszczoną za Arc. Umożliwia to bezpieczną równoczesną modyfikację.

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

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

Modyfikowanie danych za Mutex

Zablokuj mutex, zmodyfikuj wartość, a następnie pozwól na usunięcie strażnika. Ten przykład, który można uruchomić, odzwierciedla zwiększenie wartości wykonywane przez 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());
}

Przyjmowanie i odsyłanie JSON

Połącz wejściowy i wyjściowy JSON: zdeserializuj ciało, przekształć je i zwróć JSON. To typowy wzorzec utworzenia zasobu, a następnie udzielenia odpowiedzi.

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

Podstan z FromRef

Gdy stan zawiera kilka elementów, wyprowadź FromRef, aby handlery mogły wyodrębniać tylko potrzebną im część.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Szybkie sprawdzenie

Sprawdź swoją wiedzę o JSON i stanie.

Podsumowanie

Poznałeś JSON i współdzielony stan:

Owijaj typy implementujące Serialize w Json, aby zwracać odpowiedzi
Definiuj strukturę stanu implementującą Clone, często opakowaną w Arc
Dołączaj ją za pomocą with_state, a odczytuj przez State
Używaj Arc<Mutex> dla zmiennych współdzielonych danych, a FromRef dla podstanów

Dalej: middleware z warstwami tower.

Często zadawane pytania

Czy lekcja „JSON i stan” jest bezpłatna?

Tak — pełny tekst „JSON i stan” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.

Co nauczysz się w „JSON i stan”?

Współdzielony stan i serializacja Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?

Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.

Ile czasu zajmuje lekcja „JSON i stan”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?

Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Learn Rust Coding