Trabalho com XML em Kotlin: bibliotecas e exemplos |…

Trabalho com XML em Kotlin: visão geral das bibliotecas e exemplos práticos

XML (eXtensible Markup Language) continua sendo um dos principais formatos para armazenamento e transmissão de dados estruturados. Na linguagem Kotlin, que roda sobre a JVM, todas as bibliotecas Java para trabalhar com XML estão disponíveis, assim como várias soluções nativas em Kotlin. Neste artigo, veremos três abordagens principais para trabalhar com XML: SimpleXML (parsing baseado em anotações), XStream (serialização rápida) e kotlinx.serialization (biblioteca nativa Kotlin).

1. SimpleXML — parsing de XML baseado em anotações

SimpleXML é uma biblioteca popular para Java/Kotlin que permite converter XML em objetos e vice-versa usando anotações. É ideal quando a estrutura do XML é conhecida antecipadamente.

Adicionando dependência (Gradle):

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

Exemplo: parsing de feed RSS

Suponha que temos um XML com notícias:

<rss version="2.0">    <channel>        <item>            <title>Notícia 1</title>            <link>https://example.com/1</link>        </item>        <item>            <title>Notícia 2</title>            <link>https://example.com/2</link>        </item>    </channel></rss>

Criaremos modelos de dados com anotações:

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 = "")

Parsing do 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("Erro de parsing: ${e.message}")        null    }}

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

Vantagens do SimpleXML: simplicidade, suporte a herança, conversores embutidos para datas e números.

2. XStream — serialização rápida de objetos

XStream é outra biblioteca poderosa que consegue serializar objetos em XML sem anotações. Ela usa reflexão e é adequada para prototipagem.

Adicionando dependência:

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

Exemplo: serialização e desserialização

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)

    // Serialização    val person = Person("João", 30)    val xml = xstream.toXML(person)    println(xml)    // Saída: <person><name>João</name><age>30</age></person>

    // Desserialização    val restored = xstream.fromXML(xml) as Person    println("Nome: ${restored.name}, Idade: ${restored.age}")}

Características do XStream: