Convierte un JSON de ejemplo en structs de Rust listos para serde. Cada struct deriva Debug, Clone, Serialize, Deserialize; los nombres de campo siguen la convención snake_case de Rust y se vinculan a la clave original con #[serde(rename)] cuando difieren.
Es un punto de partida cuando quieres respuestas tipadas de reqwest, necesitas un tipo de petición para un extractor Json<T> de axum o actix-web, o estás escribiendo un CLI que parsea JSON de logs o eventos.
Nombre del tipo (por ejemplo AccessLog)..rs y añade serde (con la feature derive) y serde_json a Cargo.toml.serde_json::from_str::<AccessLog>(&body)? o resp.json::<AccessLog>().await?.{
"timestamp": 1714550400,
"level": "warn",
"type": "http_request",
"status": 503,
"latency_ms": 1250.7,
"headers": [{ "name": "user-agent", "value": "curl/8.4" }],
"trace_id": null
}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 es una palabra reservada de Rust, así que el campo es type_ con #[serde(rename = "type")]. Los enteros son i64 sea cual sea su tamaño, y latency_ms es f64. trace_id siempre vale null, así que su tipo es desconocido y se queda como serde_json::Value; sustitúyelo por el tipo real, p. ej. Option<String>.
#[derive(Debug, Clone, Serialize, Deserialize)] y campos pub en cada struct.#[serde(rename = "originalKey")] por campo cuando la clave difiere del nombre del campo en snake_case.Option<T> con #[serde(default, skip_serializing_if = "Option::is_none")].null: Option<T> simple, sin atributos.i64 para enteros, f64 para decimales, bool, String, Vec<T> y serde_json::Value para tipos mixtos.type, match o ref reciben un guion bajo al final (type_).pub type Root = Vec<RootItem>;.Sustituye accesos sobre serde_json::Value como ["status"].as_i64() por resp.json::<AccessLog>() para que un campo mal escrito falle en tiempo de compilación.
Genera un struct a partir del JSON que envía un cliente y recíbelo como Json(payload): Json<CreateOrder>; el framework rechaza las peticiones con campos ausentes o de tipo incorrecto antes de que se ejecute el código de tu handler.
Construye un struct a partir de una línea de log y luego deserializa cada línea de BufReader::lines() para tener en pocas líneas una herramienta de agregación por campo.
i64, por pequeños que sean. Ajústalos tú donde conozcas el rango, p. ej. u16 para códigos de estado o u32 para contadores.i64 o String. Pasar a tipos de chrono o time requiere activar las features de serde de esos crates.serde_json::Value escribe la ruta completa, así que no hace falta un use extra, pero sí la dependencia serde_json.#[serde(rename_all = "camelCase")] a nivel de struct. Si las claves siguen una sola convención, puedes unificarlos tú."level": "warn", son buenos candidatos para convertirlos después en un enum.#[serde(default)]?serde ya rellena con None un Option ausente, pero un default explícito sigue aceptando claves ausentes si más adelante cambias el tipo a algo como Vec<T>. skip_serializing_if omite los campos None al volver a escribir JSON, conservando la forma original.
Ambos pasan a Option<T>, pero solo los campos cuya clave puede estar ausente reciben los atributos default y skip_serializing_if. Un campo siempre presente pero a veces null se vuelve a escribir como null.
&str y un lifetime 'de?Los campos zero-copy (&'a str) no pueden vivir más que el buffer de entrada, lo que resulta incómodo para el manejo habitual de respuestas. Por defecto se usa String con ownership; cambia los campos críticos a Cow<'a, str> si el rendimiento importa.
Default o PartialEq?La salida solo deriva Debug, Clone, Serialize y Deserialize. Añade más a la lista de derive tú mismo cuando todos los tipos de los campos los soporten (serde_json::Value implementa PartialEq).