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.
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.
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!
Tutoriales
