JDOM

JAVA+XML = JDOM (Parte 1)
Introducción
JDOM es un API para leer, crear y manipular documentos XML de una
manera sencilla y muy intuitiva para cualquier programador en Java, en
contra de otras APIs tales como DOM y SAX, las cuales se idearon sin
pensar en ningún lenguaje en concreto, de ahí que resulte un poco
incomodo su utilización.
En este articulo exploraremos un poco el API, crearemos una pequeña

aplicación que lea un documento XML y sacaremos de él aquellas partes que
nos interese. Para abrir boca, imagínate este trozo de XML:
...
<site>javahispano</site>
...
Se imagina acceder al texto del elemento site de esta manera:
String nombre = site.getText();

¿Te gusta? Esto es JDOM.
Donde se encuentra JDOM

Para comenzar haremos una visión de pájaro para ver donde encajamos
JDOM en un pequeño esquema.
Antes de seguir adelante permitirme una aclaración: DOM y SAX son dos
especificaciones que como tal no podemos trabajar con ellas, pero si con las
implementaciones de dichas especificaciones, es decir, los parsers: Xerces,
XML4j, Crimson, Oracle's parsers,...
Pues bien un ultimo apunte, la API JDOM no es un parser, de echo, usa

un parser para su trabajo, JDOM "solo" nos aporta una capa de abstracción
en el tratado de documentos XML facilitándonos bastante la tarea como
veremos enseguida, de echo no tendremos que ser unos gurus de DOM y
SAX para poder trabajar con XML desde Java.
Donde conseguir JDOM

En www.jdom.org podremos descargar tanto el API como la documentación
que necesitemos. Antes de que se me olvide, la licencia es open source. :-)
Como JDOM fue diseñado usando List y Map de la API Java 2 Collections,
tendremos que utilizar el jdk 1.2 o si usas el jdk 1.1 deberás de instalar la
librería Collections.
Estructura de JDOM
El API está formado por 5 packages. De entre ellas comentamos lo siguiente
que será mas que suficiente para utilizar el API.
 El package org.jdom destacamos las clases: Document que

representará el documento XML, Element que representará el
elemento o etiqueta que forma el documento, y la clase
Attribute que como bien imaginaras representa los atributos
que puedan tener los elementos.
 El package org.jdom.adapters albergará todas las clases
adaptadoras (ver patrón de diseño Adapter, Thinking in
patterns) ya que no todos los parsers DOM tienen la misma
API. Mas tarde quedara mas claro su función.
 El package org.jdom.input albergara las clases builder para
construir los documentos XML.
 El package org.jdom.output albergara las clases que
utilizaremos para dar salida a nuestra clase Document.
Un poco de teoría
Como dije al principio del articulo JDOM usaba los parsers para hacer su
trabajo, pues bien, para decirle a JDOM que parser utilizar utilizaremos uno
de los siguientes métodos:
public SAXBuilder(String parserClass, boolean validation)

El primer parámetro es el parser que vamos a utilizar, por defecto se
utilizará el parser Xerces.
El segundo parámetro es para decirle si queremos que el parser cumpla sus

obligaciones de validación.
public DOMBuilder(String adapterClass, boolean validation)

El primer parámetro es la clase adaptadora que vamos a utilizar para el
parser que utilizaremos .
El segundo parámetro es igual que el del SAXBuilder.
Ahora al builder le daremos la orden de parsear el documento XML con el

método build(), cuya forma es:
Document build(File file)

Muy bien ya tenemos el documento almacenado en la clase Document.
Finalmente vamos a aprender unos cuantos métodos mas para recuperar la
información que deseemos:
Este método pertenece a la clase Document
Element getRootElement(); //cojer el nodo raiz del documento.

Estos métodos pertenecen a la clase Element:
String getText();
//Capturar el texto de una etiqueta o elemento.
List getChildren();
//Coger todos los elementos que cuelgan del Element.
List getChildren(String nombre);
//Coger todos los elementos que tengan ese nombre
List getMixedContent();
//Para recuperar todo(comentarios, PIs, elementos,...)
// de lo que cuelga del Element.
Element getChild (String nombre);
//Coger el primer hijo que tenga ese nombre.
String getAttributeValue(String nombre);
//Coger el valor del atributo que pasamos como parámetro.
Attribute getAttribute(String nombre);
//Coger el atributo que tenga ese nombre y para recuperar
//el valor de ese atributo se
//utilizaría el método del attribute: String getValue();
Nuestro primer programa

Dado el siguiente documento XML:
<?xml version="1.0"?>
<liga tipo="Champions League">
<equipo>
<club valoracion="10" ciudad="Bilbao">Athletic Club Bilbao</club>
<presidente>Uria</presidente>
<plantilla>
<nombre>Julen Guerrero</nombre>
<nombre>Joseba Etxeberria</nombre>
<nombre>Ismael Urzaiz</nombre>
</plantilla>
</equipo>
<equipo>

<club valoracion="5" ciudad="Madrid">Real Madrid</club>
<presidente>Mandamas</presidente>
<plantilla>

<nombre>Bota de oro</nombre>
<nombre>Milloneti</nombre>
<nombre>Canterano quemado</nombre>
</plantilla>
<conextranjeros/>
</equipo>
<arbitros>
<nombre>No doy una</nombre>
<nombre>Rafanomejodas</nombre>
</arbitros>
</liga>
Vamos a hacer un programa que lo lea y nos muestra cierta información.
Este sería el codigo:
import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
public class Ejemplo {
public static void main(String[] args) {

try {
SAXBuilder builder=new SAXBuilder(false);
//usar el parser Xerces y no queremos
//que valide el documento
Document doc=builder.build("liga.xml");
//construyo el arbol en memoria desde el fichero
// que se lo pasaré por parametro.
Element raiz=doc.getRootElement();
//cojo el elemento raiz
System.out.println("La liga es de tipo:"+
raiz.getAttributeValue("tipo"));
//todos los hijos que tengan como nombre plantilla
List equipos=raiz.getChildren("equipo");
System.out.println("Formada por:"+equipos.size()+" equipos");
Iterator i = equipos.iterator();
while (i.hasNext()){
Element e= (Element)i.next();
//primer hijo que tenga como nombre club
Element club =e.getChild("club");
List plantilla=e.getChildren("plantilla");
System.out.println
(club.getText()+":"+"valoracion="+
club.getAttributeValue("valoracion")+","+
"ciudad="+club.getAttributeValue("ciudad")
+","+
"formada por:"+plantilla.size()
+"jugadores");
if (e.getChildren("conextranjeros").size()==0)
System.out.println("No tiene extranjeros");
else System.out.println("Tiene extranjeros");
}
// Dejamos de mano del lector el sacar el nombre
//de los arbitros, animate!!
}catch (Exception e){
e.printStackTrace();
}
}
}
Conclusión
Como hemos visto el leer documentos XML y sacar la información de dicho
documento es un trabajo realmente fácil con JDOM, como veremos en el
siguiente articulo el crear documentos con esta API no es mucho mas
complicado.
Java y XML: JDOM
Este es otro post de la serie de artículos sobre Java y XML. Tras
haber visto cómo trabajar con SAX y DOM, ahora toca el turno de
hablar un poco de JDOM.
JDOM es una API desarrollada específicamente para Java y da

soporte al tratamiento de XML: parseo, búsquedas, modificación,
generación y serialización. Es un modelo similar a DOM, pero no está
creado ni modelado sobre DOM. Se trata de un modelo alternativo. La
principal diferencia es que DOM fue desarrollado para que fuera
independiente del lenguaje, mientras que JDOM está creado y
optimizado específicamente para Java. Esto imprime a JDOM las
ventajas inherentes a Java, lo que lo hacen que sea una API más
eficiente y más natural de usar para el desarrollador Java y por tanto
requerie un menor coste de aprendizaje.
Al igual que DOM, JDOM genera un árbol de nodos al parsear un

documento XML. En cuanto a lo tipos de nodos, son similares a los de
DOM, aunque algunos cambia el nombre ligeramente. La jerarquía de
clases también se ve algo modificada.
Mientras que en DOM todo hereda de la clase Node, en JDOM casi

todo hereda de la claseContent, que se encuentran en el
paquete org.jdom. Digo casi todo porque
ni Document niAttribute (Attr en DOM) heredan de Content. La razon
es que Document no se considera un contenido, sino más bien el
continente y Attribute tampoco se considera un nodo, sino una
propiedad de los nodos tipo Element.
Heredan de Content: Element, Comment y Text. De este

último, Text, hereda CDATA(CDATASection en DOM). Por supuesto,
hay más clases que heredan de Content y que forman el árbol de
nodos, pero no las veremos en estos ejemplos ya que su uso es
menos frecuente: DocType, EntityRef y ProccessingInstruction. Estas
o sus equivalentes también existen en DOM.
Otra diferencia entre DOM y JDOM es que mientras en DOM todos

estos tipos de nodos eran interfaces, en JDOM son clases y por
tanto para crear un objeto de cualquier tipo basta con usar el
operador new. Por ejemplo,
view plaincopy to clipboardprint?
1. Element etiqueta = new Element("nombre_etiqueta");
2. CDATA cdata = new CDATA("Contenido del CDATA");
3. Comment comentario = new Comment("Texto del comentario");
Antes de pasar a los ejemplos, voy a comentar qué hay que hacer
para incluir JDOM en tu proyecto. Lo primero es descargar
la última versión de JDOM, por ahora la 1.1. Descomprime el fichero
y sigue las intrucciones de uso. Si eres de los seguidores de la ley del
mínimo esfuerzo, simplemente tienes que copiar los siguientes
ficheros al directoriolib de tu proyecto:
 jdom.jar, el cual se encuentra en la carpeta build.

 jaxen-core.jar, jaxen-jdom.jar y saxpath.jar, que se
encuentran en la carpeta lib.
 Es posible que necesites algunos otros jars que se encuentran
en la carpeta lib. Al menos para los ejemplos publicados aquí no son
necesarios.
Ahora sí, pasemos a lo interesante. Como siempre vamos a partir del

siguiente XML:
1. <?xml version="1.0" encoding="UTF-8"?>
2. <etiquetaPrincipal xmlns:xela="http://www.latascadexela.es" >
3. <etiquetaHija id="1" atributo1="valorAtributo1" atributo2="valorAtr
ibuto2">
4. Texto dentro de la etiqueta hija
5. </etiquetaHija>
6. 
7. <xela:etiquetaConNamespace descripcion="etiqueta con un namespace"/
>
8. </etiquetaPrincipal>
Si tenéis cualquier duda podéis acudir al JavaDoc de JDOM. También

podéis preguntarla aquí. Estaré encantado de ayudar en lo que
pueda.
Parseando un XML
Una de las ventajas de SAX (o la única) es que procesa los ficheros

XML por trozos y por tanto no necesita tener todo el XML en
memoria. Esa ventaja la han aprovechado los de JDOM y para
parsear el XML a partir de un fichero se usa el SAXBuilder.
Internamente usará un SaxHandler que generará el árbol de nodos a
partir del XML.
1. // Creamos el builder basado en SAX
2. SAXBuilder builder = new SAXBuilder();
3. // Construimos el arbol DOM a partir del fichero xml
4. Document documentJDOM = builder.build(new FileInputStream("/ruta_a_fic
hero/fichero.xml"));
Si lo que tenemos es un árbol de nodos DOM, es decir, que lo hemos

generado con DOM, también podemos construir su equivalente JDOM
usando la clase DOMBuilder.
1. DOMBuilder dombuilder = new DOMBuilder();
2. Document doc = dombuilder.build(documentDOM);
Recorriendo el árbol de nodos
Una vez obtenido el objeto Document ya podemos recorrer el árbol

de nodos como gustemos. Un ejemplo de como recorrer las etiquetas
hijas de la etiqueta raíz:
1. // Obtenemos la etiqueta raíz
2. Element raiz = doc.getRootElement();
3. // Recorremos los hijos de la etiqueta raíz
4. List<Element> hijosRaiz = raiz.getChildren();
5. for(Element hijo: hijosRaiz){
6. // Obtenemos el nombre y su contenido de tipo texto
7. String nombre = hijo.getName();
8. String texto = hijo.getValue();
9.
10. System.out.println("\nEtiqueta: "+nombre+". Texto: "+texto);
11.
12. // Obtenemos el atributo id si lo hubiera
13. String id = hijo.getAttributeValue("id");
14. if(id!=null){
15. System.out.println("\tId: "+id);
16. }
17. }
También podemos obtener una etiqueta en concreto de entre las

etiquetas hijas de otra.
1. // Obtenemos una etiqueta hija del raiz por nombre
2. Element etiquetaHija = raiz.getChild("etiquetaHija");
3.
4. // Incluso podemos obtener directamente el texto de una etiqueta hija
5. String texto = raiz.getChildText("etiquetaHija");
y con namespaces
1. // Obtenemos una etiqueta hija del raiz por nombre con Namespaces
2. // Primero creamos el objeto Namespace
3. Namespace nsXela = Namespace.getNamespace("xela", "http://www.latascad
exela.es");
4. // Ahora obtenemos el hijo
5. Element etiquetaNamespace = raiz.getChild("etiquetaConNamespace", nsXe
la);
Buscando con XPath
También podemos usar XPath con JDOM para buscar etiquetas dentro
del XML. Si quieres saber más acerca de XPath, te remito al post de
DOM.
En JDOM existe un objeto llamado XPath, el cuál ofrece dos métodos

estáticos:selectSingleNode y selectNodes. Uno para evaluar
expresiones que devuelvan un único resultado y otro para
expresiones que devuelvan una lista de resultados. El primero es un
caso particular del segundo, que es el caso genérico.
1. // Buscamos una etiqueta mediante XPath
2. Element etiquetaHijaXP = (Element)XPath.selectSingleNode(doc, "/etique
taPrincipal/etiquetaHija");
y con namespaces
1. // Buscamos una etiqueta con namespace mediante XPath
2. Element etiquetaNamespaceXP = (Element)XPath.selectSingleNode(doc, "/e
tiquetaPrincipal/xela:etiquetaConNamespace");
Si vamos a evaluar una misma expresión XPath sobre varios objetos

del XML, como por ejemplo varios Document, es más eficiente
construirnos un objeto XPath con esa expresión y aplicarlo tantas
veces como deseemos. Para ello usamos el método
estático newInstancede XPath.
1. // Si hacemos uso muchas veces del mismo XPath sobre varios document
2. // es más eficiente crear un objeto XPath y usarlo varias veces
3. XPath xpathEtiquetaHija= XPath.newInstance("/etiquetaPrincipal/etiquet
aHija");
4. Element etiqueta1 = (Element)xpathEtiquetaHija.selectSingleNode(doc1);

5. Element etiqueta2 = (Element)xpathEtiquetaHija.selectSingleNode(doc2);

6. ...
7. Element etiquetaN = (Element)xpathEtiquetaHija.selectSingleNode(docN);

Modificando el XML
Podemos modificar el árbol de nodos del XML parseado. Por ejemplo,

vamos a ver lo fácil que es añadir una nueva etiqueta.
1. // Creamos una nueva etiqueta
2. Element etiquetaNueva = new Element("etiquetaNueva");
3. // Añadimos un atributo
4. etiquetaNueva.setAttribute("atributoNuevo", "Es un nuevo atributo");
5. // Añadimos contenido
6. etiquetaNueva.setText("Contenido dentro de la nueva etiqueta");
7. // La añadimos como hija a una etiqueta ya existente
8. etiquetaHija.addContent(etiquetaNueva);
Creando XML desde cero
Con JDOM es fácil crear un XML desde cero. Para crear cada objeto
del árbol de nodos, tan solo tenemos que usar el operador new.
1. // Vamos a crear un XML desde cero
2. // Lo primero es crear el Document
3. Document docNuevo = new Document();
4. // Vamos a generar la etiqueta raiz
5. Element eRaiz = new Element("raiz");
6. // y la asociamos al document
7. docNuevo.addContent(eRaiz);
Copiando nodos de un árbol a otro
Con JDOM es muy fácil pasar elementos de un árbol a otro. Aquí no

existe el concepto deámbito de un document como ocurría en
DOM. Todos los objetos son susceptibles de ser añadido a
cualquier árbol. Lo único que hay que tener en cuenta es que cada
objeto sólo puede tener un padre y por tanto si lo que queremos
es moverlo de un sitio a otro, habrá que desasociarlo antes del padre.
Para ello, la clase Content proporciona el método detach. Es decir, si
hacemos detach en un Element, lo que habremos hecho es dejar
huérfano ese Element, es decir, ya no tiene padre, por lo que se
puede añadir como hijo a cualquier otro nodo.
Si lo que queremos es copiar nodos, usaremos el método clone para

generar una copia del mismo y esta copia la podremos añadir a
cualquier nodo ya que se genera huérfana.
1. // Vamos a copiar la etiquetaHija del primer document a este
2. // Lo primero es crear una copia de etiquetaHija
3. Element copiaEtiquetaHija = (Element)etiquetaHija.clone();
4. // Después la colocamos como hija de la etiqueta raiz
5. eRaiz.addContent(copiaEtiquetaHija);
6.
7. // Vamos a mover la etiquetaConNamespace a este document
8. // Primero la desasociamos de su actual padre
9. etiquetaNamespace.detach();
10. // Una vez que ya es huerfana la podemos colocar donde queramos
11. // Por ejemplo, bajo la etiqueta raiz
12. eRaiz.addContent(etiquetaNamespace);
Una vez ejecutado el ejemplo y si obtenemos la representación en

forma de String del XML obtendremos el siguiente resultado:
1. XML parseado:
3. <etiquetaPrincipal xmlns:xela="http://www.latascadexela.es">
ibuto2">
6. <etiquetaNueva atributoNuevo="Es un nuevo atributo">Contenido de
ntro de la nueva etiqueta</etiquetaNueva>
7. </etiquetaHija>
8. 
9. </etiquetaPrincipal>
10.
11.
12. XML nuevo:
14. <raiz>
ibuto2">
17. <etiquetaNueva atributoNuevo="Es un nuevo atributo">Contenido de
ntro de la nueva etiqueta</etiquetaNueva>
18. </etiquetaHija>
19. <xela:etiquetaConNamespace xmlns:xela="http://www.latascadexela.es"
descripcion="etiqueta con un namespace" />
20. </raiz>
Como podemos observar la etiquetaConNamespace se ha eliminado

del XML original ya que usamos el método detach para llevarla de un
árbol a otro. Esto no ocurre con etiquetaHijaya que previamente
fue clonada.
Serializando el XML
La serialización (paso de árbol de nodos a String o bytes) en JDOM es

muy similar a la que se puede realizar con DOM. Lo primero que
hacemos es especificar el formato de salida del XML, es decir, si
queremos identación entre etiquetas, que las etiquetas sin texto
tengan etiqueta de cierre o no, que haya un retorno de carro entre
etiquetas, que aparezca o no la declaración xml, ....
JDOM ya ofrece tres formatos predefinidos.

Son PrettyFormat, RawFormat yCompactFormat. Sus nombres son
bastante intiuitivos: bonito, plano y compacto. Pero os remito a
la documentación para que sepáis exactamente en qué consiste cada
uno.
Una vez especificado el formato, usamos el XMLOutputter y ya

podemos serializar tantoDocument como Element, como cualquier
nodo. Incluso podemos serializar un listado de nodos. La serialización
la podemos hacer a String, a OuputStream o a Writer, lo que cubre
una amplia gama de posibilidades.
1. // Vamos a serializar el XML
2. // Lo primero es obtener el formato de salida
3. // Partimos del "Formato bonito", aunque también existe el plano y el
compacto
4. Format format = Format.getPrettyFormat();
5. // Creamos el serializador con el formato deseado
6. XMLOutputter xmloutputter = new XMLOutputter(format);
7. // Serializamos el document parseado
8. String docStr = xmloutputter.outputString(doc);
A continuación dejo el código completo de la clase que he creado

como ejemplo:
1. package es.latascadexela.xml.jdom;
2.
3. import java.io.FileInputStream;
4. import java.io.FileNotFoundException;
5. import java.io.IOException;
6. import java.util.List;
7.
8. import org.jdom.Document;
9. import org.jdom.Element;
10. import org.jdom.JDOMException;
11. import org.jdom.Namespace;
12. import org.jdom.input.SAXBuilder;
13. import org.jdom.output.Format;
14. import org.jdom.output.XMLOutputter;
15. import org.jdom.xpath.XPath;
16.
17. /**
18. * Clase de ejemplo de procesado de XML mediante JDOM.
19. *
20. * @author Xela
21. *
22. */
23. public class ProcesaXML {
24.
25. public static void main(String[] args) {
26.
27. try {
28. // Creamos el builder basado en SAX
29. SAXBuilder builder = new SAXBuilder();
30. // Construimos el arbol DOM a partir del fichero xml
31. Document doc = builder.build(new FileInputStream("/ruta_a_fic
hero/fichero.xml"));
32.
33. // Obtenemos la etiqueta raíz
34. Element raiz = doc.getRootElement();
35. // Recorremos los hijos de la etiqueta raíz
36. List<element> hijosRaiz = raiz.getChildren();
37. for(Element hijo: hijosRaiz){
38. // Obtenemos el nombre y su contenido de tipo texto
39. String nombre = hijo.getName();
40. String texto = hijo.getValue();
41.
42. System.out.println("\nEtiqueta: "+nombre+". Texto: "+texto
);
43.
44. // Obtenemos el atributo id si lo hubiera
45. String id = hijo.getAttributeValue("id");
46. if(id!=null){
47. System.out.println("\tId: "+id);
48. }
49. }
50.
51. // Obtenemos una etiqueta hija del raiz por nombre
52. Element etiquetaHija = raiz.getChild("etiquetaHija");
53. System.out.println(etiquetaHija.getName());
54. // Incluso podemos obtener directamente el texto de una etiqu
eta hija
55. String texto = raiz.getChildText("etiquetaHija");
56. System.out.println(texto);
57.
58. // Obtenemos una etiqueta hija del raiz por nombre con Namesp
aces
59. // Primero creamos el objeto Namespace
60. Namespace nsXela = Namespace.getNamespace("xela", "http://www
.latascadexela.es");
61. // Ahora obtenemos el hijo
62. Element etiquetaNamespace = raiz.getChild("etiquetaConNamespa
ce", nsXela);
63. System.out.println(etiquetaNamespace.getName());
64.
65. // Buscamos una etiqueta mediante XPath
66. Element etiquetaHijaXP = (Element)XPath.selectSingleNode(doc,
"/etiquetaPrincipal/etiquetaHija");
67. System.out.println(etiquetaHijaXP.getName());
68.
69. // Buscamos una etiqueta con namespace mediante XPath
70. Element etiquetaNamespaceXP = (Element)XPath.selectSingleNode
(doc, "/etiquetaPrincipal/xela:etiquetaConNamespace");
71. System.out.println(etiquetaNamespaceXP.getName());
72.
73. // Si hacemos uso muchas veces del mismo XPath sobre varios d
ocument
74. // es más eficiente crear un objeto XPath y usarlo varias vec
es
75. XPath xpathEtiquetaHija= XPath.newInstance("/etiquetaPrincipa
l/etiquetaHija");
76. Element etiqueta = (Element)xpathEtiquetaHija.selectSingleNod
e(doc);
77. System.out.println(etiqueta.getName());
78.
79. // Creamos una nueva etiqueta
80. Element etiquetaNueva = new Element("etiquetaNueva");
81. // Añadimos un atributo
82. etiquetaNueva.setAttribute("atributoNuevo", "Es un nuevo atri
buto");
83. // Añadimos contenido
84. etiquetaNueva.setText("Contenido dentro de la nueva etiqueta"
);
85. // La añadimos como hija a una etiqueta ya existente
86. etiquetaHija.addContent(etiquetaNueva);
87.
88. // Vamos a crear un XML desde cero
89. // Lo primero es crear el Document
90. Document docNuevo = new Document();
91. // Vamos a generar la etiqueta raiz
92. Element eRaiz = new Element("raiz");
93. // y la asociamos al document
94. docNuevo.addContent(eRaiz);
95.
96. // Vamos a copiar la etiquetaHija del primer document a este
97. // Lo primero es crear una copia de etiquetaHija
98. Element copiaEtiquetaHija = (Element)etiquetaHija.clone();
99. // Después la colocamos como hija de la etiqueta raiz
100. eRaiz.addContent(copiaEtiquetaHija);
101.
102. // Vamos a mover la etiquetaConNamespace a este documen
t
103. // Primero la desasociamos de su actual padre
104. etiquetaNamespace.detach();
105. // Una vez que ya es huerfana la podemos colocar donde
queramos
106. // Por ejemplo, bajo la etiqueta raiz
107. eRaiz.addContent(etiquetaNamespace);
108.
109.
110. // Vamos a serializar el XML
111. // Lo primero es obtener el formato de salida
112. // Partimos del "Formato bonito", aunque también existe
el plano y el compacto
113. Format format = Format.getPrettyFormat();
114. // Creamos el serializador con el formato deseado
115. XMLOutputter xmloutputter = new XMLOutputter(format);
116. // Serializamos el document parseado
117. String docStr = xmloutputter.outputString(doc);
118. // Serializamos nuestro nuevo document
119. String docNuevoStr = xmloutputter.outputString(docNuevo
);
120.
121. System.out.println("XML parseado:\n"+docStr);
122. System.out.println("XML nuevo:\n"+docNuevoStr);
123.
124. } catch (FileNotFoundException e) {
125. e.printStackTrace();
126. } catch (JDOMException e) {
128. } catch (IOException e) {
130. }
131.
132. }
133.
134. }
135. </element>
Con esto hemos visto lo más importante en cuanto al uso de JDOM.

Por supuesto, hay más cosas que no he mencionado y que pueden
resultar útil. Simplemente he tratado de dar unas nociones básicas de
uso de JDOM para aquellas personas que nunca lo han visto.
Si comparas estos ejemplos con DOM podrás hacerte una idea de lo
fácil e intuitivo que es usar JDOM frente a DOM. Si aún usas SAX o
DOM en tus proyectos, te animo a adentrarte en el mundo de JDOM.
Y si no ves ninguna ventaja, pues nada, sigue con lo que estabas.
Desde mi punto de vista las ventajas son muchas y los
inconvenientes muy pocos.

JDOM

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

JDOM

Cargado por

Copyright:

Formatos disponibles

JAVA+XML = JDOM (Parte 1)

En este articulo exploraremos un poco el API, crearemos una pequeña

String nombre = site.getText();

Donde se encuentra JDOM

Pues bien un ultimo apunte, la API JDOM no es un parser, de echo, usa

Donde conseguir JDOM

 El package org.jdom destacamos las clases: Document que

public SAXBuilder(String parserClass, boolean validation)

El segundo parámetro es para decirle si queremos que el parser cumpla sus

public DOMBuilder(String adapterClass, boolean validation)

El segundo parámetro es igual que el del SAXBuilder.

Ahora al builder le daremos la orden de parsear el documento XML con el

Document build(File file)

Este método pertenece a la clase Document

Element getRootElement(); //cojer el nodo raiz del documento.

Nuestro primer programa

public class Ejemplo {

public static void main(String[] args) {

JDOM es una API desarrollada específicamente para Java y da

Al igual que DOM, JDOM genera un árbol de nodos al parsear un

Mientras que en DOM todo hereda de la clase Node, en JDOM casi

Heredan de Content: Element, Comment y Text. De este

Otra diferencia entre DOM y JDOM es que mientras en DOM todos

 jdom.jar, el cual se encuentra en la carpeta build.

Ahora sí, pasemos a lo interesante. Como siempre vamos a partir del

Si tenéis cualquier duda podéis acudir al JavaDoc de JDOM. También

Una de las ventajas de SAX (o la única) es que procesa los ficheros

Si lo que tenemos es un árbol de nodos DOM, es decir, que lo hemos

Recorriendo el árbol de nodos

Una vez obtenido el objeto Document ya podemos recorrer el árbol

También podemos obtener una etiqueta en concreto de entre las

Buscando con XPath

En JDOM existe un objeto llamado XPath, el cuál ofrece dos métodos

Si vamos a evaluar una misma expresión XPath sobre varios objetos

Podemos modificar el árbol de nodos del XML parseado. Por ejemplo,

Creando XML desde cero

Copiando nodos de un árbol a otro

Con JDOM es muy fácil pasar elementos de un árbol a otro. Aquí no

Si lo que queremos es copiar nodos, usaremos el método clone para

Una vez ejecutado el ejemplo y si obtenemos la representación en

Como podemos observar la etiquetaConNamespace se ha eliminado

La serialización (paso de árbol de nodos a String o bytes) en JDOM es

JDOM ya ofrece tres formatos predefinidos.

Una vez especificado el formato, usamos el XMLOutputter y ya

A continuación dejo el código completo de la clase que he creado

Con esto hemos visto lo más importante en cuanto al uso de JDOM.

También podría gustarte