Transforma um JSON de exemplo em structs Rust prontos para o serde. Cada struct faz derive de Debug, Clone, Serialize, Deserialize; os nomes dos campos seguem a convenção snake_case do Rust e são ligados de volta à chave original com #[serde(rename)] quando diferem.
É um ponto de partida quando você quer respostas tipadas no reqwest, precisa de um tipo de request para um extractor Json<T> do axum ou do actix-web, ou está escrevendo uma CLI que faz parse de JSON de logs ou eventos.
Nome do tipo (por exemplo AccessLog)..rs e adicione serde (com a feature derive) e serde_json ao Cargo.toml.serde_json::from_str::<AccessLog>(&body)? ou 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 é keyword do Rust, então o campo é type_ com #[serde(rename = "type")]. Inteiros são i64 independentemente do tamanho, e latency_ms é f64. trace_id só aparece como null, então o tipo é desconhecido e ele fica serde_json::Value; troque pelo tipo real, por exemplo Option<String>.
#[derive(Debug, Clone, Serialize, Deserialize)] e campos pub em todo struct.#[serde(rename = "originalKey")] por campo quando a chave difere do nome do campo em snake_case.Option<T> com #[serde(default, skip_serializing_if = "Option::is_none")].null: Option<T> simples, sem atributos.i64 para inteiros, f64 para decimais, bool, String, Vec<T> e serde_json::Value para tipos misturados.type, match ou ref, ganham um underscore no final (type_).pub type Root = Vec<RootItem>;.Troque acessos a serde_json::Value como ["status"].as_i64() por resp.json::<AccessLog>(), para que um campo com nome errado falhe em tempo de compilação.
Gere um struct a partir do JSON que um client manda e receba como Json(payload): Json<CreateOrder>; requests com campos faltando ou com tipo errado são rejeitados pelo framework antes de o código do seu handler rodar.
Monte um struct a partir de uma linha de log e depois desserialize cada linha de BufReader::lines() para ter, em poucas linhas, uma ferramenta de agregação por campo.
i64, por menores que sejam. Restrinja você mesmo onde o intervalo é conhecido, por exemplo u16 para status codes ou u32 para contadores.i64 ou String. Trocar para tipos do chrono ou do time exige ativar as features serde desses crates.serde_json::Value escreve o path completo, então não precisa de use extra, mas a dependência serde_json sim.#[serde(rename_all = "camelCase")] no nível do struct. Se as chaves seguem uma única convenção, você pode consolidar você mesmo."level": "warn", são bons candidatos a enum depois.#[serde(default)]?O serde já preenche um Option ausente com None, mas um default explícito continua aceitando chaves ausentes se depois você mudar o tipo para algo como Vec<T>. O skip_serializing_if omite campos None ao escrever o JSON de volta, preservando o formato original.
Os dois viram Option<T>, mas só campos cuja chave pode faltar recebem os atributos default e skip_serializing_if. Um campo sempre presente, mas às vezes null, é escrito de volta como null.
&str e um lifetime 'de?Campos zero-copy (&'a str) não podem viver mais que o buffer de entrada, o que é incômodo no tratamento típico de respostas. String owned é o padrão; troque os campos mais acessados por Cow<'a, str> se a performance importar.
Default ou PartialEq?A saída só faz derive de Debug, Clone, Serialize e Deserialize. Adicione mais à lista de derive você mesmo quando todos os tipos de campo suportarem (serde_json::Value implementa PartialEq).