Sérialisation des données dans le développement mobile — définition, formats et principe de fonctionnement

Qu’est-ce que la sérialisation ?

La sérialisation est le processus de conversion d’un objet résidant en RAM en une séquence linéaire d’octets ou de caractères pouvant être transmise sur un réseau, sauvegardée dans un fichier ou passée à un autre processus. Sans sérialisation, la communication réseau, la persistance de l’état et l’interaction interprocessus seraient impossibles.

La sérialisation implique deux processus opposés. Le processus direct (sérialisation) empaquette les données dans un format de transmission. Le processus inverse (désérialisation) restaure les données dans l’objet. La désérialisation est cruciale pour la sécurité : des données d’entrée incorrectes peuvent entraîner des vulnérabilités dans l’application.

Dans le développement d’applications mobiles, la sérialisation est utilisée partout : envoi de requêtes au serveur et traitement des réponses, sauvegarde de l’état de l’application lors de la rotation de l’écran, mise en cache des données sur le disque et transfert de données entre les écrans via Intent (Android) ou Segue (iOS).

Tâches principales de la sérialisation

• Communication réseau — transfert de données entre le client et le serveur
• Persistance de l’état — sauvegarde et restauration des données de l’application
• Mise en cache — stockage des résultats de requêtes pour un accès hors ligne
• Multiplateforme — échange de données entre des systèmes dans différentes langues
• Journalisation — sérialisation d’objets pour l’écriture dans les logs

Principaux formats de sérialisation

Les formats de sérialisation se divisent en formats texte et binaires. Les formats texte (JSON, XML) sont lisibles par l’homme et ne nécessitent aucun outil pour les visualiser. Les formats binaires (Protobuf, FlatBuffers, MessagePack) sont plus compacts et plus rapides, mais illisibles sans désérialisation. Le choix du format est un compromis entre performance et commodité de débogage.

Outre JSON, XML et Protobuf, il existe des formats spécialisés : FlatBuffers de Google pour les jeux et la RA, MessagePack — une alternative binaire compacte à JSON, Avro d’Apache pour le big data dans Kafka, YAML — un format de configuration avec prise en charge des commentaires.

Sérialisation dans le développement mobile

La sérialisation sur les plateformes mobiles a ses particularités : trafic limité, processeurs plus faibles et nécessité de préserver l’état lors des rotations d’écran. Sur Android, on utilise Gson, Moshi, Kotlinx Serialization. Sur iOS — Codable, JSONSerialization, PropertyListEncoder. Le choix judicieux de la bibliothèque affecte considérablement les performances de l’application.

Kotlinx Serialization est une bibliothèque moderne de JetBrains pour Kotlin Multiplatform Mobile. Elle prend en charge JSON, Protobuf, CBOR et les formats personnalisés. La génération de code se fait à la compilation via le plugin Kotlin Serialization, garantissant des performances élevées sans utiliser la réflexion.

Kotlinx Serialization (Kotlin Multiplatform)

La bibliothèque Kotlinx Serialization utilise l’annotation @Serializable pour les classes et un plugin de compilateur pour générer des sérialiseurs. Cela garantit des performances élevées et la sécurité des types. Le format par défaut est JSON, mais d’autres formats sont pris en charge via des modules supplémentaires.

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)

    // Sérialisation
    val jsonString = json.encodeToString(project)

    // Désérialisation
    val restored = json.decodeFromString<Project>(jsonString)
}

Codable sur iOS (Swift)

Le protocole Codable est le mécanisme de sérialisation intégré de Swift. Il combine les protocoles Encodable (sérialisation) et Decodable (désérialisation). JSONEncoder et JSONDecoder gèrent automatiquement les structures imbriquées, les tableaux, les valeurs optionnelles et les clés personnalisées via 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)

Performances et comparaison des formats

Les performances des formats de sérialisation sont évaluées selon trois métriques : la taille du message, la vitesse de sérialisation et la vitesse de désérialisation. Pour les applications mobiles, ces trois aspects sont cruciaux : la taille influence le trafic et le temps de chargement, la vitesse influence la réactivité de l’interface et le temps de démarrage de l’application.

Protobuf et FlatBuffers montrent les meilleurs results grâce à la représentation binaire. FlatBuffers se distingue car il ne nécessite pas d’étape séparée de désérialisation — les données sont lues directement à partir du tampon binaire, ce qui le rend idéal pour les jeux et les applications de RA avec des exigences de latence minimale. JSON reste le format le plus populaire pour les API REST, malgré des performances inférieures, en raison de sa simplicité et de son universalité.

Tests comparatifs

Des tests pratiques sur un ensemble de 1000 objets utilisateur montrent : Protobuf crée des messages de 12 Ko (JSON — 85 Ko, XML — 120 Ko). Temps de sérialisation : Protobuf — 2 ms, JSON — 8 ms, XML — 25 ms. Ces chiffres rendent les formats binaires préférables pour les systèmes à forte charge et les applications mobiles à trafic limité.

Exemples de sérialisation de données

Les exemples montrent la sérialisation du même objet dans différents formats. Cela permet de comparer visuellement la taille et la lisibilité. Le même objet User sera sérialisé en JSON, XML et Protobuf — on voit clairement que JSON est plus compact que XML, et que Protobuf est le plus compact et illisible.

Un objet dans trois formats

JSON — syntaxe minimaliste, clés entre guillemets, valeurs de différents types. Occupe 80 caractères. Lisibilité élevée, structure visuelle claire. Adapté aux API où la rapidité de développement et de débogage est importante.

XML — chaque élément est enveloppé dans des balises ouvrantes et fermantes. Occupe 150 caractères. Lisibilité modérée, structure stricte. Adapté aux flux documentaires et aux systèmes nécessitant une validation XSD.

Protobuf — binaire, 32 octets pour ces données. Illisible — nécessite une désérialisation pour être visualisé. Sa taille minimale le rend idéal pour les systèmes à forte charge et les applications mobiles.

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

Bonnes pratiques de sérialisation

Les bonnes pratiques aident à éviter les erreurs courantes et à choisir la stratégie de sérialisation appropriée pour le projet. Le suivi de ces recommandations améliore les performances, la sécurité et la maintenabilité du code.

Recommandations pour le développement mobile

1. Choisissez le format selon le scénario — JSON pour les API REST, Protobuf pour gRPC et les microservices
2. Évitez Java Serializable — mécanisme lent et dangereux, utilisez Kotlinx Serialization ou Moshi
3. Ignorez les clés inconnues — configurez l’analyseur pour ignorer les champs absents du modèle
4. Mettez en cache les données désérialisées — évitez d’analyser plusieurs fois les mêmes données
5. Validez les données d’entrée — vérifiez les limites et les types lors de la désérialisation

Sécurité et sérialisation

La sécurité de la sérialisation est un aspect crucial, en particulier lors de la désérialisation de données provenant de sources non fiables. Les attaques par désérialisation peuvent conduire à une exécution de code à distance (RCE), ce qui constitue l’une des vulnérabilités les plus dangereuses dans les applications web et mobiles. Les cas les plus connus sont liés à Java Serializable et Python pickle.

Protobuf et JSON disposent d’une protection intégrée contre ces attaques, car ils travaillent uniquement avec des données, pas avec des objets arbitraires. Java Serializable, en revanche, peut restaurer n’importe quelle classe disponible dans le classpath, ce qui le rend dangereux pour la réception de données provenant de sources externes. Sur Android, il est recommandé d’utiliser Kotlinx Serialization ou Moshi au lieu de la sérialisation Java standard.

Mesures de sécurité supplémentaires : définissez une limite sur la taille des données d’entrée, validez le schéma avant la désérialisation, ne faites pas confiance au Content-Type des en-têtes HTTP, utilisez une liste blanche pour les classes autorisées. Mettez régulièrement à jour les bibliothèques de sérialisation, car des vulnérabilités sont périodiquement découvertes et corrigées.