Comparación de las Tecnologías Java para XML

Ni la tecnolog�a Java ni la tecnolog�a XML necesitan ninguna introducci�n, ni tampo la sinerg�a entre �mbas "C�digo Portable y Datos Portables". Con el creciente inter�s en los servicios Web y las plataformas de comercio electr�nico, XML se est� uniendo a Java en la caja de herramientas de los desarrolladores. Hasta hoy, no menos de seis extensiones de la Plataforma Java potencian al desarrollador Java cuando construye aplicaciones basadas en XML:

  • Java API for XML Processing (JAXP)
  • Java API for XML/Java Binding (JAXB)
  • Long Term JavaBeans Persistence
  • Java API for XML Messaging (JAXM)
  • Java API for XML RPC (JAX RPC)
  • Java API for XML Registry (JAXR)

Esta p�gina se dirige a la primera, el API Java para Procesar XML (JAXP). Tambi�n se dirige a las tecnolog�as que JAXP proporciona directa o indirectamente al desarrollador Java, o las tecnolog�as que est�n relacionadas con �l para poder porcesar documentos XML, entre otras:

  • SAX, Simple API for XML
  • DOM, Document Object Model API from W3C
  • XSLT, XML Style Sheet Language Transformations from W3C
  • XPath, XML Path Language from W3C
  • JDOM, "Java optimized" document object model API from jdom.org

Esta p�gina est� pensada para ofrecer una introducci�n a los diferentes APIs disponibles presentado algunos programas de ejemplo. Las diferencias de rendimiento se ver�n en la siguiente p�gina, en la tercera p�gina de este tutorial intentaremos ofrecer trucos sobre c�mo mejorar el rendimiento de aplicaciones basadas en XML desde un punto de vista program�tico y arquitectural. Para poder comparar los programas de ejemplo, los hemos aplicado el mismo problema y hemos proporcionado una soluci�n id�ntica. El problema se ha mantenido sencillo para acomodar las diferentes capaciades de estas tecnolog�as. Los programas de ejemplo mostrados aqu� podr�an considerarse como micro-comparaciones. La demostraci�n esencialmente se enfoca en el entendimiento de qu� tecnolog�as se pueden aplicar para procesar documentos de entrada XML; no cubre en detalle la generaci�n de documentos de salida XML.

Este tutorial no cubre XML y el procesamiento Java de XML en profundidad. El lector debe estar familiarizado tanto con XML como con el lenguaje de programaci�n Java.

.�Introducci�n a los Diferentes Modelos de Procesamiento XML

�Qu� significa para una aplicaci�n estar basada en XML, o para entendernos, ser un Servicio Web? Con respecto a XML, principalmente significa que puede consumir documentos XML, aplicar su l�gica de negocio o recuperar informaci�n y generar documentos XML resultantes. Estas tres fases pueden describirse en m�s detalle como:

  1. Procesamiento de entrada XML:
    • Analizar y validar el documento fuente.
    • Reconocer/buscar informaci�n importante bas�ndonse en su localizaci�n o en su etiquetdo en el documento fuente.
    • Extraer la informaci�n importante una vez que se ha localizado.
    • Opcionalmente, mapear/unir la informaci�n recuperada a objetos de negocio.
  2. Manejo de l�gica de negocio:
    • El procesamiento real de la informaci�n de entrada resultando opcionalmente en la generaci�n de informaci�n de salida.
  3. Procesamiento de salida XML:
    • Construir un modelo de documento para generar con DOM, JDOM, etc.
    • Aplicar hojas de estilo SXLT o serializar directamente a XML

SAX y DOM son los modelos de procesamiento m�s comunes. Para usar SAX para procesar un documento XML, tenemos que codificar m�todos para manejar eventos lanzados por el analizador seg�n encuentra diferentes tokens del lenguaje de marcas. Con DOM, tenemos que escribir c�digo para pasar a trav�s de una estructura de datos tipo �rbol creada por el analizador desde el documento fuente. Como un analizador SAX genera un flujo temporal de eventos, se deben hacer en un s�lo ciclo los cuatro paso de procesamiento de entrada XML descritos arriba (nombrado, an�lisis, reconocimiento, extracci�n y mapeo): cada evento capturado es manejado inmediatamente y la informaci�n importante es pasada junto con el evento. Cuando usamos DOM, el procesamiento de la entrada XML se hace al menos en dos ciclos: primero, el analizar DOM crea una estructura de datos tipo �rbol que modela el documento fuente XML (�rbol DOM), luego pasamos a trav�s del �rbol DOM, buscando informaci�n relevante para extraerla y procesarla posteriormene; este �ltimo ciclo se puede repetir tantas veces como sea necesario mientras el �rbol DOM exista en memoria.

Tabla 1: Caracter�siticas SAX y DOM

SAX DOM
Modelo basado en eventos Estructura de datos tipo �rbol
Acceso serie (flujo de eventos) Acceso aleatorio (estructura de datos en memoria
Bajo uso de memoria (s�lo se generan eventos) Alto uso de memoria (todo el documento se carga en memoria
Para procesar partes del documento (capturar eventos importantes) Para editar el documento (procesar la estructura de datos en memoria)
Para procesar el documento s�lo una vez (flujo de eventos temporal). Para procesar el documento m�ltiples veces (documento cargado en memoria).

XSLT es modelo de procesamiento XML de nivel muy superior a SAX y DOM. XSLT requiere que el desarrollador codifique reglas (plantillas) que ser�n aplicadas cuando se encuentren los patrones especificados en el documento fuente. Estos patrones se especifican usando el lenguaje Xpath. Xpath se usa para localizar y extraer informaci�n desde el documento fuente y est� especialmente dirigido a los pasos 1.b y 1.c del procesamiento de XML detallado arriba. Mientras que SAX y DOM requieren que el desarrollador Java escriba c�digo Java, XSLT (a parte del propio motor de invocaci�n) s�lo requiere escribir hojas de estilo que son ellas mismas documentos XML. Comparado con la programaci�n DOM y SAX, la progrmaci�n XSLT podr�a verse como un Script.

Tabla 2: Fases de procesamiento SAX, DOM y XSLT

Fase de Procesamiento SAX DOM XSLT

Procesamiento de entrada XML

Analizar y validar Interno Interno o basado en SAX Basado en SAX o DOM
Reconocer/buscar Capturar eventos con manejadores de eventos Buscar en el �rbol con buscadores Patrones Xpath
Extraer Capturar eventos Obtener valores de atributos, contenidos de nodos: m�todos del API Obtener valores de atributos, contenidos de nodos: sentencias Xpath
Mapear/Unir Crear objetos de negocio desde la informaci�n extra�da Crear objetos de negocio desde la informaci�n extra�da Si lo hay, a trav�s de DOM o SAX (tuber�as)

Procesamiento de salida XML

Construcci�n No hay soporte por defecto, pero se puede hacer generando una secuencia de llamadas a m�todos manejadores de eventos apropiadamente balanceada Parte impl�cita del modelo: API de m�todos factor�a Parte impl�cita del modelo: sentencias XSL.
Serializaci�n No hay soporte por defecto, pero puede hacerse con manejadores de eventos personalizados. Soprote de implementaci�n espec�fico, o a trav�s de transformaciones de identidades XSLT. Parte impl�cita del modelo: metodos de sentencias de salida XSL.

Algunos de los APIs Java disponibles para procesar XML (es decir DOM, XSLT) podr�an estar construidos encima de otros, a�adir m�s niveles de abstracci�n, y por hende m�s potencia, pero tambi�n se podr�an solapar dejando al desarrollador la elecci�n de cu�ndo utilizar uno y cuando otro. El dibujo de abajo muestra las dependencias entre estas tecnolog�as as� como algunas posibilidades (representadas por flechas mono o bi-direccionales) ofrecidas al desarrollador que necesita implementar una aplicaci�n basada en XML:

Ilustraci�n 1:
Una aplicaci�n podr�a generar/procesar documentos XML desde/hacia objetos de negocio, usando SAX, DOM, XPath o XSLT; una aplicaci�n podr�a incluso algunas veces usar un modelo de documento como JDOM para representar las estructuras de datos principales y aplicarles la l�gica de neogocio.

Para todas estas tecnolog�as diferentes, SAX, DOM, XSLT, XPath y JDOM, hemos implementado programas de ejemplo pensadas para comparar los diferentes APIs que est�n siendo usados desde los puntos de vista program�tico (capacidades, facilidad de uso) y de rendimiento. Primero, presentaremos la aplicaci�n de ejemplo dominio, luego presentaremos cada API y describiremos el correspondiente programa de ejemplo.

.�Aplicaci�n de Ejemplo Dominio

Los programas de ejemplo que se presentar�n en este tutorial est�n basados en diferentes APIs de procesamiento aplicados al mismo conjunto de documentos y proporcionan la misma salida. Los documentos XML procesados usan estas diferentes t�cnicas conforme a la misma DTD Document Type Definition o esquema XML. Estos esquemas especifican la representaci�n de un tablero de ajedrez. Para poder comparar posteriormente estos programas de ejemplo, hemos aumentado el tama�o de los documentos procesados (para aumentar la carga de trabajo); los esquemas se ha extendido de forma coherente para describir conjuntos de dichas configuraciones de tablero de ajedrez (desde 10 hasta 5000).

Ilustraci�n 2: Una Configuraci�n de Tablero de Ajedrez

Cada programa procesa un conjunto de configuraciones de tableros de ajedrez sacando la misma configuraci�n en un sencillo formato de texto le�ble por humanos. Las diferentes implementaciones basadas en SAX, DOM, XSLT y XPath cuando se aplican a los mismos documentos de entrada proporcionan la misma salida.

Abajo tenemos dos representaciones de la misma configuraci�n del tablero de ajedrez, una est� en XML y la otra est� en texto normal. La segunda ha sido generada a partir de la primera usando uno de los programas de ejemplo:

C�digo de Ejemplo 1: Una representaci�n XML de una configuraci�n tablero de Ajedrez:

<CHESSBOARD>
 <WHITEPIECES>
  <KING><POSITION COLUMN="G" ROW="1"/></KING>
  <BISHOP><POSITION COLUMN="D" ROW="6"/></BISHOP>
  <ROOK><POSITION COLUMN="E" ROW="1"/></ROOK>
  <PAWN><POSITION COLUMN="A" ROW="4"/></PAWN>
  <PAWN><POSITION COLUMN="B" ROW="3"/></PAWN>
  <PAWN><POSITION COLUMN="C" ROW="2"/></PAWN>
  <PAWN><POSITION COLUMN="F" ROW="2"/></PAWN>
  <PAWN><POSITION COLUMN="G" ROW="2"/></PAWN>
  <PAWN><POSITION COLUMN="H" ROW="5"/></PAWN>
 </WHITEPIECES>
 <BLACKPIECES>
  <KING><POSITION COLUMN="B" ROW="6"/></KING>
  <QUEEN><POSITION COLUMN="A" ROW="7"/></QUEEN>
  <PAWN><POSITION COLUMN="A" ROW="5"/></PAWN>
  <PAWN><POSITION COLUMN="D" ROW="4"/></PAWN>
 </BLACKPIECES>
</CHESSBOARD>

C�digo de ejemplo 2: Una representaci�n en formato de texto de una configuraci�n de tablero de ajedrez:

White king: G1
White bishop: D6
White rook: E1
White pawn: A4
White pawn: B3
White pawn: C2
White pawn: F2
White pawn: G2
White pawn: H5
Black king: B6
Black queen: A7
Black pawn: A5
Black pawn: D4

.�Documentos XML procesados

Se han producido dos conjuntos de documentos de entrada XML:

  • Un conjunto de documentos XML conformes a una Document Type Definition
  • Un conjunto de documentos XML conformes a un esquema XML equivalente.

Como hay muy pocos analizadores XML que soporten la especificaci�n XML Schema, la mayor�a de los programas de ejemplo usan el primer conjunto de documentos XML, basados en DTD. El segundo conjunto de documentos s�lo se usa para una comparaci�n de los respectivos documentos entre la validaci�n DTD y con esquema XML.

.�Documentos Basados en DTD

Dos DTDs especifican el formato de los documentos XML que son usados como entradas en los programas de ejemplo:

  • Una DTD que especifica una simple configuraci�n de tablero de ajedrez.
  • Una DTD relacionado con el anterior para especificar un conjunto de configuraciones de tablero de ajedrez.

C�digo de ejemplo 3: El DTD para una configuraci�n de tablero de ajedrez, (dtd/Chessboard.dtd)

<!ELEMENT CHESSBOARD (WHITEPIECES, BLACKPIECES)>
<!ENTITY % pieces
  "KING,
   QUEEN?,
   BISHOP?, BISHOP?,
   ROOK?, ROOK?,
   KNIGHT?, KNIGHT?, 
   PAWN?, PAWN?, PAWN?, PAWN?,
   PAWN?, PAWN?, PAWN?, PAWN?"
>
<!ELEMENT WHITEPIECES (%pieces;)>
<!ELEMENT BLACKPIECES (%pieces;)>
<!ELEMENT POSITION EMPTY>
<!ATTLIST POSITION
  COLUMN (A|B|C|D|E|F|G|H) #REQUIRED
  ROW (1|2|3|4|5|6|7|8) #REQUIRED
>
 
<!ELEMENT KING (POSITION)>
<!ELEMENT QUEEN (POSITION)>
<!ELEMENT BISHOP (POSITION)>
<!ELEMENT ROOK (POSITION)>
<!ELEMENT KNIGHT (POSITION)>
<!ELEMENT PAWN (POSITION)>

Este esquema fuerza varias restricciones desde el dominio de la aplicaci�n:

  • S�lo un rey por cada color puede estar presente en un momento dado en tablero de ajedrez.
  • Cero o una re�na por cada color.
  • De cero a dos alfiles por cada color.
  • De cero a dos caballos por cada color.
  • De cero a dos torres por cada color.
  • De cero a ocho peones por cada color.
  • Una pieza debe estar en una de las columnas A, B, C, D, E, F, G y H
  • Una pieza debe estar en una de las filas 1, 2, 3, 4, 5, 6, 7 y 8

A pesar de todos, este esquema no evita que dos piezas compartan la misma posici�n exacta.

El siguiente DTD usa el anterior para especificar un conjunto de configuraciones de tablero de ajedrez que ser�n hijos de un s�lo elemento CHESSBOARDS.

C�digo de ejemplo 4: El DTD para m�ltiples configuraciones de tableros de ajadrez: (dtd/Chessboards.dt)

<!ELEMENT CHESSBOARDS (CHESSBOARD*)>
<!ENTITY % chessboard SYSTEM "Chessboard.dtd">
%chessboard;

El n�mero de configuraciones de tableros de ajedrez es ilimitado, permitiendo que cualquier n�mero de configuraciones sean definidas en un s�lo documento. Para poder comparar los distintos programas, se han creado documentos con 10, 100, 200, 300, 400, 500, 1000, 2000, 3000, 4000 y 5000 configuraciones.

C�digo de ejemplo 5: Un documento XML conforme a la DTD (Chessboards-[10-5000].xml)

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE CHESSBOARDS SYSTEM "dtd/Chessboards.dtd">

<CHESSBOARDS>
 <CHESSBOARD>
  <WHITEPIECES>
   <KING><POSITION COLUMN="G" ROW="1" /></KING>
   <BISHOP><POSITION COLUMN="D" ROW="6" /></BISHOP>
   <ROOK><POSITION COLUMN="E" ROW="1" /></ROOK>
   <PAWN><POSITION COLUMN="A" ROW="4" /></PAWN>
   <PAWN><POSITION COLUMN="B" ROW="3" /></PAWN>
   <PAWN><POSITION COLUMN="C" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="F" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="G" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="H" ROW="5" /></PAWN>
  </WHITEPIECES>
  <BLACKPIECES>
   <KING><POSITION COLUMN="B" ROW="6" /></KING>
   <QUEEN><POSITION COLUMN="A" ROW="7" /></QUEEN>
   <PAWN><POSITION COLUMN="A" ROW="5" /></PAWN>
   <PAWN><POSITION COLUMN="D" ROW="4" /></PAWN>
  </BLACKPIECES>
 </CHESSBOARD>
 <CHESSBOARD>
  ...
 </CHESSBOARD>
</CHESSBOARDS>

.�Documentos Basados en Esquema XML

De forma similar a los DTDs presentados arriba, dos esquemas XML especifican el formato de los documentos XML que se usan como entrada para la comparaci�n de validaciones entre DTD y Esquema XML:

  • Un Esquema XML especificando una s�la configuraci�n de tablero de ajedrez.
  • Un Esquema XML relacionado con el anterior para especificar un conjunto de configuracioens de tablero de ajedrez.

C�digo de ejemplo 6: El Esquema XML para una configuraci�n de tablero de ajerdrez: (xsd/Chessboard.xsd)

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  targetNamespace="http://mde.sun.com/Chessboard"
  xmlns="http://mde.sun.com/Chessboard"
  elementFormDefault="qualified">

 <xsd:element name="CHESSBOARD">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element name="WHITEPIECES" type="pieces" />
    <xsd:element name="BLACKPIECES" type="pieces" />
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>
  
 <xsd:complexType name="pieces">
  <xsd:sequence>
   <xsd:element name="KING" type="piece"
     minOccurs='1' maxOccurs='1'/>
   <xsd:element name="QUEEN" type="piece"
     minOccurs='0' maxOccurs='1'/>
   <xsd:element name="BISHOP" type="piece"
     minOccurs='0' maxOccurs='2'/>
   <xsd:element name="ROOK" type="piece"
     minOccurs='0' maxOccurs='2'/>
   <xsd:element name="KNIGHT" type="piece"
     minOccurs='0' maxOccurs='2'/>
   <xsd:element name="PAWN" type="piece"
     minOccurs='0' maxOccurs='8'/>
  </xsd:sequence>
 </xsd:complexType>
  
 <xsd:complexType name="piece">
  <xsd:sequence>
   <xsd:element name="POSITION"
     minOccurs='1' maxOccurs='1'>
    <xsd:complexType>
     <xsd:attribute name="COLUMN" use='required'>
<xsd:simpleType>
 <xsd:restriction base="xsd:string">
  <xsd:pattern value="[A-H]"/>
 </xsd:restriction>
</xsd:simpleType>
     </xsd:attribute>
     <xsd:attribute name="ROW" use='required'>
<xsd:simpleType>
 <xsd:restriction base="xsd:positiveInteger">
  <xsd:minInclusive value="1"/>
  <xsd:maxInclusive value="8"/>
 </xsd:restriction>
</xsd:simpleType>
     </xsd:attribute>
    </xsd:complexType>
   </xsd:element>
  </xsd:sequence>
 </xsd:complexType>
</xsd:schema>

Este esquema fuerza las mismas restricciones del dominio de aplicaci�n que el DTD, pero usa un rango d epatrones como "minOccurs='0' maxOccurs='8'" y "value="[A-H]".

C�digo de ejemplo 7: El Esquema XML para m�ltiples configuraciones de tableros de ajedrez: (xsd/Chessboards.xsd)

<?xml version="1.0" encoding="UTF-8"?>

<xsd:schema 
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  targetNamespace="http://mde.sun.com/Chessboards"
  xmlns="http://mde.sun.com/Chessboards"
  xmlns:cb="http://mde.sun.com/Chessboard">

 <xsd:import namespace="http://mde.sun.com/Chessboard" 
   schemaLocation='Chessboard.xsd' />

 <xsd:element name="CHESSBOARDS">
  <xsd:complexType>
   <xsd:sequence>
    <xsd:element ref="cb:CHESSBOARD" 
maxOccurs='unbounded'/>
   </xsd:sequence>
  </xsd:complexType>
 </xsd:element>   
</xsd:schema>

Los documentos XML conformes a Chessboards.dtd y Chessboards.xsd tienen una estructura y contenidos ind�nticos, la �nica excepci�n es la substituci�n del Document Type Declaration por una referencia al Esquema XML.

Para las comparaciones que implican esquemas XML, se utiliz� un documento con 100 configuraciones de tablero de ajedrez.

C�digo de ejemplo 8: El documento XML conforme al esquema XML (Chessboards-schema-100.xml)

<?xml version="1.0" encoding="UTF-8"?>

<cbs:CHESSBOARDS 
  xmlns:cbs="http://mde.sun.com/Chessboards"
  xmlns="http://mde.sun.com/Chessboard"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation='http://mde.sun.com/Chessboard 
    xsd/Chessboard.xsd
    http://mde.sun.com/Chessboards 
    xsd/Chessboards.xsd'>
 <CHESSBOARD>
  <WHITEPIECES>
   <KING><POSITION COLUMN="G" ROW="1" /></KING>
   <BISHOP><POSITION COLUMN="D" ROW="6" /></BISHOP>
   <ROOK><POSITION COLUMN="E" ROW="1" /></ROOK>
   <PAWN><POSITION COLUMN="A" ROW="4" /></PAWN>
   <PAWN><POSITION COLUMN="B" ROW="3" /></PAWN>
   <PAWN><POSITION COLUMN="C" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="F" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="G" ROW="2" /></PAWN>
   <PAWN><POSITION COLUMN="H" ROW="5" /></PAWN>
  </WHITEPIECES>
  <BLACKPIECES>
   <KING><POSITION COLUMN="B" ROW="6" /></KING>
   <QUEEN><POSITION COLUMN="A" ROW="7" /></QUEEN>
   <PAWN><POSITION COLUMN="A" ROW="5" /></PAWN>
   <PAWN><POSITION COLUMN="D" ROW="4" /></PAWN>
  </BLACKPIECES>
 </CHESSBOARD>
 <CHESSBOARD>
  ...
 </CHESSBOARD>
</cbs:CHESSBOARDS>

.�Programas de Ejemplo

Todos los programas presentados en este tutoral usan el API Java para Procesar XML (JAXP) para hacer de interface entre las diferentes implementaciones subyacentes del analizador SAX, el constructor de documentos DOM y el motor de Transformaci�n XSL.

.�Java API for XML Processing (JAXP)

El API Java para Procesamiento XML (JAXP) permite a las aplicaciones analizar y transformar documentos XML usando un API que es independiente de cualquier implementaci�n de procesador XML. A trav�s de un esquema conectable, los desarrolladores podr�an cambiar las implementaciones del procesador XML sin impactar en sus aplicaciones. JAXP 1.1 soporta los siguientes est�ndards:

  • SAX versi�n 2.0
  • DOM nivel 2
  • XSLT 1.0

JAXP fue usado para crear e invocar a diferentes implementaciones de analizadores XML y motores XSLT. Para la comparaci�n de un API particular (SAX, DOM, XSLT), se utiliz� el mismo programa, s�lo se cambi� el analizador XML o el motor XSLT subyacentes.

El API trata sobre el patr�n de dise�o factor�a para crear un nuevo analizador SAX, un constructor de documentos DOM o motores de hojas de estilo. Abajo tenemos ejemplos t�picos del uso del API para procesar un documento XML usando respectivamente SAX, DOM y XSLT.

Cuando usamos el API SAX a trav�s de JAXP, debemos:

  • Crear una nueva factor�a de analizadores SAX.
  • Configurar la factor�a.
  • Crear un nuevo analizador desde la factor�a.
  • Seleccionar el manejador de documento del analizador, el manejador de error, el manejador de DTD y el resolvedor de entidades.
  • Analizar el/los documento(s) XML.

C�digo de ejemplo 9: Invocar al analizador SAX usando JAXP y analizar el documento como un stream de eventos SAX:

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

boolean validating;
String fileToProcess;
...
SAXParserFactory factory 
  = SAXParserFactory.newInstance();
factory.setValidating(validating);
SAXParser parser = factory.newSAXParser();
...
parser.parse(fileToProcess, new HandlerBase() {
 ... // Custom implementation of the HandlerBase 
     // to process the document as SAX events
});
...

Los pasos t�tpicos cuando se usa DOM a trav�s de JAXP son:

  • Crear una nueva factor�a de constructores de documentos DOM.
  • Configurar la Factor�a.
  • Crear un nuevo constructor de documentos desde la factor�a.
  • Seleccionar el manejador de error del analizador subsyacente y el resolvedor de entidades.
  • Analizar el/los documento(s) XML para generar un �rbol DOM.

C�digo de ejemplo 10: Invocar a un constructor de documentos usando JAXP, analizar y procesar el documento como un �rbol DOM:

import org.w3c.dom.*;
import javax.xml.parsers.*;

boolean validating;
String fileToProcess;
...
DocumentBuilderFactory factory 
  = DocumentBuilderFactory.newInstance();
factory.setValidating(validating);
DocumentBuilder builder
  = factory.newDocumentBuilder();
builder.setErrorHandler(new ErrorHandler() {
 ...   
});
...
Document document = builder.parse(fileToProcess);
... // Processing the document as a DOM tree

Cuando se usa JAXP para realizar transformaciones XSL, los pasos a seguir no son muy diferentes de los de SAX o DOM:

  • Crear una nueva factor�a de transformadores.
  • Configurar la Factor�a.
  • Crear un nuevo transformador desde la factor�a con una hoja de estilo particular.
  • Seleccionar el oyente de error y el resolvedor de URI.
  • Aplicar la hoja de estilos a el/los documento(s) XML para generar �rboles DOM, eventos SAX o escribir la salida en un stream.

C�digo de ejemplo 11: Invocar a un motor XSLT usando JAXP y procesar el documento con una hoja de estilo XSLT; el API permite pasar par�metros a los motores de hoja de estilo:

import javax.xml.transform.*;

String styleSheetFile;
String fileToProcess;
OutputStream out;
Properties properties;
...
TransformerFactory factory 
  = TransformerFactory.newInstance();
Transformer transformer = factory.newTransformer(
  new SAXSource(new InputSource(styleSheetFile)));
for (Enumeration i = properties.propertyNames();
     i.hasMoreElements();) {
 String name = (String) i.nextElement();
 transformer.setParameter(name,
   "\'" + properties.getProperty(name) + "\'");
}
transformer.transform(
  new SAXSource(new InputSource(fileToProcess)),
  new StreamResult(out));
...

.�Estructura Com�n de los Programas de Ejemplo

Todos los programas de ejemplo comparten una estructura com�n que posteriormente nos permitir� hacer una comparaci�n. Todos siguen los pasos t�picos de la utilizaci�n de JAXP presentados arriba, y adicionalmente incluyen dos bucles para procesar el mismo documento varias veces y en varias ejecuciones. Por cada ejecuci�n, se usa una factor�a para crear un analizador o un procesador de hojas de estilo que a su vez es usada para procesar un documento fuente XML varias veces. La validaci�n del documento fuente contra sus DTDs o Esquemas XML declarados se implementa configurando la factor�a a trav�s de su m�todo setValidating que crea un analizador con o sin validaci�n.

C�digo de ejemplo 12: Ejemplo de la estructura de los programas de ejemplo: (ChessboardSAXPrinter.java)

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class ChessboardSAXPrinter {
 private SAXParser parser;

 public ChessboardSAXPrinter(boolean validating)
   throws Exception {
  SAXParserFactory factory 
    = SAXParserFactory.newInstance();
  factory.setValidating(validating);
  parser = factory.newSAXParser();
  ...
  return;
 }

 public void print(String fileName, PrintStream out)
   throws SAXException, IOException {
  ...
  parser.parse(fileName, ...);
  return;
 }
  
 public static void main(String[] args) {
  ...   
  for (int k = 0; k < r; k++) {
    // r: number of runs
   ChessboardSAXPrinter saxPrinter
     = new ChessboardSAXPrinter(validating);
   long time = System.currentTimeMillis();
   for (int i = 0; i < n; i++) {
     // n: number of document processed per run
    saxPrinter.print(args[0], out);
   }
   // print out the average time (s) 
   // to process a document during the current run
   System.err.print( 
     (((double) (System.currentTimeMillis()
     - time)) / 1000 / n) + "\t");
  }
  ...
 }
}

.�Programa de Ejemplo SAX

El API SAX (Simple API for XML) usa un modelo basado en eventos y permite el procesamiento de un documento fuente como un stream de eventos. Los eventos son disparados mientras se analiza como un flujo continuo de retrollamadas e invocaciones a m�todos. Los eventos est�n anidados de la misma forma que los elementos en el documento, por lo tanto, no se crea ning�n modelo de documento intermedio. Como el uso de memoria es bajo, el modelo de programaci�n puede ser complejo especialmente si la estructura no corresponde con la estructura de datos de la aplicaci�n. Como genera un flujo temporal de eventos, el API SAX no puede utilizarse cuando un modelo de documento tiene que ser editado o procesado varias veces.

El API SAX define varios interfaces (alguno de los interfaces de SAX 1.0 fueron renombrados en SAX 2.0):

  • org.xml.sax.Parser (XMLReader en SAX 2.0) interfaces para analizadores SAX:
    • Analiza un documento XML.
    • Permite a una aplicaci�n registrar:
      • Un manejador de eventos de documento.
      • Un manejador de error.
      • Un manejador de DTD.
      • Un resolvedor de entidades.
  • org.xml.sax.DocumentHandler (ContentHandler en SAX 2.0) interface para recibir eventos de documento, notificaci�n de:
    • El inicio o final de un documento.
    • El inicio y final de un elemento.
    • Datos de caracter.
    • Espacios en blanco ignorables en el contenido de elementos.
    • Instrucciones de procesamiento.
  • org.xml.sax.ErrorHandler interface para recibir eventos de error SAX, notificaci�n de:
    • Un error recuperable.
    • Un error fatal/no recuperabe.
    • Un aviso.
  • org.xml.sax.DTDHandler interface para recibir nitificaci�n de eventos b�sicos relacionados con DTD, notificaci�n de:
    • Un evento de declaraci�n de notaci�n.
    • Un evento de declaraci�n de entidad sin analizar.
  • org.xml.sax.EntityResolver interface para resolver referencias a entidades externas.
  • org.xml.sax.HandlerBase (DefaultHandler en SAX 2.0) implementaci�n por defecto de los cuatro interfaces anteriores.

Una aplicaci�n debe proporcionar al menos un manejador de documento (o contenido) para poder capturar los eventos relevantes y procesarlos.

Ilustraci�n 3: Cuando se usa el API SAX, como m�nimo un desarrollador tiene que implementar un DocumentHandler (ContentHandler en SAX 2.0) o subclasificar BaseHandler (DefaultHandler) para que se puedan capturar los eventos importantes y, opcionalmente los objetos de negocio mapeados o directamente manejados por la l�gica de negocio.

El sencillo programa presentado abajo implementa el interface HandlerBase, y especialmente el m�todo startElement. Se usa una SAXParserFactory para crear un nuevo SAXParser. La implementaci�n personalizada del interface HandlerBase y el path del documento fuente XML a procesar son pasados al analizador. Durante el an�lisis, se llama al m�todo startElement por cada etiqueta de inicio del documento fuente.

C�digo de ejemplo 13: El programa procesa un documento XML bas�ndose en el API SAX (ChessboardSAXPrinter.java); el m�todo startElement imprime informaci�n basada en las etiquetas de inicio que captura:

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class ChessboardSAXPrinter {
 private SAXParser parser;
 private PrintStream out;

 public class ChessboardHandler extends HandlerBase {
  private boolean whitePiece = false;
  
  public void startElement(String name,
     AttributeList attrs) {
   if (name.equals("WHITEPIECES")) {
    whitePiece = true;
   } else if (name.equals("BLACKPIECES")) {
    whitePiece = false;
   } else if (name.equals("KING")
  || name.equals("QUEEN")
  || name.equals("BISHOP")
  || name.equals("ROOK")
  || name.equals("KNIGHT")
  || name.equals("PAWN")) {
    out.print((whitePiece ? "White" : "Black")
  + " "+ name.toLowerCase() + ": ");
   } else if (name.equals("POSITION")) {
    if (attrs != null) {
     out.print(attrs.getValue("COLUMN"));
     out.println(attrs.getValue("ROW"));
    }
   }
   return;
  }
  ...
 }
 ...
}

Durante el an�lisis, el m�todo startElement captura los sigueintes eventos de etiquetas de inicio:

  1. BLACKPIECES y WHITEPIECES para seguir el color de las piezas anidadas.
  2. KING, QUEEN, BISHOP, ROOK, KNIGHT, PAWN para imprimir el nombre de la pieza y su color.
  3. POSITION para imprimir la posici�n de la pieza, dando el atributo de elemento ROW y COLUMN.

Los otros eventos no son capturados, pero una aplicaci�n del mundo real podr�a requerir que se capturaran eventos como endElement, characters (que notifica un contenido textual) y mantener un contexto m�s complejo para mapear el stream de eventos dentro de objetos de negocio sobre los que poder aplicar m�s tarde la l�gica de negocio. Usando SAX podr�a ser tedioso, pero ser�a la t�cnica m�s r�pida.

Mientras no sea una obligaci�n el API SAX podr�a ser usado por constructores de documentos DOM para construir un �rbol DOM desde un documento fuente XML.

.�Programa de Ejemplo DOM

DOM (Document Object Model) es una especificaci�n W3C presentada como "un interface neutral del lenguaje y la plataforma que permitir� a los programas y scripts acceder dirn�micamente y actualizar el contenido, la estructura y el estilo de documento." Esencialmente es una estructura de datos en forma de �rbol y un conjunto de m�todos para acceder y editar esa estructura. Como es una estructura de datos en-memoria, el uso de memoria es mucho m�s alto que para SAX, pero el modelo de documento puede accederse aleatoriamente y puede ser procesado m�ltiples veces.

El API DOM define interfaces para cada una de las entidades de un documento XML:

  • Interface org.w3c.dom.Node: un s�lo nodo en el �rbol del documento.
    • define m�todos para acceder, insertar, eliminar y reemplazar nodos hijo.
    • Define m�todos para acceder al nodo padre.
    • Define m�todos para acceder al documento.
  • Inteface org.w3c.dom.Document es un Node que representa un documento completo XML.
  • Interface org.w3c.dom.Text es un Node que representa el contenido textual de un elemento XML.

La aplicaci�n podr�a aplicar su l�gica de negocio directamente al �rbol DOM, o ir primero a trav�s de un estado tradicional de mapear la informaci�n relevante desde el �rbol DOM en objetos de negocio:

Ilustraci�n 4: Cuando se usa el API DOM, la aplicaci�n tiene que acceder o editar una representaci�n en-memoria del documento fuente.

El programa presentado abajo usa el API DOM para analizar y cagar en memoria un documento XML describiendo un conjunto de configuraciones de tablero de ajedrez. Pasa a trav�s del �rbol DOM resultante y saca las mismas configuracioens en formato de texto.

Se usan dos implementaciones diferentes para iluminar las diferencias potenciales en rendimiento cuando se usan diferentes m�todos del API DOM: acceder a los elementos por sus nombres o en relaci�n a sus padres:

C�digo de ejemplo 14: El programa de procesamiento XML basado en el API DOM (ChessboardDOMPrinter.java), el m�todo print baja por el �rbol accediendo a los elementos en relaci�n a sus nodos padre:

import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;

public class ChessboardDOMPrinter {
 private DocumentBuilder builder;

 public void print(String fileName, PrintStream out)
   throws SAXException, IOException {
  Document document = builder.parse(fileName);
  NodeList nodes_i 
    = document.getDocumentElement().getChildNodes();
  for (int i = 0; i < nodes_i.getLength(); i++) {
   Node node_i = nodes_i.item(i);
   if (node_i.getNodeType() == Node.ELEMENT_NODE
 && ((Element) node_i).getTagName()
    .equals("CHESSBOARD")) {
    Element chessboard = (Element) node_i;
    NodeList nodes_j = chessboard.getChildNodes();
    for (int j = 0; j < nodes_j.getLength(); j++) {
     Node node_j = nodes_j.item(j);
     if (node_j.getNodeType() == Node.ELEMENT_NODE) {
Element pieces = (Element) node_j;
NodeList nodes_k = pieces.getChildNodes();
for (int k = 0; k < nodes_k.getLength); k++) {
 Node node_k = nodes_k.item(k);
 if (node_k.getNodeType() == Node.ELEMENT_NODE) {
  Element piece = (Element) node_k;
  Element position 
    = (Element) piece.getChildNodes().item(0);
  out.println((pieces.getTagName()
     .equals("WHITEPIECES")
   ? "White " : "Black ")
  + piece.getTagName().toLowerCase()
  + ": "
  + position.getAttribute("COLUMN")
  + position.getAttribute("ROW"));
 }
}
     }
    }
   }
  }
  return;
 }
}

Este programa baja por el �rbol DOM generado por el constructor de documento desde el documento de entrada XML y:

  1. Obtiene todos los elementos CHESSBOARD.
  2. Por cada elemento CHESSBOARD obtiene los subelementos BLACKPIECES y WHITEPIECES.
  3. Por cada uno de los elementos BLACKPIECES y WHITEPIECES, obtiene los subelementos KING, QUEEN, BISHOP,ROOK, KNIGHT y PAWN.
  4. Por cada uuno de los elementos KING, QUEEN,BISHOP, ROOK, KNIGHT y PAWN imprime el color, el nombre y la posici�n especificada por los atributos ROW y COLUMN.

La siguiente implementaci�n alternativa no difiere en el algoritmo pero los recupera por el nombre. Aunque parece m�s elegante podr�a ser menos efectiva ya que este m�todo busca los elementos en todo el sub�rbol, no s�lo en el siguiente nivel. Globalmente, en programas simples, DOM parece m�s complicado que SAX. Realmente, esta �ltima implementaci�n podria hacerse m�s sencilla. Como el m�todo getElementsByTagName recupera todos los hijos y nietos dando un nombre especificado, podr�a recolectar todos los elementos POSITION empezando por la ra�z del docmento y luego por cada elemento devuelto, recuperar el nombre de la pieza, (el nombre de la etiqueta del padre), y el color (basado en el nombre de la etiqueta del abuelo).

C�digo de ejemplo 15: Una implementaci�n "nativa" del m�todo print basada en el API DOM que accede a elementos por el nombre en vez por su posici�n relativa en el �rbol (ChessboardDOMPrinter.java).

public void print(String fileName, PrintStream out)
  throws SAXException, IOException {
 Document document = builder.parse(fileName);
 NodeList positions 
   = document.getElementsByTagName("POSITION");
 for (int i = 0; i < positions.getLength(); i++) {
  Element position = (Element) positions.item(i);
  Element piece = (Element) position.getParentNode();
  Element pieces = (Element) piece.getParentNode();
  out.println(
    (pieces.getTagName().equals("WHITEPIECES")
     ? "White " : "Black ")
    + piece.getTagName().toLowerCase() + ": "
    + position.getAttribute("COLUMN")
    + position.getAttribute("ROW"));
 }
 return;
}

.�Programa de Ejemplo XSLT

XSL Transformations es un lenguaje para describir c�mo transformar un documento XML (expl�cita o impl�citamene representado como un �rbol) en otro; XSLT es un �rbol para transformaciones de �rboles, desde un �rbol fuente a un �rbol resultante. Permite definir plantillas (reglas) que ser�n aplicadas sobre los elementos del documento fuente e insertar elementos en el �rbol resultante. El documento resultante puede ser otro documento XML bien formateado (XML, WML), un documento HTML, un documento de texto, o cualquier otro formato para el que este disponible el m�todo de salida apropiado. XSLT usa expresiones XPath para consultar elementos desde el �rbol fuente o para evaluar fragmentos del documento a ser insertados dentro del �rbol resultante.

Ilustraci�n 5: XSL Transformations, transforma un documento fuente XML en otro documento que puede ser de cualquier formato, XML, HTML, etc, aplicando una hoja de estilo.

Un procesador XSLT lee un documento fuente XML y una hoja de estilo XSL. La hoja de estilo es a su vez un documento XML bien formateado. Dependiendo de la implementaci�n, un motor XSLT podr�a leer una fuente de entrada como eventos SAX o �rboles DOM y tambi�n generar eventos SAX o �rboles DOM.

Este progama usa un motor XSLT y una hoja de estilo para transformar un documento XML que describe un conjunto de configuraciones de tableros de ajedrez en sus correspondientes formatos de texto. Se usa una TransformerFactory para crear un nuevo Transformer, entonces la hoja de estilo y el Transformer se usan ara procesar el documento fuente generado.

El motor XSLT aplica la siguiente hoja de estilo a cada documento de entrada:

C�digo de ejemplo 16: La hoja de estilo para transformar documentos XML que representan configuraciones de tableros de ajedrez (ChessboardPrinter.xsl)

<?xml version="1.0" encoding="UTF-8"?>

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

 <xsl:strip-space elements="*" />

 <xsl:output method="text"/> 

 <xsl:template match="/">
  <xsl:apply-templates />
 </xsl:template> 

 <xsl:template match="WHITEPIECES/*">
  <xsl:value-of select="concat('White ', name(),
    ': ', POSITION/@COLUMN, POSITION/@ROW)" />
  <xsl:text>
</xsl:text>
 </xsl:template> 

 <xsl:template match="BLACKPIECES/*">
  <xsl:value-of select="concat('Black ', name(),
    ': ', POSITION/@COLUMN, POSITION/@ROW)" />
  <xsl:text>
</xsl:text>
 </xsl:template>

</xsl:stylesheet>

Esta hoja de estilo es bastante simple, define dos plantillas, una que corresponde con las piezas blancas (pattern"WHITEPIECES/*") y otra que corresponde con las piezas negras (pattern"BLACKPIECES/*"). Cuando se aplica una de estas plantilla, inserta en el �rbol resultante un nodo de texto conteniendo el string que describe el color, el nombre y la posici�n de la pieza corresponidente. Cuando una plantilla no se aplica nunca m�s, el �rbol resultante se imprime usando el m�todo de salida de texto.

Ilustraci�n 6: XSLT puede ser usada para procesar o post-procesar documentos XML antes o despu�s de que sean manejados por la l�gica de negocios de la aplicaci�n.

.�Programa de Ejemplo XPath

Algunos motores XSLT (como Xalan deApache.org) permiten invocar su propia implementaci�n de XPath independientemente a trav�s de un API espec�fico. Una aplicaci�n podr�a usar directamente Xpath para consultar la informaci�n desde un documento fuente XML o para evaluar expresiones contra el documento fuente.

El siguiente programa usa el API DOM para analizar y cargar en memoria un documento XML que describe un conjunto de configuraciones de tableros de ajedrez. Luego eval�a expresiones Xpath para localizar los elementos a procesar y saca las configuraciones en formato de texto. Los m�todos XPathAPIselectNodeList y eval son llamados para evaluar expresiones XPath.

C�digo de ejemplo 17: El programa de procesamiento de documento XML basado en el API XPath (ChessboardXPathPrinter.java)

import javax.xml.parsers.*;
import javax.xml.transform.*;
import org.apache.xpath.*; 

public class ChessboardXPathPrinter {
 private DocumentBuilder builder;

 public void print(String fileName, PrintStream out)
   throws TransformerException, SAXException, ... {
  Document document = builder.parse(fileName);
  NodeList allPieces = XpathAPI.selectNodeList(
    document.getDocumentElement(),
    "//*[self::WHITEPIECES or self::BLACKPIECES]/*");
  for (int i = 0; i < allPieces.getLength(); i++) {
   Element piece = (Element) allPieces.item(i);
   Element pieces = (Element) piece.getParentNode();
   Element position 
     = (Element) piece.getChildNodes().item(0);
   out.println((pieces.getTagName()
     .equals("WHITEPIECES")
    ? "White " : "Black ")
   + piece.getTagName().toLowerCase()
   + ": " 
   + position.getAttribute("COLUMN")
   + position.getAttribute("ROW"));
   // out.println(XPathAPI.eval(piece,
   //  "concat(substring-before(name(..), \'PIECES\'),"
   //  + "\' \', name(),\': \',"
   //  + "POSITION/@COLUMN, POSITION/@ROW)"));
  }
  return;
 }
 ...
}

El m�todo print primero usa una expresi�n XPath para localizar los elementos piece, luego los imprime usando el API DOM; la segunda expresi�n XPath que ha sido comentada podr�a haberse usado para el mismo prop�sito.

Este programa usa una expresi�n XPath para recuperar elementos que correspondan tanto con las piezas blancas como las negras (pattern "//*[self::WHITEPIECES" o "self::BLACKPIECES]/*"). Luego por cada elemento KING, QUEEN, BISHOP, ROOK, KNIGHT y PAWN recupera sus subelementos POSITION e imprime el color (basado en el nombre de la etiqueta abuelo), el nombre y la posici�n especificada por los atributos ROW y COLUMN.

.�Programa de Ejemplo JDOM

En esta site, JDOM se presenta en los siguientes t�rminos:

"JDOM es, simplemente, una representaci�n Java de un documento XML. JDOM proporciona una forma de representar ese documento para una lectura, manipulaci�n y escrituras f�ciles y eficientes. Tiene un API correcto, es ligero y r�pido, y est� optimizado para el programador Java. Es una alternativa para DOM y SAX, aunque se integra bien con �mbos."

El siguiente programa que usa el API JDOM analiza y carga en memoria un documento XML que describe un conjuntro de configuraciones de tableros de ajedrez, luego pasa a trav�s del documento JDOM resultante y saca las mismas configuraciones en formato texto. Se usa un SAXBuilder para crear un documento JDOM desde el documento fuente XML. Por defecto, el SAXBuilder de JDOM trabaja con JAXP para crear internamente un analizador SAX.

C�digo de ejemplo 18: El programa de procesamiento de documentos XML basado en el API JDOM (ChessboardJDOMPrinter.java)

import org.jdom.*;
import org.jdom.input.*;
import org.xml.sax.*;

public class ChessboardJDOMPrinter {
 private static boolean verbose = false;
 private SAXBuilder builder;

 public ChessboardJDOMPrinter(boolean validating)
   throws Exception {
  builder = new SAXBuilder();
  builder.setValidation(validating);
  ...
  return;
 }

 public void print(String fileName, PrintStream out)
   throws JDOMException {
  Document document = builder.build(fileName);
  Element root = document.getRootElement();
  List chessboards = root.getChildren("CHESSBOARD");
  for (int i = 0; i < chessboards.size(); i++) {
   Element chessboard = (Element) chessboards.get(i);
   String[] pieceSetTags = { "WHITEPIECES", 
     "BLACKPIECES" };
   for (int j = 0; j < pieceSetTags.length; j++) {
    List pieceSets 
= chessboard.getChildren(pieceSetTags[j]);
    for (int k = 0; k < pieceSets.size(); k++) {
     Element pieceSet = (Element) pieceSets.get(k);
     String[] pieceTags = { "KING", "QUEEN", "BISHOP",
    "ROOK", "KNIGHT", "PAWN" };
     for (int l = 0; l < pieceTags.length; l++) {
List pieces = pieceSet.getChildren(pieceTags[l]);
for (int m = 0; m < pieces.size(); m++) {
 Element piece = (Element) pieces.get(m);
 Element position = piece.getChild("POSITION");
 out.println(
   (j == 0 ? "White " : "Black ")
   + pieceTags[l].toLowerCase() + ": "
   + position.getAttributeValue("COLUMN")
   + position.getAttributeValue("ROW"));
}
     }
    }
   }
  }
  return;
 }
 ...
}

Este programa es muy similar al programa de ejemplo DOM. Baja por el �rbol JDOM generado por el constructor de documentos desde el documento de entrada XML. �l:

  1. Obtiene todos los elementos CHESSBOARD.
  2. Por cada elemento CHESSBOARD obtiene los subelementos BLACKPIECES y WHITEPIECES.
  3. Por cada uno de los elementos BLACKPIECES y WHITEPIECES, obtiene los subelementos KING, QUEEN, BISHOP,ROOK, KNIGHT y PAWN.
  4. Por cada uuno de los elementos KING, QUEEN, BISHOP, ROOK, KNIGHT y PAWN imprime el color, el nombre y la posici�n especificada por los atributos ROW y COLUMN.

.�Programa de Ejemplo YAXA

Este programa usa el API YAXA para analizar documentos XML que describen un conjunto de configuraciones de tableros de ajedrez, y saca las mismas configuraciones en formato texto. YAXA es un API experimental que funciona sobre SAX y a�ade el clasico paradigma Java Event/Source/Listener. El programa de abajo implementa el m�todo elementStarted de un ElementEvent.Adapter. Este ElementEvent.Adapter est� registrado con un XMLPathTracker (que es una subclase de DefaultHandler) y escucha ElementEvents que correspondan con un patr�n espec�fico:

C�digo de ejemplo 19: El programa de procesamiento de documento XML basado en el API YAXA (ChessboardYAXAPrinter.java)

import java.io.*;
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
import yaxa.xml.*;
import yaxa.xml.events.*;

public class ChessboardYAXAPrinter {
 private SAXParser parser;

 public class ChessboardHandler
   extends XMLEventTracker {

  public ChessboardHandler() {
   addElementListener(new XMLEventTrack.Pattern(
     "//(WHITEPIECES|BLACKPIECES)/*/POSITION"),
     new ElementEvent.Adapter() {
public void elementStarted(ElementEvent event) {
 XMLEventTracker tracker 
   = (XMLEventTracker) event.getSource();
 XMLEventTrack.Builder builder
   = tracker.getCurrentTrackBuilder();
 String colorName 
   = builder.getEventName(builder.getLength()-3)
.equals("WHITEPIECES")
     ? "White " : "Black ");
 String pieceName
   = builder.getEventName(builder.getLength()-2);
 out.println(colorName + pieceName + ": "
   + event.getAttributes().getValue("COLUMN")
   + event.getAttributes().getValue("ROW"));
}
     });
   return;
  }
 }
}

Este programa captura todos los eventos de elementos que correspondan con un patr�n espec�fico ("//(WHITEPIECE|BLACKPIECE)/*/POSITION"). Luego por cada elemento que corresponda (es decir elementos POSITION) imprime el color, el nombre y la posici�n de la pieza correspondiente.

YAXA tambi�n implementa un editor de streams de eventos basado en el modelo anterior que edita directamente el flujo de eventos disparado por un analizador SAX.

C�digo de ejemplo 20: El programa usando el editor de streams YAXA XML para procesar configuraciones de tableros de ajedrez (ChessboardXSEPrinter.java)

import javax.xml.parsers.*;
import org.xml.sax.*;
import yaxa.xml.*;
import yaxa.editor.*;

public class ChessboardXSEPrinter {

 public static void main(String[] args) {
  ...
  XMLStreamEditor editor= new XMLStreamEditor(args[0]);
  XMLEventWriter writer = new XMLEventWriter("UTF-8",
    false,
    editor.getOutputFormat()
.equals(XMLEventWriter.TEXT_FORMAT),
    editor.isStrippingSpace());
  writer.setWriter(out);
  editor.setRedispatcher(writer);
  SAXParser parser
    = SAXParserFactory.newInstance().newSAXParser();
  parser.parse(args[1], editor);
  editor.clear();
  rewriter.flush();
  ...
 }
}

C�digo de ejemplo 21: El escript de edici�n de streams para transformaci�n de documentos XML que representan configuraciones de tableros de ajedrez (ChessboardPrinter.xse)

<?xml version="1.0"?>

<!DOCTYPE xse:edit SYSTEM "file:./xse.dtd" >

<xse:edit>

 <xse:output xse:format="text" xse:strip-space="true" />

 <xse:print 
   xse:at='CHESSBOARDS/CHESSBOARD/WHITEPIECES/*/POSITION'
   xse:data="White $[track{-1}]: \
     $[element{@COLUMN}]$[element{@ROW}]" />

 <xse:print
   xse:at='CHESSBOARDS/CHESSBOARD/BLACKPIECES/*/POSITION'
   xse:data="Black $[track{-1}]: \
     $[element{@COLUMN}]$[element{@ROW}]" />

</xse:edit>

Este escript define dos comandos, uno que ser� disparado por cada pieza blanca (pattern "CHESSBOARDS/CHESSBOARD/WHITEPIECES/*/POSITION") y otro que ser� disparado por cada pieza negra (pattern "CHESSBOARDS/CHESSBOARD/BLACKPIECES/*/POSITION"). Estos comandos de edici�n realmente est�n implementados como oyentes de eventos que buscan esos eventos particulares. Cuando se dispara uno de estos comandos, inserta en el stream de eventos un nuevo evento de texto conteniendo un string, describiendo el color, el nombre y la posici�n de la pieza correspondiente. El stream de salida de eventos se escribe en texto normal.

.�Generar Documentos XML

Hasta ahora, en este tutorial, nos hemos enfocado en analizar documentos XML de entrada y procesar las estructuras de datos resultantes expl�cita o impl�citamente. Todav�a no hemos cubierto la generaci�n de documentos XML desde una estructura de datos interna -- la serializaci�n a XML.

Para serializar una estructura de datos a XML, hay disponibles dos soluciones principales:

  • Generar el documento XML directamente "a mano".
  • Construir un �rbol DOM o JDOM correspondiente y serializarlo para generar el documento XML.

La segunda soluci�n es preferible porque nos asegura un documento limpio (no hay etiquetas sin cerrar). Adem�s, tener un documento XML representado internamente como un �rbol DOM, aunque requiere m�s recursos de memoria, permite un procesamiento posterior m�s eficiente, como la aplicaci�n de hojas de estilo XSLT.

.�Conclusi�n

En esta p�gina hemos mostrado un ejemplo de las tecnolog�as disponibles para procesar documentos XML. Estas tecnolog�as se dirigien a diferentes niveles de abstracci�n y proporcionan diferentes niveles de utilizaci�n para el programador Java. Algunas de esta tecnolog�as como SAX, DOM, XPath y XSLT podr�an relacionarse unas con otras. Por ejemplo, un constructor de documentos DOM podr�a usar un analizador SAX para generar un �rbol DOM desde un documento XML, o un procesador XPath podr�a aplicar expresiones a un �rbol DOM fuente, o un motor XSLT podr�a usar un procesador XPath para buscar y evaluar plantillas de hojas de estilo. Como se apilan, un desarrollador de aplicaciones XML podr�a verse tentado a elegir una de ellas para conseguir el mismo resultado, pero hacer esto traer� dificultades y p�rdidas entre el rendimiento, el uso de memoria y la flexibilidad.

XSLT y XPath podr�an trear flexibilidad a nuestra aplicaci�n debido a su naturaleza de script, y podr�an usarse para un proceso anterior y posterior de documentos XML generados y adquiridos por la aplicaci�n. SAX podria traer eficiencia durante el mapeo de datos XML a objetos de negocio Java. DOM y especialmente JDOM podr�an traer simplicidad y eficiencia en la edici�n de grandes modelos de documentos en memoria. En algunos casos, un modelo de objeto de documento podr�a ser elegible como la estructura de datos principal de la aplicaci�n.

Todos estos APIs necesitan ser considerados cuando implementamos una aplicaci�n XML. Adem�s con el API SAX 2.0, y la intercambiabilidad (como fuente y resultado) de SAX y DOM en algunos APIs, se pueden construir complejas tuber�as de procesamiento XML combinando implementaciones est�ndards y personalizadas.

COMPARTE ESTE ARTÍCULO

COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP
ARTÍCULO ANTERIOR