XML y Java (I)

XML

XML cuya siglas en ingles Extensible Markup Language  (Lenguaje de marcas extensible),  y se utiliza para el almacenamiento de datos de forma legible.

Un documento Xml consiste un conjunto de elementos en el cual cada elemento tiene un tag inicial, un contenido y un tag final.    Cada Xml tiene un elemento raíz obligatoriamente, ademas, en se diferencia caracteres en mayúscula y minúscula.

Un documento valido de XML consta de los siguiente:

• Cada XML tiene empieza con un prolog y su función es describir las propiedades del documento. 
• Cada Tag  o etiqueta tiene un comienzo y un fin.
• Todas las etiquetas están completamente anidadas.

Las ventajas de usar un XML son:

• XML es texto plano.
• XML puede almacenar datos sin definir como deben ser mostrado.
• XML puede ser transformado a otros formato con XSL.
• XML puede ser procesado de forma sencilla
• Los archivos XML son de carácter jerárquico. 

Ejemplo de XML:

<?xml version="1.0"?>
<!-- comentario -->
<direccion>
  <nombre>Lars </nombre>
  <calle> Test </calle>
  <telefono numero= "55555"/>
</direccion>

Java y XML

Java ofrece varios API para manejar los XML,  Los siguientes son un resumen de los mas importantes.

EL API DOM (Document Object Model) permite acceder a un XML usando objeto de tipo de árbol ademas que se puede escribir o leer.

SAX es un API de java que permite la lectura secuencial de archivos XML y solo permite leer archivo.

DOM y SAX son APIs viejas  que actualmente ya no se usan mucho por eso no es recomendable no usarlas.

STAX es otro API en el cual se puede leer y escribir archivos XML, salio a partir de la versión Java 6.0.

JAXB es un estándar que permite definir como se mapea un XML  a objetos y viceversa.

Para este post usare STAX para crear los ejemplos.

EJEMPLO:  Leyendo un archivo XML

Usaremos este archivo XML para el ejemplo donde se creara objetos a partir de el.

<?xml version="1.0" encoding="UTF-8"?>
<config>
  <item fecha="enero 2014">
    <modo>1</modo>
    <Unidad>600</Unidad>
    <actual>1</actual>
    <interaccion>1</interaccion>
  </item>
  <item fecha="Febrero 2014">
    <modo>2</modo>
    <Unidad>200</Unidad>
    <actual>2</actual>
    <interaccion>5</interaccion>
  </item>
  <item fecha="Marzo 2013">
    <modo>9</modo>
    <Unidad>50</Unidad>
    <actual>100</actual>
    <interaccion>3</interaccion>
  </item>
</config>

Primero definiremos la clase que van a contener la estructura de los archivos XML

package lecturadexml;

public class item {

    private String fecha;
    private String modo;
    private String Unidad;
    private String actual;
    private String interaccion;

    public String getfecha() {
        return fecha;
    }

    public void setfecha(String fecha) {
        this.fecha = fecha;
    }

    public String getmodo() {
        return modo;
    }

    public void setmodo(String modo) {
        this.modo = modo;
    }

    public String getUnidad() {
        return Unidad;
    }

    public void setUnidad(String Unidad) {
        this.Unidad = Unidad;
    }

    public String getactual() {
        return actual;
    }

    public void setactual(String actual) {
        this.actual = actual;
    }

    public String getinteraccion() {
        return interaccion;
    }

    public void setinteraccion(String interaccion) {
        this.interaccion = interaccion;
    }

    @Override
    public String toString() {
        return "Item [actual=" + actual + ", fecha=" + fecha + ", interaccion="
                + interaccion + ", modo=" + modo + ", Unidad=" + Unidad + "]";
    }

}

El siguiente código crea una lista de objetos pertenecientes a la clase item,   se creara un objeto por cada entrada del archivo XML.

package lecturadexml;
import java.io.*;
import java.util.*;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;


public class StaxLector {
  static final String fecha = "fecha";
  static final String ITEM = "item";
  static final String modo = "modo";
  static final String Unidad = "Unidad";
  static final String actual = "actual";
  static final String interaccion = "interaccion";

  @SuppressWarnings({ "unchecked", "null" })
  public List<Item> readConfig(String configFile) {
    List<Item> items = new ArrayList<Item>();
    try {
      // Empezamos con la creación de  XMLInputFactory
      XMLInputFactory inputFactory = XMLInputFactory.newInstance();
      // instanciamos el eventReader
      InputStream in = new FileInputStream(configFile);
      XMLEventReader eventReader = inputFactory.createXMLEventReader(in);
      // leemos el documento de XML 
      Item item = null;

      while (eventReader.hasNext()) {
        XMLEvent event = eventReader.nextEvent();

        if (event.isStartElement()) {
          StartElement startElement = event.asStartElement();
          // Si existe un elemento en el XML, creamos un nuevo objeto de tipo item
          if (startElement.getName().getLocalPart() == (ITEM)) {
            item = new Item();
            // leemos los atributos de la etiqueta Item y agregamos la etiqueta fecha
        
            Iterator<Attribute> attributes = startElement
                .getAttributes();
            while (attributes.hasNext()) {
              Attribute attribute = attributes.next();
              if (attribute.getName().toString().equals(fecha)) {
                item.setfecha(attribute.getValue());
              }

            }
          }

          if (event.isStartElement()) {
            if (event.asStartElement().getName().getLocalPart()
                .equals(modo)) {
              event = eventReader.nextEvent();
              item.setmodo(event.asCharacters().getData());
              continue;
            }
          }
          if (event.asStartElement().getName().getLocalPart()
              .equals(Unidad)) {
            event = eventReader.nextEvent();
            item.setUnidad(event.asCharacters().getData());
            continue;
          }

          if (event.asStartElement().getName().getLocalPart()
              .equals(actual)) {
            event = eventReader.nextEvent();
            item.setactual(event.asCharacters().getData());
            continue;
          }

          if (event.asStartElement().getName().getLocalPart()
              .equals(interaccion)) {
            event = eventReader.nextEvent();
            item.setinteraccion(event.asCharacters().getData());
            continue;
          }
        }
        // Si llegamos al final del elemento item, lo agregamos a la lista 
        if (event.isEndElement()) {
          EndElement endElement = event.asEndElement();
          if (endElement.getName().getLocalPart() == (ITEM)) {
            items.add(item);
          }
        }

      }
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (XMLStreamException e) {
      e.printStackTrace();
    }
    return items;
  }  
}

Ahora para probar la clases usaremos el siguiente programa,   Ojo el archivo Config.xml debe estar en la misma carpeta de proyecto donde están guardados los archivos del proyectos

package lecturadexml;

import java.util.List;

public class Lecturadexml {

    public static void main(String[] args) {
        StaxLector read = new StaxLector();
        List<Item> readConfig = read.readConfig("config.xml");
        for (Item item : readConfig) {
            System.out.println(item);
        }
    }

}

EJEMPLO:  Escribiendo en un archivo XML

Ahora pasemos a escribir en un archivo XML como el que mostrare a continuacion:

<?xml version="1.0" encoding="UTF-8"?>
<config>
<modo>1</modo>
    <Unidad>600</Unidad>
    <actual>1</actual>
    <interaccion>1</interaccion>
</config>

Con StaX no ninguna funcionalidad para crear automáticamente la estructura del XML entonces le toca al programador definir el inicio y el fin de cada etiqueta e igual manera el inicio y el fin del documento.

package lecturadexml;

import java.io.FileOutputStream;

import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class StaxEscritor {

    private String configFile;

    public void setFile(String configFile) {
        this.configFile = configFile;
    }

    public void salvarConfig() throws Exception {
        // Se crea un objeto de XMLOutputFactory
        XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
        // Se crea un objeto de XMLEventWriter
        XMLEventWriter eventWriter = outputFactory
                .createXMLEventWriter(new FileOutputStream(configFile));
        // Se crea un objeto EventFactory
        XMLEventFactory eventFactory = XMLEventFactory.newInstance();
        XMLEvent end = eventFactory.createDTD("\n");
        // Se crea y escribe el inicio de una etiqueta
        StartDocument startDocument = eventFactory.createStartDocument();
        eventWriter.add(startDocument);

        // Se crea la etiqueta de apertura de Config
        StartElement configStartElement = eventFactory.createStartElement("",
                "", "config");
        eventWriter.add(configStartElement);
        eventWriter.add(end);
        // Se escriben los diferents nodos
        crearNodo(eventWriter, "nodo", "1");
        crearNodo(eventWriter, "Unidad", "901");
        crearNodo(eventWriter, "actual", "0");
        crearNodo(eventWriter, "interaccion", "0");

        eventWriter.add(eventFactory.createEndElement("", "", "config"));
        eventWriter.add(end);
        eventWriter.add(eventFactory.createEndDocument());
        eventWriter.close();
    }

    private void crearNodo(XMLEventWriter eventWriter, String name,
            String value) throws XMLStreamException {

        XMLEventFactory eventFactory = XMLEventFactory.newInstance();
        XMLEvent end = eventFactory.createDTD("\n");
        XMLEvent tab = eventFactory.createDTD("\t");
        //Secrea el nodo inicial
        StartElement sElement = eventFactory.createStartElement("", "", name);
        eventWriter.add(tab);
        eventWriter.add(sElement);
        // Se crea el contenido
        Characters characters = eventFactory.createCharacters(value);
        eventWriter.add(characters);
        //Secrea el final del nodo
        EndElement eElement = eventFactory.createEndElement("", "", name);
        eventWriter.add(eElement);
        eventWriter.add(end);

    }
}

Para probar el código solo basta.

public class escrituradexml {

    public static void main(String[] args) {
        StaxEscritor configFile = new StaxEscritor();
        configFile.setFile("config2.xml");
        try {
            configFile.salvarConfig();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}

Bueno esto fue tan solo una introducción de XML, mas adelante seguiré dando mas ejemplos y enseñare como usar mas APIs.

Saludos y que  le sea de utilidad.

Aquí puede descargar todo los ejemplos y código:  Codigo Fuente.