Serialização de objetos em Rust: Serde e outras ferramentas

Serialização de objetos em Rust: visão geral de bibliotecas e ferramentas

A serialização é um dos processos fundamentais no desenvolvimento de software. Ela permite transformar estruturas de dados complexas (objetos, estruturas, enumerações) em um formato sequencial, conveniente para armazenamento em disco ou transmissão pela rede. O processo inverso — desserialização — restaura os objetos originais a partir desse formato. Na linguagem Rust, esse problema é resolvido por um ecossistema cujo centro é a biblioteca Serde (Serialization/Deserialization).

Neste artigo, vamos detalhar como a serialização funciona em Rust, quais bibliotecas existem para ela e como usá-las na prática.

Por que Serde?

Serde não é apenas uma biblioteca, mas um framework para serialização e desserialização. Sua principal característica é a divisão em duas partes:

• Modelo de Dados Serde — o núcleo que define como os tipos de dados do Rust são convertidos em uma representação intermediária.
• Adaptadores de formato — crates separados que trabalham com formatos específicos (JSON, YAML, TOML, Bincode, MessagePack e outros).

Essa abordagem permite usar o mesmo código para trabalhar com diferentes formatos, alterando apenas uma linha no Cargo.toml.

Configuração básica e instalação

Para começar, adicione as seguintes dependências ao Cargo.toml:

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

Uma característica fundamental é o uso do atributo #[derive(Serialize, Deserialize)]. Ele gera automaticamente o código para transformar suas estruturas:

use serde::{Serialize, Deserialize};

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

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

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

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

Trabalhando com diferentes formatos

Serde suporta dezenas de formatos. Vamos considerar os mais populares:

JSON (serde_json)

O formato mais comum para APIs web. Legível por humanos, mas ocupa muito espaço.

// Serialização para stringlet json_str = serde_json::to_string(&data)?;

// Serialização para fluxo (arquivo)let file = std::fs::File::create("data.json")?;let writer = std::io::BufWriter::new(file);serde_json::to_writer(writer, &data)?;

// Leitura de arquivolet file = std::fs::File::open("data.json")?;let reader = std::io::BufReader::new(file);let data: MyStruct = serde_json::from_reader(reader)?;

Bincode (bincode)

Formato binário — compacto e rápido. Ideal para armazenamento interno ou transmissão entre serviços em Rust.

// Cargo.toml: bincode = "1.3"

let encoded: Vec<u8> = bincode::serialize(&data)?;let decoded: MyStruct = bincode::deserialize(&encoded)?;

YAML e TOML (serde_yaml, toml)

Usados para arquivos de configuração. Legíveis por humanos, suportam comentários (YAML).

// YAMLlet yaml = serde_yaml::to_string(&data)?;let data: MyStruct = serde_yaml::from_str(&yaml)?;

// TOML (popular no ecossistema Rust)let toml = toml::to_string(&data)?;let data: MyStruct = toml::from_str(&toml)?;

Recursos avançados: atributos Serde

Serde fornece atributos poderosos para ajuste fino da serialização:

#[derive(Serialize, Deser