Leer archivo XML desde Java
Una manera simple de leer un archivo XML en Java
Hoy en día los xml se han convertido en uno de los princiapales arvhivos que almecenan estructuras de datos sin importar cual sea ambiente, sistema operativo, o lenguaje de programación.
Este ejemplo va a ilustrar como obtener los datos desde un xml de una manera muy básica
Pimero, veamos la estructura del archivo xml llamado libro.xml que está guardado en algun lugar de nuestra pc:
<libro> <persona> <nombre>Kiran</nombret> <apellido>Pai</apellido> <edad>22</edad> </persona> <persona> <nombre>Juliet</nombret> <apellido>Mai</apellido> <edad>19</edad> </persona> <persona> <nombre>Gio</nombret> <apellido>Bill</apellido> <edad>23</edad> </persona> </libro>
Según la estructura del archivo anterior, el nodo mayor o raíz llamado libro contiene tres elementos que persona que a su vez son nodos que contienen otrso elementos, cada persona tiene como atributos el nombre, el apellido y la edad. Es una estructura bastante entendible.
Por lo general, para todos los ejemplo siempre acostumbro primero explicar el código, luego la salida que proyecta dicho código. En este caso vamos a ver la salida de la aplacación acontinuación, para luego pasar al código.
El elemento raíz es: libro
Número total de personas : 3
Nombre : Kiran
Apellido : Pai
Edad : 22
Nombre : Juliet
Apellido : Pai
Edad : 19
Nombre : Gio
Apellido : Bill
Edad : 23
Ahora, en java vamos a empezar a leer cada unos de los elementos que conforman cada parte del archivo. El primer paso es tomar el archivo físico y por medio de un InputStream convertilo en un objeto totalmente manipulable desde java.
DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
Document doc = docBuilder.parse (new File("libro.xml"));
Para asegurarnos de que la conversión haya sido la correcta, imprimimos el nombre de la raíz co el método getNodeName(). Hay que aclarar, que la lectura de un archivo xml siempre va de arriba hacia abajo, por lo tanto, el primer nodo que encontrará será <libro> (libro).
doc.getDocumentElement ().normalize ();
System.out.println ("El elemento raíz es " +
doc.getDocumentElement().getNodeName());
Ahora que nos encontramos dentro al nivel que el nodo libro vamos a iterar entre sus elementos personas, y en cada iteración vamos a imprimir los datos de cada persona.
Buscamos dentro del objeto doc (el xml como objeto) la etiqueta o elemento <persona> (persona) con el método getElementsByTagName(“nombre-etiqueta-a-buscar”) del objeto doc.
NodeList listaPersonas = doc.getElementsByTagName("persona");
int totalPersonas = listaPersonas.getLength();
System.out.println("Número total de personas : " + totalPersonas);
La variable listaPersonas es una pequeña estructura de datos que contiene la información de las personas. Asímismo, podemos recorrerlo como si fuera un ArrayList o una List de objetos que tienen perdonas. Lo indicado es recorrer dicho vector con un ciclo, de la siguiente manera:
for (int i = 0; i < totalPersonas.getLength() ; i ++) {
Node persona = listaPersonas.item(s);
}
Hasta acá hemos topado con la parte fácil, puer ahora lo que queda es tomar el objeto persona y extraer sus atributos. Aquí quiero hacer notar la diferencia que un Node (nodo) es un elemento que a su vez tiene elementos dentro de sus etiquetas, como lo que pasa con los nodos personas, y que, los elementos (Element) son todos aquellas atributos que unicamente tienen valores dentro de sus etiquetas, lo que pasa con nombre, apellido y edad, algo así como las hojas en un árbol binario.
Ahora, solo falta extraer los valores de cada persona, son embargo, a pesar de que visualmente sabemos de que cada persona tiene sus propios atrubutos con sus respectivos valores, debemos validar esa condición… asegurar que la persona tenga atributos. Y para que una persona realmente tenga atributos quiere decir que por definicón es un Node (nodo). Eso se resuelve con getNodeType():
if (persona.getNodeType() == Node.ELEMENT_NODE)
Y para finalizar se imprime cada uno de los elementos de la persona, con ayuda del método getTagValue(“nombre -de-la-etiqueta”) que funciona para identificar cada atributo de la persona:
Element elemento = (Element) persona;
System.out.println("Nombre : " + getTagValue("nombre",elemento ));
System.out.println("Apellido : " + getTagValue("apellido",elemento ));
System.out.println("Edad : " + getTagValue("edad",elemento ));
El método no es propiamente del API de java, le he programado para faciliar el trabajo a la hora de extraer los valores de cada etiqueta.
public String getTagValue(String tag, Element elemento) {
NodeList lista = elemento.getElementsByTagName(tag).item(0).getChildNodes();
Node valor = (Node) lista.item(0);
return valor.getNodeValue();
}
Acá dejo los archivos necesarios:
Read MoreLeer un fichero
Para leer un fichero de texto en java línea a línea, podemos hacerlo así
import java.io.*;
class LeeFichero {
public static void main(String [] arg) {
File archivo = null;
FileReader fr = null;
try {
archivo = new File ("archivo.txt");
String linea;
fr = new FileReader (archivo);
BufferedReader br = new BufferedReader(fr);
while((linea=br.readLine())!=null)
System.out.println(linea);
}
catch(IOException e){
System.out.println(e);
}finally{
try{
if( fr != null){
fr.close();
}
}catch (IOException e){
System.out.println(e);
}
}
}
}
Ha que considerar que el bloque finally se ejecuta siempre, por eso, si se cierra el fichero al final del primer try, y ha dado un error antes, pasaría
al primer catch y luego saldría, dejándolo abierto. Es conveniente cerrarlo aquí, comprobando que no sea por un error anterior, como no tener permisos de lectura o que no exista – de valor null.
Comentarios recientes