Rodrigo Braga Roberto Castillo Carolin

Universidad Católica de Temuco
Proyecto de Software
Profesor Gustavo Donoso
Integrantes:
Rodrigo Braga
Roberto Castillo
Carolina Ramírez
Tema:
“Inserción de una red social en Videoschistosos.net”
Blog:
http://videoschistososnet.wordpress.com/
JDOM
JDOM es una biblioteca de código fuente para manipulaciones de datos XML optimizados
para Java. A pesar de su similitud con DOM del consorcio World Wide Web (W3C), es una
alternativa como documento para modelado de objetos que no está incluido en DOM. La
principal diferencia es que mientras que DOM fue creado para ser un lenguaje neutral e
inicialmente usado para manipulación de páginas HTML con JavaScript, JDOM se creó
específicamente para usarse con Java y por lo tanto beneficiarse de las características de
Java, incluyendo sobrecarga de métodos, colecciones, etc. Para los programadores de
Java, JDOM es una extensión más natural y correcta. Se asemeja al sistema RMI
optimizado para Java (invocación remota de métodos), y se amolda mejor que CORBA
(arquitectura de intermediario solicitador de objetos comunes) que es más neutral
respecto a los lenguajes.
Como dato curioso, aunque JDOM parezca un acrónimo de Java Document Object Model
(Documento de Modelado de Objetos en Java), esto no es así, siendo desmentido por el
propio proyecto de JDOM.
Ventajas de JDOM:
•
•
•
Pensada especialmente para Java y por tanto mejor integrada en este lenguaje.
Facilidad de uso (para programadores que conozcan Java)
Representación de documentos como árboles, lo que posibilita el acceso directo a
cualquier parte del documento (ventaja sobre SAX)
•
Desventajas de JDOM:
•
•
Mayor consumo de memoria que SAX (puesto que usualmente se debe procesar y
mantener en memoria el árbol del documento XML o una porción del mismo).
El carecer del concepto de Nodo dificulta en cierta medida la navegación a través
del árbol del documento. Por ejemplo, al obtener los hijos de un elemento, el
resultado es una lista (java.util.List) de objetos genéricos, y debemos comprobar
qué representan esos objetos (por ejemplo usando instanceof) para saber si son
elementos, atributos, etc.
Principales clases y métodos.
Element: Clase que representa a un nodo. Desde él se puede acceder tanto al nodo padre
como a los nodos hijo, en el caso de que los tuviera. Además almacena el valor de los
atributos (encapsulados mediante la clase Attribute, aunque no es absolutamente
necesaria conocerla).
Sus principales métodos son:
public Element getChild([String nombre]): Devuelve el primer hijo. Si se le pasara un
nombre, se le devolvería el primer hijo cuyo nombre de la etiqueta coincidiera.
public List getChildren([String nombre]): Retorna una lista de objetos de tipo Element con
los nodos de todos sus hijos. Si se le pasa el parámetro, solo devolverá los nodos cuyo
nombre de etiqueta coincida con el parámetro.
public String getAttributeValue(String nombre): Devuelve el valor del atributo pasado por
parámetro.
public String getText(): Devuelve el texto contenido entre el inicio y el fin de cierta
etiqueta.
Todos estos métodos tienen su análogo set...(), para almacenar los datos.
Document: Almacena datos más generales del documento XML, tales como version, nodo
raíz (muy importante), etc.
De aquí es indispensable solo un único método:
public Element getRootElement(): Retorna el nodo raíz del documento. A partir de este
nodo se pueden acceder al resto.
XMLOutputter: Sirve para almacenar los cambios en un fichero.
public void output(?,?): Almacena los cambios. Este método está muy sobrecargado.
SAXBuilder: Clase para leer los datos de un fichero XML existente.
public Document build(File fichero_xml): Devuelve el objeto Document relacionado con
ese archivo.
Ejemplos
Ejemplo 1
Supongamos que el archivo "foo.xml" es el siguiente:
<tienda nombre="tienda para geeks" ubicacion="Tokio, Japon">
<computadora nombre="iBook" precio="$1200" />
<historieta nombre="Dragon Ball Volumen 1" precio="$9" />
<nivel_geek_de_la_tienda precio="sin precio" />
</tienda>
Es posible parsear el documento XML en un árbol de objetos Javas con JDom:
SAXBuilder builder = new SAXBuilder ();
Document doc = builder.build (new FileInputStream ("foo.xml"));
Element root = doc.getRootElement ();
root.getName ();
// devuelve "tienda"
root.getAttributeValue ("nombre");
// devuelve "tienda para geeks"
root.getAttributeValue ("ubicacion");
// devuelve "Tokio, Japon"
root.getChildren ();
// devuelve una java.util.List
de objetos java con 3
elementos
También es posible realizar el proceso inverso, es decir construir un árbol de elementos y luego
crear un archivo XML:
Element root = new Element ("tienda");
root.setAttribute ("nombre", "tienda para geeks");
root.setAttribute ("ubicación", "Tokio, Japon");
Element item1 = new Element ("computadora");
item1.setAttribute ("nombre", "iBook");
item1.setAttribute ("precio", "$1200");
root.addContent (item1);
// Realizamos lo mismo con los elementos restantes
XMLOutputter outputter = new XMLOutputter ("",true);
try{outputter.output (new Document(root),new FileOutputStream
("foo2.xml"));
} catch (Exception e){
e.getMessage();
}
Ejemplo 2
1. Documento XML:
<?xml version="1.0" encoding="UTF-8"?>
<car vin="123fhg5869705iop90">
<!--Description of a car-->
<make>Toyota</make>
<model>Celica</model>
<year>1997</year>
<color>green</color>
<license state="CA">1ABC234</license>
</car>
Entre el punto 2 y 7 se creará el documento paso por paso.
Empecemos por crear el elemento root y agregarlo a un documento.
2. Creando el documento:
Element carElement = new Element("car");
Document myDocument = new Document(carElement);
Este paso crea un nuevo org.jdom.Element y lo hace el elemento root del org.jdom.Document
myDocument. Como un documento XML debe tener siempre un único elemento root, Document
toma a Element en su constructor.
Ahora agregaremos el atributo “vin”.
3. Agregando un atributo:
carElement.addAttribute(new Attribute("vin", "123fhg5869705iop90"));
Agregar elemetos es muy directo, ahora agregaremos el elemento make.
4. Elementos y subelementos:
Element make = new Element("make");
make.addContent("Toyota");
carElement.addContent(make);
Como el método addContent de un Element retorna el Element, esto también se puede escribir de
la siguiente forma.
5. Agregando elementos en forma resumida:
carElement.addContent(new Element("make").addContent("Toyota"));
Las dos formas son correctas, pero el segundo es más entendible si se tiene que agregar una gran
cantidad de elementos de una vez.
6. Agregando los elementos restantes:
carElement.addContent(new Element("model").addContent("Celica"));
carElement.addContent(new Element("year").addContent("1997"));
carElement.addContent(new Element("color").addContent("green"));
carElement.addContent(new Element("license")
.addContent("1ABC234").addAttribute("state", "CA"));
Para el elemento license no sólo se agrego el contenido del elemento, sinó que también se agregó
un atributo a él. Esto es posible porque el método addContent en un elemento siempre devuelve
el elemento mismo.
7. Agregando un comentario:
carElement.addContent(new Comment("Description of a car"));
La manipulación de docuementos es de las misma forma. Por ejemplo, para obtener una
referencia al elento year, hacemos uso del método getChild de un elemento.
8. Accediendo a los elementos hijos:
Element yearElement = carElement.getChild("year");
Esto retornará el primer elemento hijo con el nombre year. Si no hay un elemento year retornará
nulo. Recordar que elementos hijos son simples elementos. De la misma manera podemos quitar
elementos.
9. Removiendo elementos hijos:
boolean removed = carElement.removeChild("year");
Esta llamada removera el elemento year solamente, el resto del documento permanece igual.
Una vez terminada la construcción del documento, podemos devolverlos con la la clase de JDOM
XMLOutputter.
10. Devolviendo Jdom como un texto XML:
try {
XMLOutputter outputter = new XMLOutputter("
outputter.output(myDocument, System.out);
} catch (java.io.IOException e) {
e.printStackTrace();
}
", true);
XMLOutputter tiene algunas opciones de formateado. Aquí hemos especificado que queremos a
los elementos hijos dos espacios separados del elemento padre, y que queremos líneas entre cada
elemento. XMLOutputter puede devolver un Writer o un OutputStream. Para devolver el texto
XML a un archivo específico sólo debemos cambiar la línea del output.
11. Usando Filwriter para devolver un XML:
FileWriter writer = new FileWriter("/some/directory/myFile.xml");
outputter.output(myDocument, writer);
writer.close();
Otra habilidad de JDOM e sla posibilidad de leer y manipular datos XML que ya están creados. Leer
un archivo XML bien creado se puede hacer usando una de las clases de org.jdom.input. En este
ejemplo usaremos SAXBulider:
12. Parsear un archivo XML con SAXBuilder
try {
SAXBuilder builder = new SAXBuilder();
Document anotherDocument =
builder.build(new File("/some/directory/sample.xml"));
} catch(JDOMException e) {
e.printStackTrace();
} catch(NullPointerException e) {
e.printStackTrace();
}
El archivo se puede manipular de la misma forma mostrada en los puntos 2 al 7.
Instalación
Se debe descargar la librería jdom.jar desde la página:
http://www.jdom.org/downloads/index.html
Luego se procede a su inclusión en el proyecto respectivo, en la capa ejb y en la capa war
como se muestra a continuación.
Primero se va a la capa ejb, se selecciona “Libraries” y con botón derecho se selecciona la
opción “Add JAR/Folder…”
Se busca la carpeta donde tengamos el archivo jdom.jar y presionamos “Abrir”.
Finalmente tenemos la librería jdom instalada. Se debe hacer lo mismo para la capa War.