Aprendiendo XMLSchema a través de ejemplos

Introducción a XML Schema

Cuando intercambiamos información es esencial que los interlocutores estén de acuerdo en relación al formato y contenido de la misma. Esto nos ahorra mucho tiempo, ya que estos no tienen que validar la información, XML Schema lo hace por nosotros automáticamente.

XML Schema es un estándar definido por W3C cuya finalidad es la de definir cual es el formato correcto de un documento XML, más concretamente define:

• Los elementos que pueden aparecer en el documento (incluso en que orden).
• Los atributos que puede tener cada elemento.
• La jerarquía entre elementos, es decir, que elementos hijos puede tener cada elemento.
• El número de hijos que puede tener un elemento.
• El tipo de datos que puede tener un elemento o un atributo.
• Valores por defecto (en caso de que no aparezcan) o incluso valores fijos (en caso de que aparezcan con otros valores) para elementos y atributos.

Los esquemas xml son los sucesores de los DTD y nos ofrecen las siguientes ventajas respecto a ellos:

1. Son más extensibles permitiéndonos más facilidad de cambio en caso de que las necesidades futuras cambien.
2. Están escritos en XML (pueden ser validados).
3. Soportan la definición de tipos de datos.
4. Soportan espacios de nombres (namespaces).

Aplicación Java para validar los documentos XML con esquemas XML (XML Schema)

A continuación vamos a escribir una pequeña clase de utilidad que podremos reutilizar en nuestros proyectos Java para validar un documento XML a través de un esquema XML:

com.autentia.tutoriales.xmlschema.utils.XmlSchemaValidatorUtil

package com.autentia.tutoriales.xmlschema.utils;

import java.io.File;
import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * Clase de utilidad para validar un xml con un schema
 * @author Carlos García. Autentia.
 * @see http://www.mobiletest.es
 */
public class XmlSchemaValidatorUtil {
	
	/**
	 * Valida un documento XML con un esquema XML (XSD).
	 * @param xml Archivo que contiene el documento xml a validar
	 * @param xmlSchema Archivo que contiene el esquema que define el formato válido.
	 * @return El Document (DOM) del archivo xml.
	 * @throws ParserConfigurationException En caso de error de configuración (no debería producirse).
	 * @throws SAXException En caso de detectar un error de validación.
	 * @throws IOException  en caso de error al obtener la información desde los archivos  (no debería producirse).
	 */
	public static Document validate(File xml, File xmlSchema) throws ParserConfigurationException, SAXException, IOException {
		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		
		factory.setNamespaceAware(true);  
		factory.setValidating(true);
		factory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage", "http://www.w3.org/2001/XMLSchema");
		factory.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaSource",   xmlSchema);  


		// Parseando el documento  
		DocumentBuilder documentBuilder = factory.newDocumentBuilder();  
		documentBuilder.setErrorHandler(new ErrorHandler() {
			public void warning(SAXParseException ex) throws SAXException {
				throw ex;
			} 	
			public void error(SAXParseException ex) throws SAXException {
				throw ex;
			}
			public void fatalError(SAXParseException ex) throws SAXException {
				throw ex;
			}				
		});  

		return documentBuilder.parse(xml);  
	}
}
    
    

A continuación vamos a escribir una pequeña aplicación de escritorio para ir validando cada uno de los ejemplos que veremos a continuación:

package com.autentia.tutoriales.xmlschema;

import java.io.File;
import org.w3c.dom.Document;
import com.autentia.tutoriales.xmlschema.utils.XmlSchemaValidatorUtil;

/**
 * Aplicación para validar los XML con un esquema
 * @author Carlos García. Autentia.
 * @see http://www.mobiletest.es
 */
public class ValidatorByXMLSchemaApp  {
	public static void main(String[] args) {
		String xmlFilePath 		= "example1.xml";
		String schemaFilePath	= "example1.xsd";  

		try {
			File	 xml	  = new File(xmlFilePath);
			File	 schema	  = new File(schemaFilePath);
			Document document = XmlSchemaValidatorUtil.validate(xml, schema);
			
			System.out.println("El documento está bien formado y es válido");
			System.out.println(document.getFirstChild().getNodeName());
		} catch (Exception ex) {
			System.out.println(ex);
		}
	}
}    
    

Ejemplos

Conclusiones

Si habéis ejecutado la aplicación y jugado un poco con los documentos xml supongo que habréis aprendido un poco en relación a este estándar de validación.

Ahora bien, aunque lo visto anteriormente cubre un buen porcentaje de las posibilidades de XML Schema, es responsabilidad del lector profundizar más en el tema a través de libros u otros tutoriales.

Carlos García Pérez. Creador de MobileTest, un complemento educativo para los profesores y sus alumnos.

cgpcosmad@gmail.com