XML

Bases de Datos XML

  • Databases
  • Almacenamiento de documentos XML nativo
  • Consultas mediante XQuery y XPath
  • Bases de datos como eXist-db, BaseX
  • Ventajas para datos semi-estructurados

Consulta y Transformación XML

XSLT (Extensible Stylesheet Language Transformations)

  • Lenguaje para transformar documentos XML
  • Convierte XML a otros formatos (HTML, PDF, texto)
  • Utiliza plantillas (templates) para procesar nodos
  • Transformación XSLT y probador en línea
  • [XSLT MDN](https://developer.mozilla.org/es/docs/Web/XSLT)

Características XSLT

  • Procesamiento basado en reglas
  • Transformación de estructura y contenido
  • Soporte para condicionales y bucles
  • Múltiples documentos de salida

XQuery

  • Lenguaje de consulta para documentos XML
  • Similar a SQL pero para datos XML
  • Consultas complejas sobre colecciones XML
  • xquery

XPath

Conceptos Fundamentales XML

XML (eXtensible Markup Language)

  • Lenguaje de marcado extensible
  • Almacenamiento e intercambio de datos
  • Estructura jerárquica y auto-descriptiva
  • Sintaxis estricta con etiquetas de apertura y cierre

Aplicaciones XML

  • multi step form, con xhtml
  • Configuraciones y preferencias
  • Intercambio de datos entre sistemas
  • Documentación técnica
  • Feeds RSS y Atom

XHTML (EXtensible HyperText Markup Language)

  • Reformulación de HTML como aplicación XML
  • Sintaxis más estricta que HTML
  • Compatible con analizadores XML
  • XHTML - MDN

Características XHTML

  • Todas las etiquetas deben cerrarse
  • Anidamiento correcto requerido
  • Atributos entre comillas
  • Elementos en minúsculas

Tecnologías Relacionadas

Esquemas y Validación

  • DTD (Document Type Definition)
  • XML Schema (XSD)
  • RELAX NG

Procesamiento XML

  • SAX (Simple API for XML)
  • DOM (Document Object Model)
  • StAX (Streaming API for XML)

Formatos Basados en XML

  • SVG (gráficos vectoriales)
  • MathML (fórmulas matemáticas)
  • Office Open XML (documentos Office)

XSD (XML Schema Definition)

¿Qué es XSD?

  • Lenguaje basado en XML para definir la estructura y restricciones de documentos XML
  • Alternativa más potente y expresiva que DTD
  • Permite validar tanto la estructura como el contenido de un XML
  • Los esquemas XSD son también documentos XML

¿Para qué sirve XSD?

  • Garantizar que un documento XML cumple una estructura esperada
  • Definir reglas de negocio a nivel de datos
  • Facilitar interoperabilidad entre sistemas
  • Detectar errores de forma temprana (validación)

Componentes Principales de XSD

Elementos (xs:element)

  • Definen las etiquetas permitidas en el XML
  • Pueden ser simples o complejos
  • Permiten establecer cardinalidad (minOccurs, maxOccurs)
<xs:element name="nombre" type="xs:string"/>

Tipos de Datos Simples

  • xs:string
  • xs:integer
  • xs:decimal
  • xs:boolean
  • xs:date, xs:dateTime
  • xs:float, xs:double

Tipos Complejos (xs:complexType)

  • Definen elementos que contienen otros elementos o atributos
  • Pueden tener secuencias, elecciones o todos
<xs:complexType name="persona">
  <xs:sequence>
    <xs:element name="nombre" type="xs:string"/>
    <xs:element name="edad" type="xs:integer"/>
  </xs:sequence>
</xs:complexType>

Modelos de Contenido

xs:sequence

  • Los elementos deben aparecer en el orden definido

xs:choice

  • Solo uno de los elementos puede aparecer

xs:all

  • Todos los elementos pueden aparecer en cualquier orden (una sola vez)

Atributos (xs:attribute)

  • Definen atributos dentro de elementos
  • Pueden ser obligatorios u opcionales
<xs:attribute name="id" type="xs:ID" use="required"/>

Restricciones y Validaciones

Restricciones de Valor (xs:restriction)

  • Limitar valores posibles
  • Definir rangos, longitudes o patrones
<xs:simpleType name="codigoPostal">
  <xs:restriction base="xs:string">
    <xs:pattern value="[0-9]{5}"/>
  </xs:restriction>
</xs:simpleType>

Enumeraciones

  • Lista cerrada de valores permitidos
<xs:enumeration value="activo"/>
<xs:enumeration value="inactivo"/>

Namespaces en XSD

  • Evitan colisiones de nombres
  • Uso de prefijos (xs normalmente)
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

Asociación XML con XSD

  • Mediante atributos en el documento XML
<root xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:noNamespaceSchemaLocation="schema.xsd">

Ventajas de XSD frente a DTD

  • Tipos de datos avanzados
  • Es extensible
  • Basado en XML
  • Mejor control de validaciones
  • Soporte de namespaces

Casos de Uso Comunes

  • Validación de XML en servicios web (SOAP)
  • Definición de contratos de datos
  • Integración entre sistemas heterogéneos
  • Documentación formal de estructuras XML

Herramientas Relacionadas

  • Validadores XSD online
  • Soporte en IDEs (IntelliJ, VS Code, Eclipse)
  • Librerías de validación en Java, Python, .NET

Relación con otras Tecnologías XML

  • XSD + XML → Validación
  • XSD + XPath → Navegación estructural
  • XSD + XSLT → Transformaciones seguras
  • XSD + XQuery → Consultas con tipado fuerte

Procesamiento XML

El procesamiento XML hace referencia a las distintas formas de leer, recorrer, modificar y generar documentos XML mediante APIs y modelos de programación. La elección del método depende del tamaño del documento, el rendimiento requerido y el tipo de operación a realizar.


Modelos de Procesamiento XML

Existen tres enfoques principales:

  • Basado en eventos (SAX)
  • Basado en árbol (DOM)
  • Basado en streaming controlado (StAX)

SAX (Simple API for XML)

¿Qué es SAX?

  • API basada en eventos para procesar XML
  • El parser lee el documento secuencialmente y lanza eventos
  • No carga el XML completo en memoria

Funcionamiento

  • El parser detecta eventos como:

    • Inicio de documento
    • Inicio de elemento
    • Texto
    • Fin de elemento
  • El programador implementa handlers para responder a esos eventos

Características

  • Muy eficiente en memoria
  • Lectura rápida
  • No permite navegación hacia atrás
  • El XML es de solo lectura

Ventajas

  • Ideal para XML muy grandes
  • Bajo consumo de memoria
  • Alto rendimiento

Desventajas

  • Código más complejo
  • Difícil de mantener
  • No se puede modificar el documento directamente

Casos de Uso

  • Procesamiento de logs en XML
  • Importación masiva de datos
  • Validación de grandes documentos

DOM (Document Object Model)

¿Qué es DOM?

  • Modelo basado en árbol
  • El XML completo se carga en memoria
  • Cada nodo es un objeto manipulable

Funcionamiento

  • El documento XML se convierte en un árbol
  • Permite acceso libre a cualquier nodo
  • Soporta lectura, modificación y escritura

Características

  • Acceso aleatorio a nodos
  • Navegación bidireccional
  • Fácil integración con XPath

Ventajas

  • API intuitiva
  • Fácil de entender y depurar
  • Ideal para transformaciones y ediciones

Desventajas

  • Alto consumo de memoria
  • No recomendable para documentos grandes

Casos de Uso

  • Editores XML
  • Transformaciones con XSLT
  • Configuraciones pequeñas y medianas

StAX (Streaming API for XML)

¿Qué es StAX?

  • API de streaming controlada por el programador
  • Modelo pull (el programa pide los eventos)
  • Alternativa moderna a SAX

Funcionamiento

  • El desarrollador controla el avance del parser
  • Se procesan eventos uno a uno
  • Permite mayor flexibilidad que SAX

Características

  • Streaming bidireccional
  • Bajo consumo de memoria
  • Más control del flujo

Ventajas

  • Código más legible que SAX
  • Eficiente y flexible
  • Permite escritura de XML

Desventajas

  • Más compleja que DOM
  • Menos intuitiva para principiantes

Casos de Uso

  • Procesamiento incremental
  • Servicios web
  • Aplicaciones de alto rendimiento

Comparativa SAX vs DOM vs StAX

Característica SAX DOM StAX
Modelo Eventos (push) Árbol Streaming (pull)
Memoria Muy baja Alta Baja
Modificación XML ❌ ✅ ✅
Facilidad de uso Baja Alta Media
Rendimiento Muy alto Medio Alto

Relación con Otras Tecnologías XML

  • SAX / StAX + XSD → Validación en streaming
  • DOM + XPath → Navegación sencilla
  • DOM + XSLT → Transformaciones estructurales
  • StAX + Servicios Web → Procesamiento eficiente

¿Cuál elegir?

  • SAX → XML muy grande y solo lectura
  • DOM → XML pequeño/mediano con modificaciones
  • StAX → Streaming eficiente con control total

Resumen

  • SAX: rápido y ligero, pero complejo
  • DOM: sencillo y potente, pero consume memoria
  • StAX: equilibrio entre control y eficiencia

    Procesamiento XML: Ejemplos de Código y Casos de Uso

Esta nota muestra ejemplos prácticos de código y casos reales para los tres principales modelos de procesamiento XML: SAX, DOM y StAX. Los ejemplos están pensados para entender cuándo y cómo usar cada uno.


SAX (Simple API for XML)

Caso de Uso

  • Lectura de XML muy grandes
  • Importación masiva de datos
  • Procesamiento secuencial sin necesidad de modificar el documento

Ejemplo típico: leer un archivo XML de millones de registros y extraer ciertos valores.

Ejemplo SAX (Java)

import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;

public class MiSAXHandler extends DefaultHandler {

    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) {
        if (qName.equals("persona")) {
            System.out.println("Inicio de persona, id: " + attributes.getValue("id"));
        }
    }

    @Override
    public void characters(char[] ch, int start, int length) {
        String texto = new String(ch, start, length).trim();
        if (!texto.isEmpty()) {
            System.out.println("Texto: " + texto);
        }
    }
}

Ventajas en la práctica

  • Muy rápido
  • Consumo mínimo de memoria

Limitación clave

  • No se puede volver atrás ni modificar el XML

DOM (Document Object Model)

Caso de Uso

  • XML pequeño o mediano
  • Necesidad de leer, modificar y guardar el documento
  • Navegación compleja entre nodos

Ejemplo típico: editar un archivo de configuración XML.

Ejemplo DOM (Java)

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse("personas.xml");

NodeList personas = doc.getElementsByTagName("persona");

for (int i = 0; i < personas.getLength(); i++) {
    Element persona = (Element) personas.item(i);
    String nombre = persona.getElementsByTagName("nombre").item(0).getTextContent();
    System.out.println(nombre);
}

Modificación del XML

persona.getElementsByTagName("nombre").item(0).setTextContent("Nuevo Nombre");

Ventajas en la práctica

  • Muy intuitivo
  • Fácil de combinar con XPath y XSLT

Desventaja clave

  • Alto consumo de memoria

StAX (Streaming API for XML)

Caso de Uso

  • Procesamiento eficiente
  • Streaming con control total del flujo
  • Servicios web y sistemas de alto rendimiento

Ejemplo típico: leer XML progresivamente y generar otro XML.

Ejemplo StAX (Java)

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader reader = factory.createXMLEventReader(new FileInputStream("personas.xml"));

while (reader.hasNext()) {
    XMLEvent event = reader.nextEvent();

    if (event.isStartElement()) {
        StartElement start = event.asStartElement();
        if (start.getName().getLocalPart().equals("persona")) {
            System.out.println("Persona encontrada");
        }
    }
}

Escritura XML con StAX

XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
XMLStreamWriter writer = outputFactory.createXMLStreamWriter(System.out);

writer.writeStartDocument();
writer.writeStartElement("persona");
writer.writeAttribute("id", "1");
writer.writeStartElement("nombre");
writer.writeCharacters("Ana");
writer.writeEndElement();
writer.writeEndElement();
writer.writeEndDocument();

Ventajas en la práctica

  • Más flexible que SAX
  • Menor consumo que DOM

Desventaja clave

  • Más compleja que DOM

Comparativa con Casos Reales

Escenario API Recomendada
XML gigante solo lectura SAX
Editar configuración XML DOM
Servicio web de alto rendimiento StAX
Transformaciones complejas DOM + XSLT
Procesamiento incremental StAX

Elección Rápida (Examen)

  • SAX → rápido, ligero, solo lectura
  • DOM → fácil, modificable, consume memoria
  • StAX → equilibrio entre control y rendimiento

Conclusión

No existe un método mejor que otro:

  • SAX prioriza rendimiento
  • DOM prioriza simplicidad
  • StAX prioriza control y eficiencia

La elección depende del tamaño del XML y del tipo de operación requerida.

Consulta y Transformación XML: Ejemplos de Código y Casos de Uso

Esta nota desarrolla XSLT, XQuery y XPath con ejemplos prácticos de código y escenarios reales de uso. Estas tecnologías permiten consultar, filtrar y transformar documentos XML de forma declarativa.


XPath

¿Para qué se usa XPath?

  • Seleccionar nodos dentro de un documento XML
  • Filtrar información específica
  • Base para XSLT y XQuery

Caso de Uso

  • Extraer datos concretos sin recorrer manualmente el XML
  • Selección de nodos en validaciones, transformaciones y consultas

XML de Ejemplo

<personas>
  <persona id="1">
    <nombre>Ana</nombre>
    <edad>30</edad>
  </persona>
  <persona id="2">
    <nombre>Carlos</nombre>
    <edad>25</edad>
  </persona>
</personas>

Ejemplos XPath

/personas/persona            // Todas las personas
//persona[@id='1']            // Persona con id=1
//persona[nombre='Ana']       // Persona llamada Ana
//persona/edad/text()         // Edades
//persona[edad>26]            // Personas mayores de 26

Ventaja clave

  • Sintaxis concisa y potente

XSLT (Extensible Stylesheet Language Transformations)

Caso de Uso

  • Convertir XML a HTML, texto o PDF
  • Cambiar la estructura del documento
  • Generar informes y vistas

Ejemplo típico: mostrar datos XML como una tabla HTML.

XML de Entrada

<personas>
  <persona>
    <nombre>Ana</nombre>
    <edad>30</edad>
  </persona>
  <persona>
    <nombre>Carlos</nombre>
    <edad>25</edad>
  </persona>
</personas>

XSLT → HTML

<xsl:stylesheet version="1.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:template match="/">
    <html>
      <body>
        <h2>Lista de Personas</h2>
        <table border="1">
          <tr><th>Nombre</th><th>Edad</th></tr>
          <xsl:for-each select="personas/persona">
            <tr>
              <td><xsl:value-of select="nombre"/></td>
              <td><xsl:value-of select="edad"/></td>
            </tr>
          </xsl:for-each>
        </table>
      </body>
    </html>
  </xsl:template>

</xsl:stylesheet>

Características mostradas

  • Templates
  • XPath embebido
  • Bucles (xsl:for-each)

Casos de Uso Reales

  • Generación de informes
  • Vistas web desde XML
  • Transformaciones en backend

XQuery

¿Para qué se usa XQuery?

  • Consultar colecciones de documentos XML
  • Filtrar, ordenar y construir nuevos XML
  • Muy usado en bases de datos XML (eXist-db, BaseX)

Caso de Uso

  • Consultas complejas similares a SQL
  • Integración con bases de datos XML

Ejemplo XQuery

for $p in /personas/persona
where $p/edad > 26
order by $p/nombre
return <persona>{ $p/nombre }</persona>

Resultado

<persona>
  <nombre>Ana</nombre>
</persona>

Construcción de XML

<resultado>
{
  for $p in /personas/persona
  return <nombre>{data($p/nombre)}</nombre>
}
</resultado>

Ventaja clave

  • Muy expresivo para consultas complejas

Comparativa Práctica

Tecnología Uso Principal Ejemplo Real
XPath Seleccionar nodos Filtrado de datos
XSLT Transformar XML XML → HTML
XQuery Consultar XML Base de datos XML

Uso Combinado

  • XPath → Selección
  • XSLT → Transformación
  • XQuery → Consulta avanzada

Ejemplo típico:

  • XPath selecciona nodos
  • XSLT transforma resultados
  • XQuery consulta grandes colecciones

Elección Rápida (Examen)

  • XPath → localizar nodos
  • XSLT → transformar documentos
  • XQuery → consultar datos XML

Conclusión

Estas tres tecnologías forman el núcleo del procesamiento declarativo XML:

  • XPath es la base
  • XSLT transforma
  • XQuery consulta y construye

Juntas permiten explotar al máximo documentos y bases de datos XML.

Recursos y Herramientas XML (Estado 2025–2026)

Nota de referencia con herramientas, editores, procesadores y recursos online para trabajar con XML, XSD, XPath, XSLT y XQuery, actualizada al estado del ecosistema en 2026.


🛠️ Editores e IDEs XML

Oxygen XML Editor

  • IDE profesional multiplataforma (Windows, macOS, Linux)
  • Soporte completo para XML, XSD, RELAX NG, Schematron
  • XSLT, XPath y XQuery con depuración
  • Muy usado en documentación técnica y entornos académicos

🔗 https://www.oxygenxml.com/


Altova XMLSpy

  • IDE avanzado para XML, JSON y servicios web
  • Excelente soporte visual para XSD y validación
  • Depurador XPath / XSLT integrado
  • Integración con RaptorXML

🔗 https://www.altova.com/xmlspy-xml-editor


Liquid XML Studio

  • IDE XML centrado en entorno Windows (.NET)
  • Validación XML/XSD y diseño visual
  • Orientado a flujos empresariales

🔗 https://www.liquid-technologies.com/xml-editor


Visual Studio Code (VS Code)

  • Editor ligero con extensiones XML
  • Buen soporte para XSD, XPath y validación
  • Ideal para proyectos mixtos (XML + código)

🔗 https://code.visualstudio.com/


⚙️ Procesadores XSLT / XQuery / XPath

Saxon

  • Procesador de referencia para XSLT, XPath y XQuery
  • Soporte hasta XSLT 3.0 y XPath 3.1
  • Versiones HE (open-source), PE y EE
  • Muy usado en producción

🔗 https://www.saxonica.com/


RaptorXML

  • Motor de validación y transformación de alto rendimiento
  • Soporte XML, XSD, XSLT, XQuery
  • Usado en pipelines y CI/CD

🔗 https://www.altova.com/raptorxml


🧪 Validación Avanzada

Schematron

  • Lenguaje de validación basado en reglas
  • Complementa XSD para reglas de negocio complejas
  • Implementado normalmente vía XSLT

🔗 https://schematron.com/


RELAX NG

  • Lenguaje alternativo a XSD
  • Sintaxis más simple y expresiva
  • Muy usado en documentación técnica

🔗 https://relaxng.org/


🗄️ Bases de Datos XML Nativas

eXist-db

  • Base de datos XML nativa
  • Soporte completo de XQuery y XPath
  • Ideal para colecciones XML grandes

🔗 https://exist-db.org/


BaseX

  • Base de datos XML ligera y rápida
  • Muy usada en entornos académicos
  • Excelente soporte XQuery

🔗 https://basex.org/


🌐 Herramientas Online y Testing

MagicTool – XSLT Online

  • Transformación XSLT directamente en el navegador
  • Ideal para pruebas rápidas

🔗 https://magictool.ai/tool/xslt-transformation/es/


W3Schools – XPath / XSLT / XQuery

  • Referencias y ejemplos prácticos
  • Entorno de pruebas interactivo

🔗 https://www.w3schools.com/xml/


MDN Web Docs – XML & XSLT

  • Documentación técnica clara y actualizada
  • Enfoque web

🔗 https://developer.mozilla.org/es/docs/Web/XML 🔗 https://developer.mozilla.org/es/docs/Web/XSLT


📚 Documentación Oficial y Estándares

W3C – XML Technologies

  • Especificaciones oficiales
  • XSD, XPath, XSLT, XQuery

🔗 https://www.w3.org/XML/


📈 Estado del Ecosistema XML en 2026

  • XML sigue siendo clave en sistemas empresariales, documentación y publishing
  • XSLT 3.0 y XPath 3.1 son estándares consolidados
  • XML convive con JSON, pero es superior para datos fuertemente estructurados
  • Bases de datos XML siguen vigentes en nichos específicos

🧠 Recomendación Rápida

Necesidad Herramienta
IDE profesional Oxygen XML / XMLSpy
Transformaciones Saxon
Validación avanzada Schematron
DB XML BaseX / eXist-db
Pruebas rápidas MagicTool

📌 Nota Final

Este stack sigue siendo muy relevante en 2026 para:

  • Integración de sistemas
  • Publicación técnica
  • Flujos ETL
  • Servicios empresariales

XML no está obsoleto: está especializado.

XML – Casos de Uso e Implementación

Esta nota resume casos de uso reales de XML y muestra cómo se implementan usando las tecnologías vistas: XSD, XPath, XSLT, XQuery y APIs de procesamiento (DOM / SAX / StAX).


1️⃣ Intercambio de Datos entre Sistemas

Caso de Uso

  • Comunicación entre sistemas heterogéneos
  • Integración entre aplicaciones empresariales
  • Contratos de datos estables

Ejemplo típico: intercambio de pedidos entre empresas.

Implementación

  • XML → formato de datos
  • XSD → contrato y validación
  • DOM / SAX → lectura desde backend
<pedido id="P1">
  <cliente>Ana</cliente>
  <total>120.50</total>
</pedido>
<xs:element name="pedido">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="cliente" type="xs:string"/>
      <xs:element name="total" type="xs:decimal"/>
    </xs:sequence>
    <xs:attribute name="id" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

2️⃣ Validación de Datos y Reglas de Negocio

Caso de Uso

  • Asegurar integridad de datos
  • Detectar errores antes del procesamiento

Implementación

  • XSD → estructura y tipos
  • Schematron → reglas de negocio

Ejemplo de regla:

  • Si el total es mayor de 1000, debe existir un descuento

3️⃣ Generación de Informes y Vistas Web

Caso de Uso

  • Mostrar XML como HTML
  • Generar informes automáticamente

Implementación

  • XSLT para transformar XML → HTML
  • XPath para seleccionar datos
<xsl:for-each select="personas/persona">
  <p><xsl:value-of select="nombre"/></p>
</xsl:for-each>

Usado en:

  • Publicación técnica
  • Dashboards estáticos

4️⃣ Consulta de Grandes Colecciones XML

Caso de Uso

  • Repositorios documentales
  • Bases de datos XML nativas

Implementación

  • XQuery + BaseX / eXist-db
for $p in /personas/persona
where $p/edad > 30
return $p/nombre

Ventaja:

  • Consultas complejas tipo SQL

5️⃣ Procesamiento de XML Muy Grandes

Caso de Uso

  • Logs
  • Exportaciones masivas
  • Big XML

Implementación

  • SAX o StAX (streaming)
if (event.isStartElement()) {
  if (event.asStartElement().getName().getLocalPart().equals("registro")) {
    // procesar registro
  }
}

Beneficio:

  • Bajo consumo de memoria

6️⃣ Configuración de Aplicaciones

Caso de Uso

  • Archivos de configuración
  • Preferencias de usuario

Implementación

  • DOM para lectura y modificación
  • XPath para acceso rápido

Ejemplo:

/config/puerto

7️⃣ Servicios Web y APIs (SOAP)

Caso de Uso

  • Comunicación estructurada
  • Contratos estrictos

Implementación

  • XML + XSD → contrato
  • XPath → extracción
  • StAX → rendimiento

Usado en:

  • Sistemas legacy
  • Integraciones bancarias

8️⃣ Documentación Técnica y Publishing

Caso de Uso

  • Manuales
  • Normativas
  • Libros técnicos

Implementación

  • XML como fuente única
  • XSLT → HTML / PDF

Ejemplo:

  • DocBook + XSLT

🔁 Flujo de Implementación Típico

  1. Definir estructura → XSD
  2. Validar XML
  3. Consultar datos → XPath / XQuery
  4. Transformar salida → XSLT
  5. Procesar en backend → DOM / SAX / StAX

🧠 Elección Rápida (Examen)

Necesidad Tecnología
Validar estructura XSD
Reglas complejas Schematron
Transformar XML XSLT
Consultar XML XQuery
XML grande SAX / StAX
Editar XML DOM

✅ Conclusión

XML sigue siendo una tecnología clave cuando se necesita:

  • Estructura estricta
  • Validación fuerte
  • Transformaciones complejas

Cada tecnología cumple un rol concreto dentro del ecosistema XML.