XML y validación tradicional
Índice
En el ámbito de XML existen dos tecnologías para definir la estructura de un XML:
- DTD (Document Type Definition): mecanismo muy simple que, con una sintaxis propia (no XML), define la estructura o esquema de un XML.
- XSD (XML Schema Definition): se trata de un estándar más moderno y mucho más potente que utiliza XML para definir la estructura o esquema de un XML.
Para que veas la diferencia, antes de entrar de lleno en esquemas, de DTD y XSD, y sobre todo las limitaciones de DTD, imagina que queremos definir que un elemento <edad> solo admita números enteros positivos:
En DTD no hay forma de obligar a que sea un número y solo puede decir que el elemento contiene texto:
<!ELEMENT edad (#PCDATA)>En XSD podemos definir explícitamente que el tipo de dato es un entero positivo:
<xs:element name="edad" type="xs:positiveInteger"/>
En este apartado nos vamos a centrar en XSD para ver cómo definir esquemas para documentos XML.
Antes de empezar
Antes de meternos de lleno en XSD es necesario recordar que un documento XML podía:
- Estar bien (o mal) formado.
- Ser válido (o no válido).
Durante la primera unidad ya estudiamos y profundizamos en la estructura, si estaban o no bien formados, los XML. Ahora toca profundizar en la validez. Un documento XML será válido si cumple con el esquema XSD.
Se puede concluir a partir de lo anteriormente comentado que un documento XML debe estar acompañado de un XSD para poder validarlo.
Hace falta también recordar qué eran los espacios de nombre porque el lenguaje de definición de esquemas se encuentra en el espacio de nombres xmlns:xs="http://www.w3.org/2001/XMLSchema", utilizándose el prefijo xsd o xs.
Para abrir boca
Para entender cómo se estructura un esquema XSD en la práctica, vamos a ver un ejemplo muy sencillo. Imagina que queremos definir un documento XML para representar un libro.
El documento XML de datos (libro.xml) sería así:
<?xml version="1.0" encoding="UTF-8"?>
<libro>
<titulo>El Quijote</titulo>
<anyo>1605</anyo>
</libro>
Y su correspondiente esquema de validación en XSD (libro.xsd) sería el siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="libro">
<xs:complexType>
<xs:sequence>
<xs:element name="titulo" type="xs:string"/>
<xs:element name="anyo" type="xs:integer"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Como puedes observar a simple vista, el esquema utiliza etiquetas XML para definir la jerarquía, indicando qué elementos son obligatorios, qué estructura contienen y de qué tipo de datos (string, integer) son.
A continuación, vamos a desglosar en detalle los tipos de elementos y las estructuras que podemos definir.
Elementos y tipos en XSD
En un esquema XSD, todos los datos que formarán parte de nuestro XML se clasifican fundamentalmente en dos grandes grupos según su naturaleza:
Elementos simples: son aquellos que contienen únicamente un valor de texto (o datos atómicos como números, fechas, booleanos) y no pueden tener atributos ni elementos hijos. Ejemplo:
<xs:element name="titulo" type="xs:string"/>- Elementos complejos: Son aquellos que contienen otros elementos en su interior (elementos hijos) o bien atributos. Requieren el uso de constructores como
xs:complexType. Ejemplo: el elemento<libro>del ejemplo anterior, que engloba al título y al año.
En cuanto a los tipos, en el 90% de los casos, vas a usar los siguientes:
xs:string: para cadenas de texto (ej. nombres, descripciones, direcciones).xs:integer: para números enteros (ej. edad, cantidad de stock).xs:decimal: para números con decimales (ej. precios, notas de exámenes).xs:boolean: para valores lógicos (true o false).xs:date: para fechas en formato estándar ISO (YYYY-MM-DD).
Estructura de un XSD
Un documento XSD sigue una jerarquía muy lógica:
- La raíz global que es el elemento que lo envuelve todo y donde se define el espacio de nombres (
<xs:schema>) - El elemento principal que contiene todo el documento XML definido con
xs:elementyxs:complexType - La secuencia (
<xs:sequence>) que obliga a que los hijos aparezcan en ese orden exacto o el conjunto (<xs:all>) si no importa el orden en que aparezcan los elementos - Los campos finales con su tipo (
xs:string,xs:integer, etc)
Para aclararlo, aquí tienes un ejemplo de XSD donde puedes ver esa estructura jerárquica:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <!-- 1. Raíz global -->
<xs:element name="empresa"> <!-- 2. Elemento principal (Caja contenedora) -->
<xs:complexType>
<xs:sequence> <!-- 3. Secuencia de orden -->
<xs:element name="nombre" type="xs:string"/> <!-- 4. Campo final -->
<xs:element name="empleados" type="xs:integer"/> <!-- 4. Campo final -->
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
Restricciones en un XSD
Además de definir la estructura y el tipo de dato básico (que un campo sea un entero, un text, etc), en muchas ocasiones necesitamos acotar y afinar las reglas de validación, es decir, tenemos que indicar restricciones. Por ejemplo:
- Asegurar que una edad esté entre 18 y 100 años,
- que un código postal tenga exactamente 5 caracteres,
- que un campo de texto solo admita ciertos valores predeterminados (como "rojo" o "azul"),
- etc.
Para lograr esto, XSD utiliza el elemento <xs:simpleType> combinado con <xs:restriction>, indicando sobre qué tipo base actúa y aplicando las reglas de restricción necesarias.
Las restricciones más utilizadas en el desarrollo de aplicaciones son las siguientes:
- Longitud de cadenas:
xs:length: fija una longitud exacta.xs:minLength/xs:maxLength: establecen un rango mínimo y máximo de caracteres.Ejemplo:
<xs:element name="codigoPostal"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:length value="5"/> </xs:restriction> </xs:simpleType> </xs:element>
- Rangos numéricos:
xs:minInclusive/xs:maxInclusive: valor mínimo y máximo permitido (incluidos).xs:minExclusive/xs:maxExclusive: valor mínimo y máximo (excluidos).Ejemplo:
<xs:element name="edad"> <xs:simpleType> <xs:restriction base="xs:integer"> <xs:minInclusive value="0"/> <xs:maxInclusive value="120"/> </xs:restriction> </xs:simpleType> </xs:element>
- Listas de valores permitidos (enumeraciones):
xs:enumeration: obliga a que el valor del documento XML coincida estrictamente con uno de los elementos de la lista cerrada.Ejemplo:
<xs:element name="talla"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:enumeration value="XS"/> <xs:enumeration value="S"/> <xs:enumeration value="M"/> <xs:enumeration value="L"/> <xs:enumeration value="XL"/> </xs:restriction> </xs:simpleType> </xs:element>
- Patrones y expresiones regulares:
xs:pattern: permite validar formatos complejos mediante expresiones regulares. Es extremadamente útil para matrículas, códigos de producto, DNI o emails sencillos.Ejemplo (para un código que exige 3 letras mayúsculas seguidas de 3 números, tipo
ABC123):<xs:element name="codigoProducto"> <xs:simpleType> <xs:restriction base="xs:string"> <xs:pattern value="[A-Z]{3}[0-9]{3}"/> </xs:restriction> </xs:simpleType> </xs:element>
Asociación y validación
Una vez que ya sabemos crear un esquema XSD (nuestro "molde") y tenemos nuestro documento XML de datos, necesitamos un mecanismo para unir ambos ficheros y comprobar de forma automática si los datos cumplen las reglas.
Asociación del esquema al XML:
Para que un fichero XML sepa qué XSD debe usar para validarse, se utilizan los atributos de los espacios de nombres de instancia de XML Schema (xsi). En la etiqueta raíz del documento XML añadimos lo siguiente:
<?xml version="1.0" encoding="UTF-8"?>
<libro xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="libro.xsd">
<titulo>El Quijote</titulo>
<anyo>1605</anyo>
</libro>
¿Qué significan estos atributos?
xmlns:xsi: habilita el espacio de nombres oficial para las instancias de validación.xsi:noNamespaceSchemaLocation: indica la ruta o el nombre del fichero.xsdlocal que contiene las reglas de validación (en este caso,libro.xsd).
Validación en la práctica (herramientas):
Para comprobar si el XML es válido o no, no necesitamos programas complejos. En entornos de desarrollo como Visual Studio Code, si instalamos una extensión estándar de soporte XML (como la extensión XML de Red Hat):
- El propio editor lee automáticamente la asociación del esquema.
- Si escribimos algo mal (por ejemplo, ponemos texto en el campo
anyoo nos dejamos un campo obligatorio), VS Code subrayará el error en rojo al instante y nos mostrará un mensaje descriptivo. - Si todo es correcto, no aparecerá ningún aviso, confirmando que nuestro documento es 100% válido.