I-convert ang JSON sa Rust struct!

Maglagay ng JSON para gumawa ng Rust struct code, kasama ang mga nested object! Sinusuportahan ang serde Serialize, Deserialize, #[serde(rename)].
JSON
Resulta
 

I-convert ang JSON sa Rust struct!

Gawing mga Rust struct na handa para sa serde ang isang JSON sample. Nagde-derive ng Debug, Clone, Serialize, Deserialize ang bawat struct; sinusunod ng mga field name ang snake_case convention ng Rust at nakatali pabalik sa orihinal na key gamit ang #[serde(rename)] kapag magkaiba sila.

Panimulang punto ito kapag gusto mo ng typed na reqwest response, kailangan mo ng request type para sa Json<T> extractor ng axum o actix-web, o nagsusulat ka ng CLI na nagpa-parse ng log o event JSON.

Paano gamitin

  1. I-paste ang JSON. Nakakatulong ang array na may ilang item para ma-detect ang mga optional na field.
  2. Ilagay sa Pangalan ng type ang pangalan ng top-level struct (halimbawa AccessLog).
  3. I-paste ang output sa isang .rs file at idagdag ang serde (na may derive feature) at serde_json sa Cargo.toml.
  4. Gamitin ito sa pamamagitan ng serde_json::from_str::<AccessLog>(&body)? o resp.json::<AccessLog>().await?.

Halimbawa

Input (JSON)
{
  "timestamp": 1714550400,
  "level": "warn",
  "type": "http_request",
  "status": 503,
  "latency_ms": 1250.7,
  "headers": [{ "name": "user-agent", "value": "curl/8.4" }],
  "trace_id": null
}
Output (Rust · serde)
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccessLog {
    pub timestamp: i64,
    pub level: String,
    #[serde(rename = "type")]
    pub type_: String,
    pub status: i64,
    pub latency_ms: f64,
    pub headers: Vec<Header>,
    pub trace_id: serde_json::Value,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Header {
    pub name: String,
    pub value: String,
}

Rust keyword ang type, kaya type_ ang field na may #[serde(rename = "type")]. i64 ang mga integer anuman ang laki, at f64 ang latency_ms. Laging null lang ang trace_id, kaya hindi alam ang type nito at nananatili itong serde_json::Value; palitan ito ng totoong type, hal. Option<String>.

Mga sinusuportahang feature

  • #[derive(Debug, Clone, Serialize, Deserialize)] at mga pub field sa bawat struct.
  • #[serde(rename = "originalKey")] bawat field kapag iba ang key sa snake_case na field name.
  • Mga field na wala sa ilang item: Option<T> na may #[serde(default, skip_serializing_if = "Option::is_none")].
  • Mga field na laging nandoon pero minsan ay null: simpleng Option<T> na walang attribute.
  • Mga type: i64 para sa integer, f64 para sa decimal, bool, String, Vec<T>, at serde_json::Value para sa halo-halong type.
  • Nilalagyan ng underscore sa dulo ang mga keyword key gaya ng type, match o ref (type_).
  • Kapag array ang top level, pub type Root = Vec<RootItem>; ang lumalabas.

Mga gamit

Mga typed na reqwest response

Palitan ang mga serde_json::Value lookup gaya ng ["status"].as_i64() ng resp.json::<AccessLog>() para pumalya sa compile time ang maling spelling ng field.

Mga request body sa axum o actix-web

Gumawa ng struct mula sa JSON na ipinapadala ng client at tanggapin ito bilang Json(payload): Json<CreateOrder>; tinatanggihan ng framework ang mga request na may nawawala o maling type na field bago pa tumakbo ang handler code mo.

Isang CLI para sa pagsusuri ng JSON Lines log

Bumuo ng struct mula sa isang linya ng log, saka i-deserialize ang bawat linya mula sa BufReader::lines() para makakuha ng per-field na aggregation tool sa ilang linya lang.

Mga paalala at limitasyon

  • Laging i64 ang mga integer, gaano man kaliit. Ikaw na ang magpaliit sa kanila kung saan alam ang range, hal. u16 para sa mga status code o u32 para sa mga counter.
  • Nananatiling i64 o String ang mga timestamp at date string. Kailangang i-enable ang serde features ng mga crate na iyon para lumipat sa mga chrono o time type.
  • Buong path ang isinusulat ng output na gumagamit ng serde_json::Value, kaya walang dagdag na use na kailangan, pero kailangan ang serde_json dependency.
  • Bawat field ang mga rename sa halip na isang struct-level na #[serde(rename_all = "camelCase")]. Kung iisang convention ang sinusunod ng mga key, ikaw na ang magsama-sama sa kanila.
  • Hindi ginagawa ang mga tagged enum. Magandang kandidato para gawing enum pagkatapos ang mga field na may fixed na set ng value, gaya ng "level": "warn".

Mga madalas itanong

Bakit may #[serde(default)] din ang mga optional na field?

Pinupunan na ng serde ng None ang nawawalang Option, pero sa explicit na default, patuloy na tatanggapin ang mga nawawalang key kung papalitan mo mamaya ang type ng gaya ng Vec<T>. Inaalis naman ng skip_serializing_if ang mga None field kapag isinusulat pabalik ang JSON, kaya napapanatili ang orihinal na hugis.

Paano nagkakaiba sa output ang mga field na puwedeng null at ang mga nawawalang field?

Parehong nagiging Option<T>, pero ang mga field lang na puwedeng mawala ang key ang nakakakuha ng default at skip_serializing_if na attribute. Isinusulat pabalik bilang null ang field na laging nandoon pero minsan ay null.

Bakit hindi mag-borrow gamit ang mga &str field at 'de lifetime?

Hindi puwedeng mabuhay nang mas matagal sa input buffer ang mga zero-copy field (&'a str), na hindi komportable sa karaniwang paghawak ng response. Owned na String ang default; ilipat sa Cow<'a, str> ang mga hot field kung mahalaga ang performance.

Puwede ba akong magdagdag ng Default o PartialEq derive?

Debug, Clone, Serialize at Deserialize lang ang dine-derive ng output. Ikaw na ang magdagdag sa derive list kapag suportado sila ng lahat ng field type (nag-i-implement ng PartialEq ang serde_json::Value).