Serialização de objetos em Rust: serde, bincode, JSON |…

Serialização de objetos em Rust: guia completo sobre a biblioteca serde e formatos de dados

Serialização é o processo de converter estruturas de dados ou objetos em um formato que pode ser salvo em arquivo, transmitido pela rede ou armazenado em cache. Na linguagem Rust, essa tarefa é resolvida de forma elegante e eficiente com a biblioteca serde (Serialization/Deserialization). Neste artigo, vamos detalhar como a serialização funciona em Rust, quais formatos de dados são suportados e como escolher a ferramenta adequada para o seu projeto.

O que é serde e por que é o padrão de facto?

serde é um framework para serialização e desserialização de estruturas de dados em Rust. Ele não está vinculado a um formato específico — você pode usar JSON, Bincode, YAML, TOML, MessagePack, CBOR e muitos outros. A ideia principal: você descreve sua estrutura uma vez, e o serde gera automaticamente o código para trabalhar com qualquer formato através do sistema de traits Serialize e Deserialize.

Vantagens do serde:

Máximo desempenho — o código é gerado em tempo de compilação (zero-cost abstraction)
Segurança de tipos — erros de incompatibilidade de formatos são detectados em tempo de compilação
Suporte a estruturas complexas: enum, vetores, hash maps, objetos aninhados
Possibilidade de personalização através de atributos

Instalação e configuração básica

Adicione as seguintes dependências ao Cargo.toml:

[dependencies]serde = { version = "1.0", features = ["derive"] }serde_json = "1.0"bincode = "1.3"

O ponto-chave é a feature "derive" para o serde. Sem ela, você precisará implementar manualmente os traits Serialize e Deserialize.

Exemplo simples: serialização em JSON

JSON é o formato mais popular para aplicações web e APIs. Vejamos um exemplo básico:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct User {    id: u32,    name: String,    email: String,    is_active: bool,}

fn main() {    let user = User {        id: 42,        name: "Alexei".to_string(),        email: "alex@example.com".to_string(),        is_active: true,    };

    // Serialização em JSON    let json = serde_json::to_string(&user).unwrap();    println!("JSON: {}", json);

    // Desserialização de JSON    let deserialized: User = serde_json::from_str(&json).unwrap();    println!("Desserializado: {:?}", deserialized);}

Saída:

JSON: {"id":42,"name":"Alexei","email":"alex@example.com","is_active":true}Desserializado: User { id: 42, name: "Alexei", email: "alex@example.com", is_active: true }

Serialização binária com bincode

Para aplicações de alto desempenho (jogos, sistemas em tempo real, bancos de dados), geralmente é necessário um formato binário compacto. bincode é uma das melhores opções:

use serde::{Serialize, Deserialize};

#[derive(Debug, Serialize, Deserialize)]struct GameState {    level: u16,    health: f32,    inventory: Vec<String>,    checkpoint: (f64, f64),}

fn main() {    let state = GameState {        level: 5,        health: 87.5,        inventory: vec!["espada".into(), "poção".into()],        checkpoint: (120.5, -34.8),    };

    // Serialização em formato binário    let binary = bincode::serialize(&state).unwrap();    println!("Tamanho binário: {} bytes", binary.len());

    // Desserialização    let restored: GameState = bincode::deserialize(&binary).unwrap();    println!("Restaurado: {:?}", restored);}

Bincode oferece ganhos no tamanho dos dados e na velocidade de processamento em comparação com JSON. Por exemplo, uma estrutura com 4 campos ocupará cerca de 40 bytes contra 100+ em JSON.