Trabajo con XML en Kotlin: bibliotecas y herramientas para análisis y creación

Trabajo con XML en Kotlin: resumen de bibliotecas y ejemplos prácticos

A pesar de la adopción activa de JSON y YAML, XML sigue siendo un formato demandado en sistemas corporativos, archivos de configuración, protocolos SOAP y desarrollo Android. Kotlin, al ser compatible con Java, proporciona acceso a todas las bibliotecas Java maduras para trabajar con XML, además de tener sus propias soluciones nativas. En este artículo, analizaremos cinco enfoques principales para el procesamiento de XML en Kotlin, incluyendo análisis, creación y validación de documentos.

1. Herramientas integradas: DOM, SAX, StAX

Kotlin utiliza directamente la API estándar de Java para XML. Esta es la forma más sencilla para tareas rápidas, pero requiere mucho código repetitivo.

DOM (Modelo de Objeto de Documento)

Carga todo el XML en memoria y permite acceso aleatorio a los nodos. Adecuado para documentos pequeños.

import javax.xml.parsers.DocumentBuilderFactoryimport org.w3c.dom.Element

fun parseWithDOM(xml: String) {    val factory = DocumentBuilderFactory.newInstance()    val builder = factory.newDocumentBuilder()    val doc = builder.parse(xml.byteInputStream())        val books = doc.getElementsByTagName("book")    for (i in 0 until books.length) {        val book = books.item(i) as Element        val title = book.getElementsByTagName("title").item(0).textContent        println("Libro: $title")    }}

SAX (API Simple para XML)

Analizador de flujo, no carga todo el documento en memoria. Eficiente para archivos grandes, pero complejo de implementar.

import org.xml.sax.helpers.DefaultHandlerimport org.xml.sax.Attributesimport javax.xml.parsers.SAXParserFactory

class BookHandler : DefaultHandler() {    override fun startElement(uri: String, localName: String, qName: String, attributes: Attributes) {        if (qName == "book") {            println("Libro encontrado con id: ${attributes.getValue("id")}")        }    }}

fun parseWithSAX(xml: String) {    val factory = SAXParserFactory.newInstance()    val parser = factory.newSAXParser()    parser.parse(xml.byteInputStream(), BookHandler())}

2. JDOM — API conveniente para Kotlin

JDOM es una biblioteca Java popular que se integra perfectamente con Kotlin gracias al soporte de colecciones y funciones de extensión. Permite leer, modificar y crear XML sin fábricas engorrosas.

Análisis y navegación

import org.jdom2.input.SAXBuilderimport org.jdom2.Element

fun parseWithJDOM(xml: String) {    val builder = SAXBuilder()    val doc = builder.build(xml.byteInputStream())    val root = doc.rootElement        root.getChildren("book").forEach { book ->        val title = book.getChildText("title")        val author = book.getChildText("author")        println("$title — $author")    }}

Creación de XML desde cero

import org.jdom2.Documentimport org.jdom2.Elementimport org.jdom2.output.XMLOutputter

fun createXML(): String {    val root = Element("library")    val book = Element("book").apply {        setAttribute("id", "1")        addContent(Element("title").setText("Kotlin in Action"))        addContent(Element("author").setText("Dmitry Jemerov"))    }    root.addContent(book)    val doc = Document(root)        val outputter = XMLOutputter().apply {        format = org.jdom2.output.Format.getPrettyFormat()    }    return outputter.outputString(doc)}

3. XOM — simplicidad y rigor

XOM se adhiere al principio de "inmutable por defecto": todos los nodos, una vez creados, no se pueden modificar, solo reemplazar. Esto hace que el código sea predecible y seguro. La biblioteca verifica automáticamente la corrección de la estructura.

import nu.xom.Builderimport nu.xom.Serializer

fun parseWithXOM(xml: String) {    val builder = Builder()    val doc = builder.build(xml, null)    val root = doc.rootElement