Parsing dans les applications mobiles : essence, formats de données et processus

Qu'est-ce que le parsing ?

Le parsing (analyse syntaxique) est le processus de conversion d'une séquence de caractères en une représentation structurée adaptée au traitement programmatique. Dans le contexte du développement mobile, le parsing désigne le traitement des réponses serveur, des fichiers de configuration, du cache local et des fichiers de ressources. Chaque format nécessite sa propre approche : JSON — léger et intégré au SDK, XML — strict avec validation de schéma XSD, CSV — minimaliste pour les données tabulaires, Protobuf — binaire avec un schéma rigide.

Étapes de l'analyse syntaxique

Tout analyseur, quel que soit le format, passe par trois étapes. L'analyse lexicale divise le texte brut en tokens : clés, chaînes, nombres, délimiteurs et commentaires. L'analyse syntaxique vérifie la correction grammaticale — équilibre des parenthèses dans JSON, imbrication correcte des balises dans XML. La construction de la structure de sortie forme une représentation objet : JSONObject, Map ou un flux de tokens pour un traitement ultérieur. Selon Apple (2026), l'analyseur Foundation intégré sur iOS utilise une analyse paresseuse — il ne valide que le début du JSON, économisant ainsi les ressources.

Parsing manuel vs bibliothèques automatisées

Le parsing manuel (JSONSerialization, XmlPullParser) offre un contrôle total sur le processus et est utile pour les formats non standard ou lorsqu'une validation personnalisée de chaque champ est nécessaire. Les bibliothèques automatisées (JSONDecoder, Moshi, kotlinx.serialization) accélèrent le développement mais masquent les détails de la gestion des erreurs. Le choix dépend des exigences : si la structure des données est dynamique ou inconnue à l'avance — le parsing manuel est préférable. Si le schéma est fixe — la désérialisation automatisée réduit le code de 60 à 70 %.

En quoi le parsing diffère de la désérialisation

Le parsing est une opération plus large : il peut être effectué en mode streaming et ne crée pas nécessairement un objet typé. La désérialisation est un cas particulier du parsing dont le résultat est toujours une instance d'une classe connue avec des types de propriétés spécifiques. Un analyseur JSON décompose un document en Map ou JsonElement, tandis qu'un désérialiseur transforme le même JSON en un objet User, Order ou Product avec des champs et des types connus.

Le parsing en streaming est le principal avantage du parsing sur la désérialisation. XmlPullParser sur Android analyse XML au fur et à mesure de la lecture, sans charger le document entier en RAM. C'est essentiel pour les réponses API volumineuses, l'analyse de flux RSS contenant des centaines d'éléments ou le traitement de tableaux de milliers d'objets JSON provenant d'un vidage de serveur. Un analyseur en streaming lit token par token, consommant une quantité constante de mémoire quelle que soit la taille du document.

Parsing JSON dans les applications mobiles

JSON est le format d'échange de données dominant. Sur iOS, JSONSerialization intégré analyse JSON en Any, tandis que JSONDecoder analyse directement en une structure Codable. Sur Android, org.json standard fournit JSONObject et JSONArray pour l'analyse manuelle. Gson et Moshi ajoutent une conversion automatique. Le choix entre les approches manuelles et automatisées est la première décision architecturale de la couche réseau.

val jsonString = """{"users":[{"id":1,"name":"Alice"}]}"""
val jsonObject = JSONObject(jsonString)
val usersArray = jsonObject.getJSONArray("users")

for (i in 0 until usersArray.length()) {
    val item = usersArray.getJSONObject(i)
    val id = item.getInt("id")
    val name = item.getString("name")
    // traitement utilisateur
}

Parsing manuel via org.json est utile lorsque la structure de la réponse est inconnue à l'avance ou varie considérablement. Cette approche offre un contrôle total sur la gestion des erreurs et les champs nullables, mais nécessite plus de code standard par rapport à la désérialisation automatisée. Pour les petits projets ou prototypes, c'est acceptable, mais en production, Moshi ou kotlinx.serialization sont préférés.

JsonReader pour le parsing en streaming

JsonReader de la bibliothèque Moshi est un outil puissant pour le parsing JSON en streaming. Il lit le document token par token en utilisant des méthodes comme beginObject, nextName, nextString, nextInt et endObject. Cette approche permet de traiter des documents de toute taille avec une consommation mémoire constante. Selon Google (2026), le parsing en streaming via JsonReader est 2 à 3 fois plus rapide que le chargement du document entier dans un JsonObject et consomme jusqu'à 80 % de mémoire en moins.

val reader = JsonReader(StringReader(json))
reader.beginObject()
while (reader.hasNext()) {
    val name = reader.nextName()
    when (name) {
        "id" -> val id = reader.nextInt()
        "name" -> val name = reader.nextString()
        "email" -> val email = reader.nextString()
        else -> reader.skipValue()
    }
}
reader.endObject()

L'exemple montre JsonReader analysant JSON en mode streaming. Chaque appel à nextName() et nextInt() avance le curseur vers le token suivant. skipValue() ignore les champs inutiles sans les analyser — particulièrement utile lorsque JSON contient 50 champs mais que seuls 3 sont nécessaires. Le résultat est une consommation mémoire minimale et une vitesse maximale.

Parsing XML et CSV

XML continue d'être utilisé dans les projets Android pour les ressources et dans les services SOAP des applications d'entreprise. Sur Android, XmlPullParser intégré offre un parsing en streaming avec une consommation mémoire minimale — il ne charge pas d'arbre DOM mais génère des événements START_TAG, TEXT, END_TAG. iOS utilise XMLParser avec une approche déléguée : les méthodes parser(didStartElement:) et parser(foundCharacters:) traitent les éléments séquentiellement.

CSV dans le développement mobile

CSV est le format le plus simple pour exporter et importer des données tabulaires. Dans les applications mobiles, CSV est utilisé pour l'exportation de rapports, le chargement de données de référence (listes de pays, devises, codes) et la synchronisation de données hors ligne. Les bibliothèques de streaming sont adaptées au parsing CSV : Apache Commons CSV et OpenCSV traitent les fichiers ligne par ligne, en échappant les guillemets et les virgules dans les valeurs. Sur iOS, le parsing CSV peut être implémenté via la méthode de délimiteur NSString.components(separatedBy:) avec gestion des cas limites.

class CSVParser: NSObject, XMLParserDelegate {
    private var currentItem: [String: String] = [:]
    private var currentElement: String = ""

    func parser(
        _ parser: XMLParser,
        didStartElement elementName: String,
        namespaceURI: String?,
        qualifiedName qName: String?,
        attributes attributeDict: [String: String]
    ) {
        currentElement = elementName
        if elementName == "item" {
            currentItem = [:]
        }
    }

    func parser(_ parser: XMLParser,
                foundCharacters string: String) {
        currentItem[currentElement] = string
    }
}

Exemple d'un délégué XMLParser sur iOS pour analyser un flux RSS. La méthode didStartElement est appelée à chaque balise ouvrante, foundCharacters retourne le contenu textuel entre les balises, didEndElement termine l'élément. Cette architecture événementielle permet de traiter XML de toute taille sans charger d'arbre DOM en mémoire — essentiel pour les ressources limitées des appareils mobiles.

Comparaison des bibliothèques CSV pour Android

Sur Android, le choix de l'analyseur CSV dépend du volume de données. OpenCSV prend en charge une API fluide, des annotations pour le mappage POJO et des délimiteurs personnalisés. Apache Commons CSV est de plus bas niveau mais plus rapide sur les fichiers volumineux. Pour les cas simples (1 à 2 colonnes), l'analyse manuelle via String.split(",") avec gestion d'échappement est suffisante. Pour les projets de production avec de gros fichiers CSV, OpenCSV est recommandé.

Protobuf et parsing en streaming

Protocol Buffers de Google est un format de sérialisation binaire qui surpasse JSON en vitesse et en compacité. Un message Protobuf prend 3 à 6 fois moins de place que le JSON équivalent et s'analyse 4 à 10 fois plus rapidement grâce à son format binaire et à son schéma rigide. Les principaux inconvénients sont l'absence de lisibilité humaine et la nécessité de générer du code à partir de fichiers .proto via le compilateur protoc.

Le parsing en streaming de Protobuf est implémenté via CodedInputStream — le client lit les champs au fur et à mesure de leur arrivée sans charger la totalité du message. Chaque champ a une balise (numéro + type) et l'analyseur peut ignorer les champs inconnus. Selon Google (2026), le parsing en streaming de Protobuf consomme jusqu'à 90 % de mémoire en moins lors du traitement de messages à partir de 1 Mo, ce qui est essentiel pour les appareils mobiles avec une RAM limitée. Protobuf-lite est une version spéciale pour Android, optimisée pour la taille du code généré.