Introducción al uso de la API JAXP

1. Introducción
La API JAXP (Java API for XML Processing), es un paquete de software de Oracle (anteriormente de Sun
Microsystems) para facilitar el procesamiento de ficheros XML, implementando el interfaz DOM creado por el
W3C.

Imaginemos un fichero XML como el presentado en la figura.

El contenido de este fichero puede verse como un árbol, con los nodos mostrados en la siguiente figura.
El objetivo de JAXP es proporcionar una API con un conjunto de clases y métodos para:
! Obtener un árbol de esas características a partir de un fichero XML.
! Consultar y modificar la información de ese árbol.
1
2. El Interfaz DOM del W3C
El interfaz DOM del W3C tiene como objetivo normalizar los tipos de nodos que puede contener el árbol de un
documento XML, las posibles relaciones jerárquicas entre ellos (es decir, qué tipos de nodo pueden ser hijos de
cada uno de los nodos), y un conjunto de operaciones para consultar y modificar los contenidos de un árbol DOM.
En la figura podemos ver los distintos tipos de nodos definidos en el estándar DOM (por ejemplo, el nodo
Element), todos ellos subtipos de un tipo Node genérico. En la figura, además, están indicados algunos tipos de
nodos que pueden ser hijos del nodo Element.

Para cada tipo de nodo, el estándar DOM define una serie de propiedades y métodos. Por ejemplo,

! Tipo Node. El tipo Node tiene una serie de propiedades y métodos disponibles para cualquier tipo de nodo. Por
ejemplo:
o Propiedades: nodeType, nodeName, nodeValue…
o Métodos: getNodeType(), getNodeValue(), getChildNodes(), getFirstChild()…
! Tipo Element. Un nodo Element (que representa un elemento del documento), además de las genéricas por
ser un Node, tiene una serie de propiedades y métodos adicionales. Por ejemplo:
o Métodos: getAttribute(), getElementsByTagName()…

! Tipo Attr. El tipo Attr (que representa un atributo de un elemento), además de las heredadas del tipo Node,
tendrá otro conjunto de propiedades y métodos particulares, distintos de las del tipo Element. Por ejemplo:
o Métodos: getName(), getValue()…
Todos los tipos de nodo, sus posibles relaciones de parentesco, la propiedades de cada uno y los métodos
disponibles están descritos en el estándar DOM del W3C. Por ejemplo, allí se dice:
• El nodeName de elementos y atributos es su nombre. El de Text es ‘#text’
• El nodeValue de Text y Attr es su contenido. El de los elementos es indefinido
• Hay una serie de constantes para enumerar los tipos de nodos: DOCUMENT_NODE, ELEMENT_NODE,
ATTRIBUTE_NODE, TEXT_NODE…

2
3. La API JAXP
La API JAXP es una implementación del estándar DOM del W3C. Nos ofrece una serie de clases para ayudarnos
a parsear ficheros XML y obtener árboles DOM sobre los que después aplicar los métodos definidos en el
estándar DOM para consultar y manipular esos árboles.
Los paquetes Java que contienen esas clases son:

! javax.xml.parsers interfaz para crear, configurar y usar parsers

! org.w3c.dom interfaz DOM para acceder a un árbol DOM (clases Document, Node, Element…)

! org.xml.sax interfaz de parsers SAX (provee excepciones)

! org.xml.sax.helpers interfaz para gestores de errores (interfaz DefaultHandler)

Por ejemplo, éste sería un sencillo programa para obtener un árbol DOM a partir de un fichero XML (faltaría
capturar algunas excepciones).
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.IOException;

public class TVML_parser {

public static void main (String[] args) throws ParserConfigurationException, SAXException, IOException
{
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(URL); /* obtiene el árbol */
Element programacion = doc.getDocumentElement(); /* obtiene el elemento raíz del árbol */
}
}

Una vez que tenemos el árbol del documento, emplearíamos las distintas clases y métodos definidos en los
mencionados paquetes para acceder a su contenido (o modificarlo). Por ejemplo, suponiendo que la variable
“elem" representa un nodo tipo Element, podríamos ejecutar (entre muchas otras) las siguientes operaciones,
cuya explicación no debería suscitar dudas viendo su nombre y el de las variables involucradas.

Para obtener el valor de un atributo de “elem”:

• String valorAtributo = elem.getAttribute(“nombreAtributo”);
o Ejemplo: String idioma = canal.getAttribute(“lang”); // nos da el valor de un atributo
se supone que canal es una variable representando un nodo Element de tipo Canal

• NamedNodeMap nm= elem.getAttributes(); // nos da un mapa con todos los atributos

Para obtener la lista con los hijos de “elem”, asignándosela a una variable de tipo NodeList que representa una
lista de objetos Node.

! NodeList nl = elem.getChildNodes()
o Ejemplo: NodeList nl = canal.getChildNodes()

Para obtener el primer hijo de un elemento.

! Node nodo = elem.getFirstChild()

o Ejemplo: Node nodoNombreCanal = canal.getFirstChild()
Esta operación sería peligrosa, puesto que no comprobamos que realmente el primer hijo sea el nombre. Podría
ser un nodo texto con blancos.

3
Para obtener la lista con los descendientes de “elem” que se llamen de una determinada forma:

! NodeList nl = elem.getElementsByTagName(“nombreElemento”)
o Ejemplo: NodeList programas = canal.getElementsByTagName(“Programa”)

! Para acceder al primer programa —> Element programa= (Element)programas.item(0)

Para acceder al texto contenido en “elem”:

! String contenido = elem.getTextContent()

o Ejemplo: String nombreCanal = nodoNombreCanal.getTextContent()

Esto nos daría el texto contenido en el elemento. Si es un elemento con contenido estructurado nos devolvería
todo el texto agregado de sus descendientes.

! O también mediante el método “getNodeValue”

o Ejemplo incorrecto: String nombreCanal = nodoNombreCanal.getNodeValue() ¡¡¡NO funciona!!!
o Ejemplo correcto: String nombreCanal = nodoNombreCanal.getFirstChild().getNodeValue()

Conviene aplicar el método trim() a todas las cadenas que se lean para eliminar los espacios antes y después.

Además de los métodos mencionados existen muchos otros para averiguar diversa información del árbol o
realizar un gran número de tareas sobre él. Para escribir correctamente programas que usen JAXP es necesario
revisar el JavaDoc de sus clases para conocer las alternativas y elegir las más adecuadas para nuestro propósito.