Serialização de dados no desenvolvimento móvel — o que é, formatos e princípio de funcionamento

O que é serialização?

Serialização é o processo de converter um objeto na memória RAM em uma sequência linear de bytes ou caracteres que pode ser transmitida pela rede, salva em um arquivo ou passada para outro processo. Sem serialização, a comunicação em rede, a persistência de estado e a interação entre processos seriam impossíveis.

A serialização envolve dois processos opostos. O processo direto (serialização) empacota os dados em um formato de transmissão. O processo inverso (desserialização) restaura os dados de volta ao objeto. A desserialização é crítica para a segurança: dados de entrada incorretos podem levar a vulnerabilidades no aplicativo.

No desenvolvimento de aplicativos móveis, a serialização é usada em toda parte: envio de requisições ao servidor e processamento de respostas, salvamento do estado do aplicativo ao girar a tela, cache de dados no disco e transferência de dados entre telas via Intent (Android) ou Segue (iOS).

Principais tarefas da serialização

• Comunicação em rede — transferência de dados entre cliente e servidor
• Persistência de estado — salvamento e restauração de dados do aplicativo
• Cache — armazenamento de resultados de requisições para acesso offline
• Multiplataforma — troca de dados entre sistemas em diferentes idiomas
• Registro — serialização de objetos para gravação em logs

Principais formatos de serialização

Os formatos de serialização se dividem em textuais e binários. Os formatos textuais (JSON, XML) são legíveis por humanos e não requerem ferramentas para visualização. Os formatos binários (Protobuf, FlatBuffers, MessagePack) são mais compactos e rápidos, mas ilegíveis sem desserialização. A escolha do formato é um compromisso entre desempenho e conveniência de depuração.

Além de JSON, XML e Protobuf, existem formatos especializados: FlatBuffers do Google para jogos e RA, MessagePack — um alternativo binário compacto ao JSON, Avro da Apache para big data no Kafka, YAML — um formato de configuração com suporte a comentários.

Serialização no desenvolvimento móvel

A serialização em plataformas móveis tem suas particularidades: tráfego limitado, processadores mais fracos e a necessidade de preservar o estado durante as rotações de tela. No Android, são usados Gson, Moshi, Kotlinx Serialization. No iOS — Codable, JSONSerialization, PropertyListEncoder. A escolha correta da biblioteca afeta criticamente o desempenho do aplicativo.

Kotlinx Serialization é uma biblioteca moderna da JetBrains para Kotlin Multiplatform Mobile. Ela suporta JSON, Protobuf, CBOR e formatos personalizados. A geração de código ocorre em tempo de compilação através do plugin Kotlin Serialization, garantindo alto desempenho sem usar reflexão.

Kotlinx Serialization (Kotlin Multiplatform)

A biblioteca Kotlinx Serialization usa a anotação @Serializable para classes e um plugin de compilador para gerar serializadores. Isso garante alto desempenho e segurança de tipos. O formato padrão é JSON, mas outros formatos são suportados através de módulos adicionais.

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.encodeToString
import kotlinx.serialization.decodeFromString

@Serializable
data class Project(
    val id: Int,
    val name: String,
    val platforms: List<String>,
    val active: Boolean
)

val json = Json {
    prettyPrint = true
    ignoreUnknownKeys = true
    encodeDefaults = true
}

fun main() {
    val project = Project(1, "MobileApp",
        listOf("Android", "iOS"), true)

    // Serialização
    val jsonString = json.encodeToString(project)

    // Desserialização
    val restored = json.decodeFromString<Project>(jsonString)
}

Codable no iOS (Swift)

O protocolo Codable é o mecanismo de serialização integrado do Swift. Ele combina os protocolos Encodable (serialização) e Decodable (desserialização). JSONEncoder e JSONDecoder lidam automaticamente com estruturas aninhadas, arrays, valores opcionais e chaves personalizadas através de CodingKeys.

import Foundation

struct AppConfig: Codable {
    let appName: String
    let version: String
    let features: [String]
    let isProduction: Bool
}

let config = AppConfig(
    appName: "MyApp",
    version: "2.1.0",
    features: ["push", "analytics", "offline"],
    isProduction: true
)

let encoder = JSONEncoder()
encoder.outputFormatting = [.prettyPrinted, .sortedKeys]

guard let data = try? encoder.encode(config) else { return }
let jsonString = String(data: data, encoding: .utf8)

Desempenho e comparação de formatos

O desempenho dos formatos de serialização é avaliado por três métricas: tamanho da mensagem, velocidade de serialização e velocidade de desserialização. Para aplicativos móveis, as três são críticas: o tamanho afeta o tráfego e o tempo de carregamento, a velocidade afeta a capacidade de resposta da interface e o tempo de inicialização do aplicativo.

Protobuf e FlatBuffers mostram os melhores resultados graças à representação binária. FlatBuffers se destaca porque não requer uma etapa separada de desserialização — os dados são lidos diretamente do buffer binário, tornando-o ideal para jogos e aplicativos de RA com requisitos de latência mínima. JSON continua sendo o formato mais popular para APIs REST, apesar do pior desempenho, devido à sua simplicidade e universalidade.

Teste comparativo

Testes práticos em um conjunto de 1000 objetos de usuário mostram: Protobuf cria mensagens de 12 KB (JSON — 85 KB, XML — 120 KB). Tempo de serialização: Protobuf — 2 ms, JSON — 8 ms, XML — 25 ms. Esses números tornam os formatos binários preferíveis para sistemas de alta carga e aplicativos móveis com tráfego limitado.

Exemplos de serialização de dados

Os exemplos demonstram a serialização do mesmo objeto em diferentes formatos. Isso ajuda a comparar visualmente o tamanho e a legibilidade. O mesmo objeto User será serializado em JSON, XML e Protobuf — é claramente visível que JSON é mais compacto que XML, e Protobuf é o mais compacto de todos e ilegível.

Um objeto em três formatos

JSON — sintaxe minimalista, chaves entre aspas, valores de diferentes tipos. Ocupa 80 caracteres. Legibilidade alta, estrutura visual clara. Adequado para APIs onde a velocidade de desenvolvimento e depuração importa.

XML — cada elemento está envolto em tags de abertura e fechamento. Ocupa 150 caracteres. Legibilidade moderada, estrutura estrita. Adequado para fluxos de documentos e sistemas que exigem validação XSD.

Protobuf — binário, 32 bytes para esses dados. Ilegível — requer desserialização para visualização. O tamanho mínimo o torna ideal para sistemas de alta carga e aplicativos móveis.

{
  "id": 42,
  "name": "IT Sectr",
  "email": "team@itsectr.com",
  "role": "admin",
  "active": true
}

<user>
    <id>42</id>
    <name>IT Sectr</name>
    <email>team@itsectr.com</email>
    <role>admin</role>
    <active>true</active>
</user>

Melhores práticas de serialização

As melhores práticas ajudam a evitar erros comuns e escolher a estratégia de serialização certa para o projeto. Seguir estas recomendações melhora o desempenho, a segurança e a manutenibilidade do código.

Recomendações para desenvolvimento móvel

1. Escolha o formato pelo cenário — JSON para APIs REST, Protobuf para gRPC e microsserviços
2. Evite Java Serializable — mecanismo lento e inseguro, use Kotlinx Serialization ou Moshi
3. Ignore chaves desconhecidas — configure o parser para ignorar campos ausentes no modelo
4. Armazene em cache dados desserializados — evite analisar repetidamente os mesmos dados
5. Valide os dados de entrada — verifique limites e tipos durante a desserialização

Segurança e serialização

A segurança da serialização é um aspecto criticamente importante, especialmente ao desserializar dados de fontes não confiáveis. Ataques de desserialização podem levar à execução remota de código (RCE), sendo uma das vulnerabilidades mais perigosas em aplicativos web e móveis. Os casos mais conhecidos estão relacionados ao Java Serializable e Python pickle.

Protobuf e JSON têm proteção integrada contra tais ataques, pois trabalham apenas com dados, não com objetos arbitrários. Java Serializable, por outro lado, pode restaurar qualquer classe disponível no classpath, tornando-o perigoso para receber dados de fontes externas. No Android, recomenda-se usar Kotlinx Serialization ou Moshi em vez da Serialização Java padrão.

Medidas de segurança adicionais: defina um limite para o tamanho dos dados de entrada, valide o esquema antes da desserialização, não confie no Content-Type dos cabeçalhos HTTP, use uma lista de permissão para classes autorizadas. Atualize regularmente as bibliotecas de serialização, pois vulnerabilidades são periodicamente descobertas e corrigidas.