Este artículo es un tutorial de como leer y escribir desde y hacia un archivo XML con XMLBeans.
Como todos los tutoriales de este sitio el enfoque es práctico, instala lo necesario en tu equipo para correr el ejemplo, descárgalo, ejecútalo y después regresa a entender que es lo que hace el ejemplo.
No olvides dejar comentarios, sugerencias y dudas en la sección de comentarios.
Requisitos: Los únicos prerequisitos previos para entender y ejecutar el ejemplo son:
- Nociones Basicas de Java
- Nociones Basicas de XML
- Tener instalado el JDK 1.4+
- Conocimientos básicos de Ant (Ver tutorial de Ant)
Para correr el ejemplo, descarga el siguiente archivo
y descomprímelo en tu disco duro, desde una ventana de ms-dos (o un shell
de Unix/Linux) , cambia de directorio hacia la ruta donde hayas descomprimido
el ejemplo, y ejecuta el siguiente comando (es necesario haber configurado
previamente Ant ):
D:\cd XMLBeansTutorial
D:\XMLBeansTutorial>ant runSample
Si configuraste correctamente las variables de entorno debes de ver la siguiente salida:
D:\XMLBeansTutorial>ant runSample
Buildfile: build.xml
schemas.jar:
[xmlbean] Time to build schema type system: 1.504 seconds
[xmlbean] Time to generate code: 0.376 seconds
[xmlbean] Compiling 5 source files to DOCUME~1\USERNAME\LOCALS~1\Temp\xbean61862.d\classes
[xmlbean] Note: Some input files use or override a deprecated API.
[xmlbean] Note: Recompile with -Xlint:deprecation for details.
[xmlbean] Time to compile code: 2.24 seconds
[xmlbean] Building jar: www.marioalberto.com.mx\tutorialesCode\xmlBeans\lib\schemas.jar
build:
[mkdir] Created dir: www.marioalberto.com.mx\tutorialesCode\xmlBeans\classes
[javac] Compiling 5 source files to www.marioalberto.com.mx\tutorialesCode\xmlBeans\classes
[javac] Note: Some input files use or override a deprecated API.
[javac] Note: Recompile with -Xlint:deprecation for details.
[javac] Note: www.marioalberto.com.mx\tutorialesCode\xmlBeans\src\mx\com\marioalberto\curso\impl\CursoDocumentImpl.java uses unchecked or unsafe operations.
[javac] Note: Recompile with -Xlint:unchecked for details.
runSample:
[java] Se encontraron: 4 alumnos
[java] Raul
[java] raul.gomez@ejemplo.com
[java]
[java] Mario
[java] mario.ramirez@ejemplo.com
[java]
[java] Luis
[java] luis.rodriguez@ejemplo.com
[java]
[java] Pedro
[java] pedro.rojas@ejemplo.com
BUILD SUCCESFUL
Total time: 9 seconds
D:\XMLBeansTutorial>
Si es asi acabas de ejecutar un programa que lee un archivo XML recorre cada uno de los elementos y agrega uno nuevo.
Recuerda que es necesario haber instalado
y configurado previamente Ant
XMLBeans es una herramienta que nos permite manipular XML, asociando cada uno de los elementos de un documento XML, a objetos y tipos de datos de Java, haciendo mas amigable el uso de XML.
XMLBeans utiliza un esquema de XML (archivo XSD) para compilar las interfaces y las clases necesarias para poder acceder y modificar un documento XML.
Una vez que se han generado las clases y las interfaces, es posible manipular archivos de XML como si fuera una colección de objetos y sin tener que hacer parsing (análisis sintáctico) , ya que las funciones encargadas de hacer el Análisis Sintáctico o parsing son generadas por el XMLBeans a partir del archivo de esquema XSD.
Cuando se va a utilizar un archivo XML es necesario definir ciertas reglas sobre la estructura y el contenido (tipo de datos) que seran validos para ese documento.
De esta forma, conociendo las reglas podemos verificar si una instancia en particular de un documento XML es valida o no.
Actualmente las dos principales formas de definir estas reglas es a traves de:
- Document Type Definition (DTDs)
- XML Schema Definition (XSD)
XMLBeans utiliza el XML Schema Definition(XSD) para generar las clases e interfaces de Java.
A grandes rasgos el esquema XSD es un archivo de texto en el que se definen las
reglas que debe seguir un documento XML para ser considerado como "valido".
El archivo xsd que define las reglas para el archivo XML de nuestro ejemplo es el siguiente:
Nombre del Alumno
Si se desea saber mas acerca del documento de esquema se pueden revisar la siguientes ligas:
XML_Schema : Definicion de Wikipedia (en español)
W3C XML Schema: Pagina oficial de la World Wide Web Consortium ( en Ingles) http://www.w3.org/XML/Schema
XML Schema Tutorial: Tutorial de Esquema XML en W3 Schools (en Ingles) http://www.w3schools.com/Schema/default.asp
Basicamente para poder utilizar XMLBeans se tienen que llevar a cabo las siguientes tareas:
- Obtener la versión mas actual de XMLBeans
- Obtener o definir que reglas debe seguir el archivo XML que se va a utilzar, es decir, es necesario contar con el esquema XSD, o si no se cuenta con el definir un archivo XSD basico en base a la estructura del archivo xml a utilizar
- Compilar el esquema con la herramienta scomp incluida en el directorio /bin de la instalación de XMLBEans , este paso se puede llevar a cabo manualmente desde la linea de comando o desde Ant.
Si el proceso de compilación se llevo a cabo exitosamente se obtiene un JAR con todas las clases a utilizar.
- Utilizar el jar generado para manipular el archivo XML
El objetivo del ejemplo es manipular un archivo XML en el cual se tiene almacenado una lista de alumnos que asisten a un curso, el cual se muestra a continuación
Raul
Gomez
25
raul.gomez@ejemplo.com
Mario
Ramirez
29
mario.ramirez@ejemplo.com
Luis
Rodriguez
29
luis.rodriguez@ejemplo.com
Pedro
Rojas
39
pedro.rojas@ejemplo.com
Como ya mencionamos anteriormente para generar las clases e interfaces que nos permitiran manipular el archivo es necesario utilizar la herramienta scomp (en el directorio bin de la instalación de XMLBeans) para compilar el XSD.
Es en este paso, es donde XMLBeans genera las clases e interfaces para el manejo de XML.
La forma mas básica de utilizar el scomp es la siguiente:
scomp -out lib\schemas.jar schemas\Curso.xsd
En la cual unicamente se indican cual sera la ruta y el nombre del archivo jar a generar y en donde se encuentra ubicado el esquema
Tambien es posible indicarle parametros extras al compilador de esquemas, por ejemplo, si se desea que se genere el código fuente en un subdirectorio aparte se debe indicar la opción -src,
si se desea utilizar un compilador en especifico para generar el codigo se utiliza la opción -compiler.
Por ejemplo:
scomp -compiler "\Program Files\Java\jdk1.5.0_12\bin\javac" -src /src -out curso.jar Curso.xsd
Una forma adicional de utilizar el scomp es a traves de un Task para Ant el cual se incluye en la distribución de Xmlbeans
Para utilizar el task se debe incluir lo siguiente en el archivo build.xml
Una vez configurado el task lo podemos utilizar en un target (en este caso, lo nombramos schemas.jar) de la siguiente forma:
En este target le indicamos al compilador de esquemas lo siguiente:
- Utilizar los esquemas que se encuentren en la carpeta schemas (en este caso el unico esquema que hay es Curso.xsd)
- Generar el archivo "schemas.jar" en el directorio "lib"
- Generar tambien el codigo fuente y guardarlo en la carpeta "src"
Basicamente lo que el ejemplo hace (a través de Ant) es :
a)Ejecutar el target de Ant "schemas.jar" que acabamos de definir(ver archivo build.xml) para generar el jar con las clases.
b)Compilar y Ejecutar el archivo XmlBeanExample.java el cual se muestra a continuación y se describe en las siguientes secciones:
package com.marioalberto.tutoriales.xmlbeans;
import java.io.File;
import java.math.BigInteger;
import org.apache.xmlbeans.XmlCursor;
import mx.com.marioalberto.curso.*;
import mx.com.marioalberto.curso.CursoDocument.Curso;
public class XmlBeanExample {
public static void main(String args[]) {
try {
String filePath = "curso.xml";
File inputXMLFile = new java.io.File(filePath);
CursoDocument cursoDoc= CursoDocument.Factory.parse(inputXMLFile);
Curso curs= cursoDoc.getCurso();
AlumnoType[] alumnos;
alumnos=curs.getAlumnoArray();
int size=alumnos.length;
System.out.println("Se encontraron: " +size+ " alumnos");
for(int count=0;count<size;count++) {
System.out.println(alumnos[count].getNombre() );
System.out.println(alumnos[count].getEmail() );
System.out.println("");
}
AlumnoType alumnoNuevo=cursoDoc.getCurso().addNewAlumno();
alumnoNuevo.setNombre("Carlos");
alumnoNuevo.setApellido("Mendez");
alumnoNuevo.setEdad(new BigInteger("23"));
alumnoNuevo.setEmail("carlos.mendez@ejemplo.com");
cursoDoc.save(new File("curso.xml"));
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Como podemos ver en el listado anterior, para leer el archivo XML solo hay que utilizar las clases generadas, para nuestro ejemplo de curso utilizamos la clase
CursoDocument para hacer el "parsing" o análisis sintáctico con la instrucción:
CursoDocument cursoDoc= CursoDocument.Factory.parse(inputXMLFile);
A continuación instanciamos un objeto Curso:
Curso curs= cursoDoc.getCurso();
Un curso esta conformado por varios alumnos, para obtener el listado de alumnos utilizamos el metodo getAlumnoArray():
AlumnoType[] alumnos;
alumnos=curs.getAlumnoArray();
Ahora que ya tenemos un arreglo de alumnos podemos utilizar los elementos en nuestro programa, en este ejemplo unicamente los
desplegamos en pantalla utilizando un for:
for(int count=0;count<size;count++) {
System.out.println(alumnos[count].getNombre() );
System.out.println(alumnos[count].getEmail() );
System.out.println("");
}
Para actualizar el archivo xml agregandole un registro utilizamos el metodo addNewAlumno() y el metodo save(), al metodo save se le envía el nombre del archivo en el que se desean grabar los cambios
AlumnoType alumnoNuevo=cursoDoc.getCurso().addNewAlumno();
alumnoNuevo.setNombre("Carlos");
alumnoNuevo.setApellido("Mendez");
alumnoNuevo.setEdad(new BigInteger("23"));
alumnoNuevo.setEmail("carlos.mendez@ejemplo.com");
cursoDoc.save(new File("curso.xml"));
Los pasos a seguir y las consideraciones a tener en cuenta para utilizar XMLBeans son:
- Descargar XMLBeans y para obtener los archivos jar:
-
Tener el archivo de esquema XSD, que describe la estructura del archivo XML a manipular.
-
Generar el jar que contiene las clases e interfaces necesarias con el compilador scomp
-
Utilizar las clases generadas en un programa de Java para manipular el XML.
Espero que este articulo te sea de utilidad, recuerda que puedes poner tus dudas en la sección de comentarios donde seran respondidas a la brevedad.
© Copyright Mario Alberto Ramirez, todos los derechos reservados
