JSON in Rust-struct umwandeln!

Gib JSON ein, um Rust-struct-Code inklusive verschachtelter Objekte zu erzeugen! Unterstützt serde Serialize, Deserialize, #[serde(rename)].
JSON
Ergebnis
 

JSON in Rust-struct umwandeln!

Mach aus einem JSON-Beispiel Rust-structs, die für serde bereit sind. Jedes Struct leitet Debug, Clone, Serialize, Deserialize ab; Feldnamen folgen der snake_case-Konvention von Rust und werden, wo sie abweichen, mit #[serde(rename)] an den ursprünglichen Key gebunden.

Ein Ausgangspunkt, wenn du typisierte reqwest-Antworten willst, einen Request-Typ für einen Json<T>-Extractor in axum oder actix-web brauchst oder ein CLI schreibst, das Log- oder Event-JSON parst.

So funktioniert es

  1. Füge das JSON ein. Ein Array mit mehreren Elementen hilft beim Erkennen optionaler Felder.
  2. Gib den Namen des obersten Structs in Typname ein (zum Beispiel AccessLog).
  3. Füge die Ausgabe in eine .rs-Datei ein und ergänze serde (mit dem Feature derive) und serde_json in Cargo.toml.
  4. Verwende es über serde_json::from_str::<AccessLog>(&body)? oder resp.json::<AccessLog>().await?.

Beispiel

Eingabe (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
}
Ausgabe (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,
}

type ist ein Rust-Schlüsselwort, daher heißt das Feld type_ mit #[serde(rename = "type")]. Ganzzahlen sind unabhängig von ihrer Größe i64, und latency_ms ist f64. trace_id ist immer nur null, sein Typ ist also unbekannt und es bleibt serde_json::Value; ersetze es durch den echten Typ, z. B. Option<String>.

Unterstützte Funktionen

  • #[derive(Debug, Clone, Serialize, Deserialize)] und pub-Felder an jedem Struct.
  • #[serde(rename = "originalKey")] pro Feld, wenn der Key vom snake_case-Feldnamen abweicht.
  • Felder, die in manchen Elementen fehlen: Option<T> mit #[serde(default, skip_serializing_if = "Option::is_none")].
  • Felder, die immer vorhanden, aber manchmal null sind: einfaches Option<T> ohne Attribute.
  • Typen: i64 für Ganzzahlen, f64 für Dezimalzahlen, bool, String, Vec<T> und serde_json::Value für gemischte Typen.
  • Keys, die Schlüsselwörter sind, wie type, match oder ref, bekommen einen angehängten Unterstrich (type_).
  • Ein Array auf oberster Ebene erzeugt pub type Root = Vec<RootItem>;.

Anwendungsfälle

Typisierte reqwest-Antworten

Ersetze Zugriffe auf serde_json::Value wie ["status"].as_i64() durch resp.json::<AccessLog>(), damit ein falsch geschriebenes Feld schon beim Kompilieren auffällt.

Request-Bodies in axum oder actix-web

Erzeuge ein Struct aus dem JSON, das ein Client sendet, und nimm es als Json(payload): Json<CreateOrder> entgegen; Requests mit fehlenden oder falsch typisierten Feldern weist das Framework ab, bevor dein Handler-Code läuft.

Ein CLI zur Analyse von JSON-Lines-Logs

Baue ein Struct aus einer Logzeile und deserialisiere dann jede Zeile aus BufReader::lines(), schon hast du in wenigen Zeilen ein Tool für Auswertungen pro Feld.

Hinweise und Einschränkungen

  • Ganzzahlen sind immer i64, egal wie klein. Schränke sie selbst ein, wo der Wertebereich bekannt ist, z. B. u16 für Statuscodes oder u32 für Zähler.
  • Timestamps und Datums-Strings bleiben i64 oder String. Für einen Wechsel zu chrono- oder time-Typen musst du die serde-Features dieser Crates aktivieren.
  • Ausgabe mit serde_json::Value schreibt den vollen Pfad aus, ein zusätzliches use ist also nicht nötig, die Abhängigkeit serde_json aber schon.
  • Umbenennungen erfolgen pro Feld statt über ein #[serde(rename_all = "camelCase")] auf Struct-Ebene. Folgen die Keys einer einzigen Konvention, kannst du sie selbst zusammenfassen.
  • Getaggte Enums werden nicht erzeugt. Felder mit einer festen Wertemenge wie "level": "warn" sind gute Kandidaten für ein nachträgliches Enum.

Häufige Fragen

Warum bekommen optionale Felder zusätzlich #[serde(default)]?

serde füllt ein fehlendes Option ohnehin mit None, ein explizites default akzeptiert fehlende Keys aber weiterhin, wenn du den Typ später zum Beispiel in Vec<T> änderst. skip_serializing_if lässt None-Felder beim Zurückschreiben in JSON weg und erhält so die ursprüngliche Form.

Wie unterscheiden sich nullable und fehlende Felder in der Ausgabe?

Beide werden zu Option<T>, aber nur Felder, deren Key fehlen kann, bekommen die Attribute default und skip_serializing_if. Ein Feld, das immer vorhanden, aber manchmal null ist, wird als null zurückgeschrieben.

Warum nicht mit &str-Feldern und einer Lifetime 'de ausleihen?

Zero-Copy-Felder (&'a str) können den Eingabepuffer nicht überleben, was bei typischer Antwortverarbeitung unpraktisch ist. Standard ist daher ein eigenes String; stelle viel genutzte Felder auf Cow<'a, str> um, wenn Performance zählt.

Kann ich Default- oder PartialEq-Derives ergänzen?

Die Ausgabe leitet nur Debug, Clone, Serialize und Deserialize ab. Ergänze weitere selbst in der Derive-Liste, wenn alle Feldtypen sie unterstützen (serde_json::Value implementiert PartialEq).