Travailler avec XML en Kotlin : bibliothèques et exemples…

Travailler avec XML en Kotlin : aperçu des bibliothèques et exemples pratiques

XML (eXtensible Markup Language) reste l'un des formats clés pour le stockage et la transmission de données structurées. En langage Kotlin, qui fonctionne sur la JVM, toutes les bibliothèques Java pour travailler avec XML sont disponibles, ainsi que plusieurs solutions natives Kotlin. Dans cet article, nous examinerons trois approches principales pour travailler avec XML : SimpleXML (analyse par annotations), XStream (sérialisation rapide) et kotlinx.serialization (bibliothèque native Kotlin).

1. SimpleXML — analyse XML par annotations

SimpleXML est une bibliothèque populaire pour Java/Kotlin qui permet de convertir du XML en objets et vice versa à l'aide d'annotations. Elle est idéale lorsque la structure XML est connue à l'avance.

Ajout de la dépendance (Gradle) :

dependencies {    implementation("org.simpleframework:simple-xml:2.7.1")}

Exemple : analyse d'un flux RSS

Supposons que nous ayons un XML avec des actualités :

<rss version="2.0">    <channel>        <item>            <title>Actualité 1</title>            <link>https://example.com/1</link>        </item>        <item>            <title>Actualité 2</title>            <link>https://example.com/2</link>        </item>    </channel></rss>

Créons les modèles de données avec des annotations :

import org.simpleframework.xml.*

@Root(name = "rss", strict = false)data class Rss(    @field:Element(name = "channel")    var channel: Channel? = null)

@Root(name = "channel", strict = false)data class Channel(    @field:ElementList(inline = true, entry = "item")    var items: List<Item> = emptyList())

@Root(name = "item", strict = false)data class Item(    @field:Element(name = "title")    var title: String = "",

    @field:Element(name = "link")    var link: String = "")

Analyse du XML :

import org.simpleframework.xml.core.Persister

fun parseRss(xmlString: String): Rss? {    return try {        val serializer = Persister()        serializer.read(Rss::class.java, xmlString)    } catch (e: Exception) {        println("Erreur d'analyse : ${e.message}")        null    }}

// Utilisation :val xml = "<rss version=\\"2.0\\">...</rss>" // votre XMLval rss = parseRss(xml)rss?.channel?.items?.forEach { item ->    println("${item.title}: ${item.link}")}

Avantages de SimpleXML : simplicité, prise en charge de l'héritage, convertisseurs intégrés pour les dates et les nombres.

2. XStream — sérialisation rapide d'objets

XStream est une autre bibliothèque puissante qui peut sérialiser des objets en XML sans annotations. Elle utilise la réflexion et convient bien au prototypage.

Ajout de la dépendance :

dependencies {    implementation("com.thoughtworks.xstream:xstream:1.4.20")}

Exemple : sérialisation et désérialisation

import com.thoughtworks.xstream.XStream

data class Person(val name: String, val age: Int)

fun main() {    val xstream = XStream()    xstream.alias("person", Person::class.java)

    // Sérialisation    val person = Person("Jean", 30)    val xml = xstream.toXML(person)    println(xml)    // Sortie : <person><name>Jean</name><age>30</age></person>

    // Désérialisation    val restored = xstream.fromXML(xml) as Person    println("Nom : ${restored.name}, Âge : ${restored.age}")}

Caractéristiques de XStream :