El API JAXP

• Crear y Manipular un DOM
• Obtener un DOM desde un Factoría
• Modificar el Código
• Crear Nodos Element y Text
• Ejecutar la Aplicación
• Normalizar el DOM
• Otras Operaciones
• Mover Nodos
• Crear Atributos
• Eliminar y Cambiar Nodos
• Finalizando

Crear y Manipular un DOM

Hasta ahora, hemos comprendido la estructura de nodos que componen un DOM. Un DOM realmente es muy fácil de crear. Esta sección del tutorial DOM nos va a llevar mucho menos trabajo que nada de lo que hemos visto hasta ahora.

 Obtener un DOM desde un Factoría

En esta versión de la aplicación también vamos a crear una nueva factoría constructora de documentos, pero esta vez le vamos a decir que cree un nuevo DOM en lugar de analizar un documento XML existente. Dejaremos todas las funcionalidades existentes intactas, y añadiremos la nueva funcionalidad en forma de interruptor para poder volver al comportamiento de analizador.

Note: El código de está sección es DomEcho05.java.

 Modificar el Código

Empezamos desactivando la caracterísitica de compresión. Como vamos a trabajar con el DOM en esta sección, queremos ver todos los nodos.

public class DomEcho05  extends JPanel
{
    ...
    boolean compress = true;
    boolean compress = false;

Luego, necesitamos crear un método buildDom que cree el objeto document. La forma más fácil de hacer esto es crear el método y copiar la sección de construcción del DOM desde el método main para crear el buildDom. Las modificaciones mostradas abajo muestran los cambios que necesitamos hacer en el código del método buildDom:

public class DomEcho05  extends JPanel
{
    ...
    public static void makeFrame() {
        ...
    }
    public static void buildDom ()
    {
        DocumentBuilderFactory factory = 
			DocumentBuilderFactory.newInstance();
        try {
          DocumentBuilder builder = factory.newDocumentBuilder();
          document = builder.parse( new File(argv[0]) );
          document = builder.newDocument();  // Create from whole cloth

        } catch (SAXParseException spe) {
           ...

        } catch (SAXException sxe) {
           ...

        } catch (ParserConfigurationException pce) {
            // Parser with specified options can't be built
            pce.printStackTrace();

        } catch (IOException ioe) {
           ...
        }
    }

En este código, reemplazamos la línea que hace el análisis con una que crea el DOM. Luego, como el código no va a analizar un fichero existente, eliminamos las excepciones que ya no se lanzarán: SAXParseException, SAXException, y IOException.

Finalmente, como vamos a trabajar con objetos Element, añadimos la sentencia para importar la clase al principo del programa.

import org.w3c.dom.Document;
import org.w3c.dom.DOMException;
import org.w3c.dom.Element;

 Crear Nodos Element y Text

Ahora, para nuestro primer experimento, añadimos las operaciones Document para crear un nodo raíz y varios hijos.

public class DomEcho05  extends JPanel
{
    ...
    public static void buildDom ()
    {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
          DocumentBuilder builder = factory.newDocumentBuilder();
          document = builder.newDocument();  // Create from whole cloth

          Element root = 
                  (Element) document.createElement("rootElement"); 
          document.appendChild (root);
          root.appendChild( document.createTextNode("Some") );
          root.appendChild( document.createTextNode(" ")    );
          root.appendChild( document.createTextNode("text") );

        } catch (ParserConfigurationException pce) {
            // Parser with specified options can't be built
            pce.printStackTrace();
        }
    }

Finalmente, modificamos el código de chequeo de la lista de argumentos de la parte superior del método main para inovocar a nuestros buildDom y makeFrame en lugar de generar un error.

public class DomEcho05  extends JPanel
{
    ...
    public static void main (String argv [])
    {
        if (argv.length != 1) {
            System.err.println ("Usage: java DomEcho filename");
            System.exit (1);
            buildDom();
            makeFrame();
            return;
        } 

Si suministramos un argumento especificando un fichero, éste será analizado, si no lo hacemos, se ejecutará el código experimental que construye el DOM.

 Ejecutar la Aplicación

Compilamos y ejecutamos el programa sin argumentos y veremos el resultado de la figura 1.

 Normalizar el DOM

En este experimento, manipularemos el DOM que hemos creado normalizándolo después de haberlo construido.

Nota: El código de está sección es DomEcho06.java.

Añadimos el código en negrita de abajo, para normalizar el DOM:

    public static void buildDom ()
    {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        try {
          ...
          root.appendChild( document.createTextNode("Some") );
          root.appendChild( document.createTextNode(" ")    );
          root.appendChild( document.createTextNode("text") );

          document.getDocumentElement().normalize();

        } catch (ParserConfigurationException pce) {
            ...

En este código, getDocumentElement devuelve el nodo raíz del documento, y la operación normalize manipula el arbol.

Cuando compilamos y ejecutamos la aplicación, el resultado se parece al de la figura 2.

Aquí podemos ver que los nodos de texto adyacentes han sido combinados en un sólo nodo. La operación de normalización es una que normalmente queremos hacer después de hacer modifiaciones a un DOM, para asegurarnos que el DOM resultante es tan compacto como sea posible.

Nota: Ahora que tenemos este programa para experimentar con él, pudes ver que sucede con otras combinaciones de CDATA, referencias de entidad, y nodos de texto cuando los normalizas.

 Otras Operaciones

Para completar esta sección, echaremos un rápido vistazo a otras operaciones que podríamos querer aplicar a un DOM, incluyendo:

• Mover Nodos
• Crear Atributos
• Eliminar Nodos

 Mover Nodos

El interface Node define un número de métodos que podemos usar para mover nodos, incluyendo getFirstChild, getLastChild, getNextSibling, getPreviousSibling, y getParentNode. Estas operaciones son suficientes para obtener algo de una posición del árbol y ponerlo en otra.

 Crear Atributos

El interface org.w3c.dom.Element, que extiende Node, define una operación setAttribute que añade un atributo a un nodo.

También podemos usar la operación createAttribute de Document para crear un ejemplar del Attribute, y usar una versión sobrecargada de setAttribute para añadirlo.

 Eliminar y Cambiar Nodos

Para eleminar un nodo, usamos el método removeChild de su padre. Para cambiarlo, o usamos la operación replaceChild de su padre o su propia operación setNodeValue.

 Finalizando

¡Felicidades! Has aprendido cómo está estructurado un DOM y cómo manipularlo. Ahora tienes una aplicación DomEcho que puedes usar para mostrar la estructura de un DOM, dondensarlo en dimensiones compatibles GUI, y experimentar para ver como afectan a la estructura las distintas operaciones. ¡Diviertete con ella!