Learn Rust Coding · Pelajaran

JSON dan State

State bersama dan serialisasi

JSON dan State adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Mengembalikan JSON

Axum memudahkan respons JSON. Bungkus tipe Serialize apa pun dengan Json; Axum akan menetapkan tipe konten dan melakukan serialisasi isi.

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

Melakukan serialisasi koleksi

Vec yang berisi item yang dapat diserialisasi menjadi array JSON. Tidak diperlukan pekerjaan tambahan.

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

Memodelkan JSON dalam Rust biasa

Serialisasi JSON hanyalah mengubah struct menjadi string. Dengan serde_json, Anda memanggil to_string. Berikut gagasannya menggunakan format manual.

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

Apa itu state bersama?

State bersama adalah data yang dapat diakses setiap handler, seperti pool basis data atau konfigurasi. Axum meneruskannya melalui pengekstrak State.

Mendefinisikan state app

Definisikan struct yang menyimpan data bersama Anda. Sering kali struct ini membungkus Arc agar proses kloning lebih murah.

use std::sync::Arc;

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

Melampirkan state ke router

Berikan state kepada with_state. Axum menyimpannya dan menyediakannya kepada handler yang memintanya.

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

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

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

Membaca state dalam handler

Tambahkan parameter State untuk menerima klon state Anda di dalam handler.

use axum::extract::State;

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

State bersama yang dapat diubah

Untuk data yang berubah, lindungi data tersebut dengan lock seperti Mutex di balik Arc. Ini memungkinkan perubahan bersamaan yang aman.

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

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

Mengubah data di balik Mutex

Kunci mutex, ubah nilainya, lalu guard akan dilepas. Contoh yang dapat dijalankan ini meniru penambahan nilai yang dilakukan 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());
}

Menerima dan memantulkan JSON

Gabungkan JSON input dan output: lakukan deserialisasi isi request, ubah isinya, lalu kembalikan JSON. Ini adalah pola umum membuat data lalu memberikan respons.

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

Substate dengan FromRef

Saat state menyimpan beberapa bagian, turunkan FromRef agar handler dapat mengekstrak hanya bagian yang dibutuhkannya.

use axum::extract::FromRef;

#[derive(Clone)]
struct Pool;

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang JSON dan state.

Rangkuman

Anda telah mempelajari JSON dan state bersama:

Bungkus tipe Serialize dengan Json untuk memberikan respons
Definisikan struct state Clone, yang sering kali membungkus Arc
Pasang dengan with_state, lalu baca dengan State
Gunakan Arc<Mutex> untuk data bersama yang dapat diubah dan FromRef untuk substate

Selanjutnya: middleware dengan lapisan tower.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “JSON dan State” gratis?

Ya — teks lengkap “JSON dan State” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “JSON dan State”?

State bersama dan serialisasi Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “JSON dan State” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding