Serializzazione dei dati nello sviluppo mobile — cos’è, formati e principio di funzionamento

Cos’è la serializzazione?

La serializzazione è il processo di conversione di un oggetto residente nella RAM in una sequenza lineare di byte o caratteri che può essere trasmessa in rete, salvata in un file o passata a un altro processo. Senza serializzazione, la comunicazione di rete, la persistenza dello stato e l’interazione tra processi sarebbero impossibili.

La serializzazione coinvolge due processi opposti. Il processo diretto (serializzazione) impacchetta i dati in un formato di trasmissione. Il processo inverso (deserializzazione) ripristina i dati nell’oggetto. La deserializzazione è critica per la sicurezza: dati di input errati possono portare a vulnerabilità nell’applicazione.

Nello sviluppo di applicazioni mobili, la serializzazione viene utilizzata ovunque: invio di richieste al server ed elaborazione delle risposte, salvataggio dello stato dell’applicazione durante la rotazione dello schermo, memorizzazione nella cache su disco e trasferimento di dati tra schermate tramite Intent (Android) o Segue (iOS).

Compiti principali della serializzazione

• Comunicazione di rete — trasferimento dati tra client e server
• Persistenza dello stato — salvataggio e ripristino dei dati dell’applicazione
• Cache — memorizzazione dei risultati delle richieste per l’accesso offline
• Multipiattaforma — scambio di dati tra sistemi in lingue diverse
• Registrazione — serializzazione degli oggetti per la scrittura nei log

Principali formati di serializzazione

I formati di serializzazione si dividono in testuali e binari. I formati testuali (JSON, XML) sono leggibili dall’uomo e non richiedono strumenti per la visualizzazione. I formati binari (Protobuf, FlatBuffers, MessagePack) sono più compatti e veloci, ma illeggibili senza deserializzazione. La scelta del formato è un compromesso tra prestazioni e comodità di debug.

Oltre a JSON, XML e Protobuf, esistono formati specializzati: FlatBuffers di Google per giochi e AR, MessagePack — un’alternativa binaria compatta a JSON, Avro di Apache per big data in Kafka, YAML — un formato di configurazione con supporto ai commenti.

Serializzazione nello sviluppo mobile

La serializzazione sulle piattaforme mobili ha le sue peculiarità: traffico limitato, processori meno potenti e la necessità di preservare lo stato durante le rotazioni dello schermo. Su Android si utilizzano Gson, Moshi, Kotlinx Serialization. Su iOS — Codable, JSONSerialization, PropertyListEncoder. La scelta corretta della libreria influisce criticamente sulle prestazioni dell’applicazione.

Kotlinx Serialization è una libreria moderna di JetBrains per Kotlin Multiplatform Mobile. Supporta JSON, Protobuf, CBOR e formati personalizzati. La generazione del codice avviene in fase di compilazione tramite il plugin Kotlin Serialization, garantendo alte prestazioni senza utilizzare la riflessione.

Kotlinx Serialization (Kotlin Multiplatform)

La libreria Kotlinx Serialization utilizza l’annotazione @Serializable per le classi e un plugin del compilatore per generare serializzatori. Ciò garantisce elevate prestazioni e sicurezza dei tipi. Il formato predefinito è JSON, ma altri formati sono supportati tramite moduli aggiuntivi.

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)

    // Serializzazione
    val jsonString = json.encodeToString(project)

    // Deserializzazione
    val restored = json.decodeFromString<Project>(jsonString)
}

Codable su iOS (Swift)

Il protocollo Codable è il meccanismo di serializzazione integrato di Swift. Combina i protocolli Encodable (serializzazione) e Decodable (deserializzazione). JSONEncoder e JSONDecoder gestiscono automaticamente strutture annidate, array, valori opzionali e chiavi personalizzate tramite 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)

Prestazioni e confronto dei formati

Le prestazioni dei formati di serializzazione vengono valutate secondo tre metriche: dimensione del messaggio, velocità di serializzazione e velocità di deserializzazione. Per le applicazioni mobili, tutte e tre sono critiche: la dimensione influisce sul traffico e sul tempo di caricamento, la velocità influisce sulla reattività dell’interfaccia e sul tempo di avvio dell’applicazione.

Protobuf e FlatBuffers mostrano i migliori risultati grazie alla rappresentazione binaria. FlatBuffers si distingue perché non richiede un passaggio separato di deserializzazione — i dati vengono letti direttamente dal buffer binario, rendendolo ideale per giochi e applicazioni AR con requisiti di latenza minima. JSON rimane il formato più popolare per le API REST, nonostante le prestazioni inferiori, grazie alla sua semplicità e universalità.

Test comparativi

Test pratici su un set di dati di 1000 oggetti utente mostrano: Protobuf crea messaggi di 12 KB (JSON — 85 KB, XML — 120 KB). Tempo di serializzazione: Protobuf — 2 ms, JSON — 8 ms, XML — 25 ms. Questi numeri rendono i formati binari preferibili per i sistemi ad alto carico e le applicazioni mobili con traffico limitato.

Esempi di serializzazione dei dati

Gli esempi mostrano la serializzazione dello stesso oggetto in diversi formati. Ciò aiuta a confrontare visivamente dimensione e leggibilità. Lo stesso oggetto User verrà serializzato in JSON, XML e Protobuf — è chiaramente visibile che JSON è più compatto di XML e Protobuf è il più compatto di tutti e illeggibile.

Un oggetto in tre formati

JSON — sintassi minimalista, chiavi tra virgolette, valori di diversi tipi. Occupa 80 caratteri. Leggibilità alta, struttura visiva chiara. Adatto per API dove contano la velocità di sviluppo e debug.

XML — ogni elemento è racchiuso in tag di apertura e chiusura. Occupa 150 caratteri. Leggibilità media, struttura rigorosa. Adatto per flussi documentali e sistemi che richiedono validazione XSD.

Protobuf — binario, 32 byte per questi dati. Illeggibile — richiede deserializzazione per la visualizzazione. La dimensione minima lo rende ideale per sistemi ad alto carico e applicazioni mobili.

{
  "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>

Best practice di serializzazione

Le best practice aiutano a evitare errori comuni e a scegliere la strategia di serializzazione giusta per il progetto. Seguire queste raccomandazioni migliora le prestazioni, la sicurezza e la manutenibilità del codice.

Raccomandazioni per lo sviluppo mobile

1. Scegli il formato in base allo scenario — JSON per API REST, Protobuf per gRPC e microservizi
2. Evita Java Serializable — meccanismo lento e insicuro, usa Kotlinx Serialization o Moshi
3. Ignora le chiavi sconosciute — configura il parser per saltare i campi assenti nel modello
4. Memorizza nella cache i dati deserializzati — evita di analizzare ripetutamente gli stessi dati
5. Valida i dati di input — controlla i limiti e i tipi durante la deserializzazione

Sicurezza e serializzazione

La sicurezza della serializzazione è un aspetto criticamente importante, specialmente quando si deserializzano dati da fonti non affidabili. Gli attacchi di deserializzazione possono portare all’esecuzione remota di codice (RCE), una delle vulnerabilità più pericolose nelle applicazioni web e mobili. I casi più noti sono legati a Java Serializable e Python pickle.

Protobuf e JSON hanno una protezione integrata contro tali attacchi, poiché lavorano solo con dati, non con oggetti arbitrari. Java Serializable, al contrario, può ripristinare qualsiasi classe disponibile nel classpath, rendendolo pericoloso per ricevere dati da fonti esterne. Su Android, si consiglia di utilizzare Kotlinx Serialization o Moshi invece della serializzazione Java standard.

Misure di sicurezza aggiuntive: imposta un limite sulla dimensione dei dati di input, valida lo schema prima della deserializzazione, non fidarti del Content-Type dalle intestazioni HTTP, usa una whitelist per le classi consentite. Aggiorna regolarmente le librerie di serializzazione, poiché le vulnerabilità vengono periodicamente scoperte e corrette.