• Parseador: Es la clase que se encarga de leer el documento XML. Esta clase contiene varios métodos por defecto: inicioElemento(Avisa que se ha encontrado una etiqueta registro, y de paso almacenamos el atributo definido en ella), finElemento (Tratamos los datos, en nuestro caso almacenamos en el objeto Vector) y characters (recibe la ubicación de los caracteres del elemento y los extraemos almacenándolos en una cadena). En realidad inicioElemento y finalElemento son una versión simplificada de los métodos startElement y endElement. De aquí sacaremos una colección con los datos que hayamos leído durante el proceso de lectura. En la variable valor se irá guardando una cadena que contiene los datos extraídos, es decir, los datos que tendremos que almacenar en la colección. El código es el siguiente:

  import org.xml.sax.helpers.DefaultHandler;
  import org.xml.sax.Attributes;
  import java.util.Vector;
  import org.xml.sax.*;
  import org.xml.sax.helpers.*;
  
  
  	
  public class Parseador extends DefaultHandler  {
    private Vector coleccion; 
    private Acciones actual; 
    private String valor; 
  
    public Parseador (Vector coleccion) {
       this.coleccion = coleccion; 
    }
  
    /*
    localName: contiene el nombre de la etiqueta.
    att: de la clase "org.xml.sax.Attributes",
    es una tabla que contiene los atributos
    contenidos en la etiqueta.
    */
    public void startElement( String namespaceURI,
             String localName, String qName,
             Attributes attr ) throws SAXException {
  
       inicioElemento(localName, attr);
    }
  
    public void endElement (String namespaceURI,
             String localName, String rawName)
             throws SAXException {
        finElemento(localName);
    }
  
     public void inicioElemento(String nombreElemento,
              Attributes atributo) throws SAXException {
  
        if (nombreElemento.equals("entrada")) {
          actual = new Acciones (); 
          coleccion.addElement(actual); 
          actual.setID(
               Integer.parseInt(atributo.getValue("id"))); 
        }
      }
  
      public void finElemento(String nombreElemento)
               throws SAXException {
  
          if (nombreElemento.equals("nombre")){ 
            actual.setNombre (valor);
          } else if (nombreElemento.equals("telefono")) {
            actual.setTelefono (Integer.parseInt(valor)); 
          }
      }
  
      public void characters (char[] ch, int start, int end)
      {
  
         valor = new String (ch, start, end);
         valor = valor.trim();
      }
  }
  

• Acciones: La clase Acciones contiene sencillos métodos get y set utilizando en la aplicación. Viene dada por el siguiente código:

  public class Acciones {
  
     private String documento;
     private String nombre;
     private int telefono;
     private int id;
  
     public void setNombre (String nombre) {
        this.nombre = nombre;
     }
  
     public void setTelefono (int telefono) {
        this.telefono = telefono;
     }
  
     public void setID (int id) {
        this.id = id;
     }
  
     public void setDocumento(String documento) {
        this.documento = documento;
     }
  
      public String getNombre() {
         return nombre;
      }
  
      public int getTelefono()  {
         return telefono;
      }
  
       public int getID() {
         return id;
       }
  
       public String getDocumento() {
         return documento;
       }
  }
  

• Index: Es la clase que contiene el main e invoca a las demás clases. Su código es el que se muestra a continuación:

  import java.util.Vector;
  import org.xml.sax.XMLReader;
  import org.xml.sax.SAXException;
  import org.apache.xerces.parsers.SAXParser;
  import org.xml.sax.*;
  
  	
  public class Index {
  
    Vector coleccion = new Vector ();
    Acciones acciones = new Acciones ();
    XMLReader parser = new SAXParser();
  
   public void ParsearDocumento () throws Exception {
  
        String nombre_de_archivo;
        acciones.setDocumento("index.xml"); 
        nombre_de_archivo=acciones.getDocumento(); 
        parser.setContentHandler(new Parseador(coleccion));
        parser.parse(nombre_de_archivo); 
        Interfaz contenedor = new Interfaz(coleccion);
   }
  
   public static void main(String[] args) throws Exception {
  
        Index ejecutar = new Index();
        ejecutar.ParsearDocumento();
   }
  
  	
  }
  

• Interfaz y Conclusión: La clase Interfaz es la que se encarga de crear la interfaz gráfica dónde se mostrarán los datos en pantalla. La clase Conclusión es una clase auxiliar de Interfaz.

  import java.util.Vector;
  import java.awt.FlowLayout;
  import java.awt.Frame;
  import java.awt.List;
  import java.awt.MenuBar;
  import java.awt.Menu;
  import java.awt.MenuItem;
  import java.awt.Event;
  import java.awt.*;
  import java.awt.image.ImageObserver;
  
  
  	
  public class Interfaz {
  
     public Interfaz(Vector datos) {
  
        int i;
        Acciones[] inserta=new Acciones[datos.size()]; 
        List miLista = new List(15,false);
  
        for(i=0;i<datos .size();i++) {
           inserta[i]=(Acciones)datos.elementAt(i);
           miLista.add(inserta[i].getID()+"."
              <ins>inserta[i].getNombre()</ins>
              " - "+inserta[i].getTelefono());
        }
  
        Frame miFrame = new Frame("Agenda Electrónica XML");
        miFrame.setLayout(new FlowLayout());
        miFrame.add(miLista);
        miFrame.setSize(200,275);
        miFrame.setVisible(true); 
        miFrame.addWindowListener(new Conclusion());
  
     }
  }
  

  import java.awt.*;
  import java.awt.event.*;
  
  	
  public class Conclusion extends WindowAdapter {
      public void windowClosing( WindowEvent evt ) {
           System.exit(0);
      }
  
  }
  
  

  
  

Podemos parsear un documento XML de dos modos: usando SAX o DOM. Podemos distinguir a grandes rasgos el funcionamiento de cada modo de parseo de la siguiente forma:

• DOM: DOM crea un árbol jerárquico en memoria que contiene el todo documento XML, y con él en memoria podemos hacer realizar cualquier tipo de recorrido, movimiento o acción con los elementos que deseemos.


• SAX: SAX significa Simple API for XML. Se usa para realizar un recorrido secuencial de los elementos del documento XML, es decir, vamos tratando la información a la vez que la vamos leyendo.

SAX es menos potente que DOM, pero aún así es más rápido y útil para los casos donde por ejemplo interesa hacer una lectura secuencial o buscar algún fragmento en un documento.

Para mostrar el funcionamiento de un parser de XML, crearemos una pequeña aplicación donde leeremos el contenido de un documento XML usando SAX y lo mostraremos en pantalla. Para escribir el programa usaremos Java, aún así lo podriamos hacer en cualquier otro C++, PHP, Python, ...

Nuestra aplicación parseará el siguiente documento XML de ejemplo, que se trata de una agenda que almacena el nombre y el número de teléfono de cada registro insertado.

< ?xml version="1.0"?>
<agenda>
   <entrada id="1">
      <nombre> Javier </nombre>
      <telefono> 956425981 </telefono>
   </entrada>
   <entrada id="2">
      <nombre> Fran </nombre>
      <telefono> 645675431 </telefono>
   </entrada>
   <entrada id="3">
      <nombre> Alfonso </nombre>
      <telefono> 660137258 </telefono>
   </entrada>
   <entrada id="4">
      <nombre> Manuel </nombre>
      <telefono> 625435431 </telefono>
   </entrada>
   <entrada id="5">
      <nombre> Paco </nombre>
      <telefono> 630603804 </telefono>
   </entrada>
</agenda>

Para parsear el documento usaremos JAXP y Xerces. JAXP (Java API for XML Processing) es un conjunto de clases que permite a las aplicaciones en Java parsear y transformar documento XML independientemente del modo de procesamiento utilizado. La razón de la existencia de JAXP es facilitar el uso de XML en la plataforma Java, garantizando que una aplicación escrita en Java orientanda hacia un parser con soporte JAXP puede ser migrado a otro sin ningún problema. Xerces es un parseador desarrollado por la fundacion Aparche.org disponible para Java y C++. Para escribir nuestro programa usaremos Xerces.

Mañana continuaremos con la segunda parte Parseando XML con Java (II) donde mostraré la implementación de las clases necesarias y subiré el código de fuente.