Sérialisation des données dans le développement mobile : essence, formats et fonctionnement

Essence de la sérialisation et de la désérialisation

La sérialisation est le processus de conversion d'un objet applicatif en un format approprié pour la transmission réseau ou le stockage sur disque. La désérialisation effectue la conversion inverse, restaurant l'objet à partir des données reçues. Dans le développement mobile, la sérialisation est utilisée dans les requêtes API, la sauvegarde d'état d'écran, la mise en cache et le transfert de données via Intent ou Bundle.

Quand le besoin se présente

Toute interaction entre les composants de l'application ou entre l'application et le serveur nécessite une sérialisation. Les API REST transmettent des données en JSON ou XML, gRPC utilise Protocol Buffers et la communication intraprocessus sur Android utilise Parcelable. Sans sérialisation, il est impossible de passer un objet complexe à travers une limite de processus ou de le sauvegarder dans une base de données.

// Principe général de sérialisation
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Sérialisation : objet -> JSON
fun serializeUser(user: User): String {
    return """{"id":${user.id},"name":"${user.name}","email":"${user.email}"}"""
}

// Désérialisation : JSON -> objet
fun deserializeUser(json: String): User? {
    // analyse de JSON en objet
    return Gson().fromJson(json, User::class.java)
}

JSON — le format principal du développement mobile

JSON (JavaScript Object Notation) est un format texte léger basé sur la syntaxe des objets JavaScript. JSON prend en charge les chaînes, les nombres, les booléens, les tableaux et les objets imbriqués, couvrant la plupart des scénarios de transfert de données dans les applications mobiles. Le format est indépendant de la plateforme : chaque écosystème fournit des outils intégrés pour son analyse.

Avantages de JSON par rapport aux alternatives

JSON l'emporte grâce à sa simplicité et sa polyvalence. Le développeur n'a pas besoin de schéma pour une utilisation de base — la structure est déterminée dynamiquement lors de l'analyse. La lisibilité du format simplifie le débogage et les tests : la réponse du serveur peut être visualisée dans n'importe quel outil de développement. Sur les deux plateformes mobiles, JSON est traité nativement sans nécessiter de bibliothèques tierces.

// Codable — sérialisation JSON native en Swift
struct User: Codable {
    let id: Int
    let name: String
    let email: String
}

let jsonString = """{"id":1,"name":"John","email":"john@test.com"}"""
let jsonData = Data(jsonString.utf8)
let decoder = JSONDecoder()
let user = try! decoder.decode(User.self, from: jsonData)

Protocol Buffers de Google

Protocol Buffers (protobuf) est un format de sérialisation binaire développé par Google pour les systèmes hautes performances. Contrairement à JSON, protobuf nécessite un schéma prédéfini dans un fichier .proto, mais offre une taille de données considérablement réduite et une vitesse de traitement plus élevée. Le format est utilisé dans gRPC, Firebase Firestore et les services internes de Google.

Structure d'un fichier .proto

Un schéma protobuf décrit des messages avec des champs typés, chacun ayant un numéro unique. Le compilateur protoc génère des classes dans le langage cible qui effectuent la sérialisation et la désérialisation automatiquement. Protobuf prend en charge l'évolution du schéma via des règles d'ajout et de suppression de champs sans perdre la compatibilité ascendante.

// Définition de schéma dans user.proto
syntax = "proto3";

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
  repeated string roles = 4;
}

// Code généré en Kotlin
val user = UserProto.User.newBuilder()
    .setId(1)
    .setName("John")
    .setEmail("john@test.com")
    .build()

val bytes: ByteArray = user.toByteArray()

XML et son application

XML (eXtensible Markup Language) est un format avec une structure rigide, une prise en charge des espaces de noms et une validation via des schémas XSD. XML perd face à JSON en compacité et en vitesse d'analyse, mais reste demandé dans le développement Android pour les fichiers de layout, AndroidManifest, les ressources et les configurations Gradle. Sur iOS, XML est utilisé dans les fichiers plist et certains services legacy.

Analyse XML sur Android

Android propose trois approches pour l'analyse XML : DOM (chargement de l'intégralité du document en mémoire), SAX (analyse de flux pilotée par les événements) et XmlPullParser (une approche hybride). XmlPullParser est l'option recommandée pour les appareils mobiles, car il fonctionne efficacement avec une mémoire limitée et permet de traiter le document au fur et à mesure de sa lecture.

// XmlPullParser sur Android
fun parseUserXml(inputStream: InputStream): User? {
    val parser = Xml.newPullParser()
    parser.setInput(inputStream, Xml.Encoding.UTF_8.name)

    var id: Int? = null
    var name: String? = null
    var email: String? = null

    while (parser.next() != XmlPullParser.END_DOCUMENT) {
        if (parser.eventType == XmlPullParser.START_TAG
            && parser.name == "email") {
            email = parser.nextText()
        }
    }
    return User(id!!, name!!, email!!)
}

Sérialisation sur iOS et Android

Chaque plateforme propose ses propres outils de sérialisation. Sur iOS, le mécanisme principal est le protocole Codable avec JSONEncoder et JSONDecoder, tandis qu'Objective-C utilise NSJSONSerialization. Android utilise les bibliothèques Gson, Moshi et kotlinx.serialization. Pour le transfert de données interprocessus, Android utilise Parcelable, tandis qu'iOS utilise NSKeyedArchiver. Les projets Kotlin choisissent de plus en plus kotlinx.serialization — une solution de JetBrains qui prend en charge la multiplateforme et ne dépend pas de la réflexion, générant des sérialiseurs à la compilation via le plugin du compilateur Kotlin.

Parcelable vs Serializable sur Android

Android prend en charge deux mécanismes de sérialisation pour Intent et Bundle. Serializable est un mécanisme Java standard qui utilise la réflexion, conduisant à des performances inférieures. Parcelable est un protocole spécifique à Android qui nécessite une implémentation manuelle des méthodes writeToParcel et createFromParcel, mais fonctionne des dizaines de fois plus rapidement grâce à la manipulation directe des octets.

// Parcelable sur Android
@Parcelize
data class UserParcel(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable

// Transfert via Intent
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("user", userParcel)
startActivity(intent)

Sur iOS, Codable avec sérialisation préliminaire en Data est utilisé pour le transfert de données entre contrôleurs, tandis que NSKeyedArchiver est utilisé pour la communication interprocessus, convertissant les objets au format binaire Property List. Les projets SwiftUI modernes préfèrent encoder les données via JSONEncoder pour le transfert entre les modules de l'application.

Sécurité de la sérialisation

Une désérialisation incorrecte de données non fiables peut entraîner des vulnérabilités. Les attaques via la sérialisation exploitent les méthodes readObject surchargées en Java ou les désérialiseurs non sécurisés de bibliothèques tierces. Sur Android, il faut éviter Serializable pour les données provenant de sources non fiables, en utilisant plutôt Parcelable ou une validation manuelle de tous les champs après la désérialisation. Sur iOS, JSONDecoder est strict par défaut avec les types, mais lors du travail avec JSONSerialization, les développeurs doivent vérifier les types via un casting conditionnel.

Choisir un format pour le projet

Lors du choix d'un format de sérialisation, les exigences de performance, la taille des données et la compatibilité sont prises en compte. Pour les API REST et l'architecture de microservices, JSON reste le choix optimal — il est supporté par toutes les plateformes et langages. Pour les systèmes à forte charge et les applications mobiles à bande passante limitée, Protocol Buffers sont préférables, offrant une taille plus petite et une désérialisation plus rapide. XML n'est justifié que dans les scénarios de configuration et lors de l'intégration avec des systèmes legacy. Les projets modernes voient également la montée en popularité de FlatBuffers — un format binaire sans étape de désérialisation, utilisé dans les moteurs de jeux et les applications à latence minimale. Chaque format a son créneau, et le bon choix affecte directement la vitesse de l'application et le volume de trafic consommé.