Acceso a datos. Ejercicios (IV). Ficheros XML

1. Realiza las siguientes tareas:

A partir de la clase persona:

import java.io.Serializable;

public class Persona  {

                private String nombre;

                private int edad;

                public Persona(String nombre, int edad) {

                               this.nombre=nombre;

                               this.edad=edad;

                              

                }

                public Persona(){

                               this.nombre=null;

                }

                public void setNombre (String nom) { nombre=nom;}

                public void setEdad (int ed) {edad=ed;}

               

                public String getNombre() {return nombre;}

                public int getEdad() {return edad;}

}

a) Crea un fichero “FichPersona.dat”,  que almacene varios objetos persona.

b) Tomando como base el fichero anterior, crea un documento XML usando DOM.

c) Implementa una clase que permita leer el documento XML del apartado anterior.

ARCHIVO PERSONA.JAVA

import java.io.*;

public class Persona implements Externalizable{

     // Propiedades

     private String nombre;

     private int edad;

    

     // Constructor

     public Persona(){}

    

     // Métodos

     public void setNombre(String nombre){

          this.nombre = nombre;

     }

    

     public void setEdad(int edad){

          this.edad = edad;

     }

    

     public String getNombre(){

          return nombre;

     }

    

     public int getEdad(){

          return edad;

     }

    

     public void writeExternal(ObjectOutput out) throws IOException{

          out.writeObject(nombre);

          out.writeObject(edad);

     }

    

     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException{

          nombre = (String)in.readObject();

          edad = (int)in.readObject();

     }

}

ARCHIVO ESCRIBIRSINCABECERA.JAVA

import java.io.*;

public class EscribirSinCabecera extends ObjectOutputStream{

     // Constructor

     public EscribirSinCabecera(OutputStream out) throws IOException{

          super(out);

     }

         

     public EscribirSinCabecera() throws IOException, SecurityException{

          super();

     }

         

     // Métodos

     /*

      * (non-Javadoc)

      * @see java.io.ObjectOutputStream#writeStreamHeader()

      *

      * Redefino el método de escribir la cabecera para que no haga nada

      */

     protected void writeStreamHeader() throws IOException{}

}

ARCHIVO CONFIGURARXML.JAVA

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import javax.xml.parsers.*;

import javax.xml.*;

import javax.xml.transform.*;

import javax.xml.transform.Source;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.*;

import org.w3c.dom.*;

import org.w3c.dom.DOMImplementation;

public class ConfigurarXML {

     // Propiedades

     Document doc = null;

    

     // Métodos

    

     // Genero un XML cargando la raíz en él

     public void crearXML(String raiz, String ruta){

          try{

                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

                DocumentBuilder builder = factory.newDocumentBuilder();

                DOMImplementation implementacion = builder.getDOMImplementation();

                doc = implementacion.createDocument(null, raiz, null);

                doc.setXmlVersion("1.0");

                Source source = new DOMSource(doc);

                Result result = new StreamResult(new java.io.File(ruta));

                guardarCambiosXML(source, result);

          }

          catch(Exception e){

                e.printStackTrace();

          }

     }

    

     public int anadirDOM(String nombre, String edad, String ruta){

          try{

                Node nNombre = doc.createElement("Nombre");

                Node nNombreTexto = doc.createTextNode(nombre);

                nNombre.appendChild(nNombreTexto);

                Node nEdad = doc.createElement("Edad");

                Node nEdadTexto = doc.createTextNode(edad);

                nEdad.appendChild(nEdadTexto);

               

                Node nPersona = doc.createElement("Persona");

                nPersona.appendChild(nNombre);

                nPersona.appendChild(nEdad);

               

                Node raiz = doc.getChildNodes().item(0);

                raiz.appendChild(nPersona);

               

                Source source = new DOMSource(doc);

                Result result = new StreamResult(new java.io.File(ruta));

                guardarCambiosXML(source, result);

                return 0;

          }

          catch(Exception e){

                e.printStackTrace();

                return -1;

          }

     }

    

     // Convierte el Document a fichero XML

     public void guardarCambiosXML(Source fuente, Result salida){

          try{

                Transformer t = TransformerFactory.newInstance().newTransformer();

                t.transform(fuente, salida);

          }

          catch(Exception e){

                e.printStackTrace();

          }   

     }

    

     public String leerXML(String ruta){

          File archivo = new File(ruta);

          abrirDoc(archivo);

          String datosNodo[] = null;

          String salida = "";

          Node n;

         

          // Obtengo el primer hijo del DOM

          Node raiz = doc.getFirstChild();

          // Listo todos los nodos hijos de raiz

          NodeList listado = raiz.getChildNodes();

         

          for(int i = 0; i < listado.getLength(); i++){

                n = listado.item(i);

                datosNodo = procesarPersona(n);

                salida = salida + "Nombre: " + datosNodo[0];

                salida = salida + "\n" + "Edad: " + datosNodo[1];

                salida = salida + "\n\n";

          }

         

          return salida;

     }

    

     protected String[] procesarPersona(Node n){

          String datos[] = new String[2];

          Node tmp = null;

          int contador = 0;

         

          // Hijos del libro

          NodeList nodos = n.getChildNodes();

          for(int i = 0; i < nodos.getLength(); i++){

               tmp = nodos.item(i);

               

                if (tmp.getNodeType() == Node.ELEMENT_NODE){

                     // Accedo al noto TEXT hijo de tmp para obtener nombre y edad

                     datos[contador] = tmp.getChildNodes().item(0).getNodeValue();

                     contador++;

                }

          }

         

          return datos;

     }

    

     protected void abrirDoc(File f){

          doc = null;

         

          try{

                DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

                factory.setIgnoringComments(true); // No contempla comentarios

                factory.setIgnoringElementContentWhitespace(true); // Ignoro los espacios en blanco

                DocumentBuilder b = factory.newDocumentBuilder();

                doc = b.parse(f);

          }

          catch(Exception e){

                e.printStackTrace();

          }

     }

}

ARCHIVO ACCIONES.JAVA

import java.io.*;

import java.util.Scanner;

public class Acciones {

     // Propiedades

     Persona p = new Persona();

     ConfigurarXML c = new ConfigurarXML();

    

     // Constructor

     public Acciones(){}

    

     // Métodos

    

     private void generarPersona(){

          Scanner sc = new Scanner(System.in);

         

          System.out.println("Generador de personas");

          System.out.println("Escribe nombre");

          p.setNombre(sc.nextLine());

          System.out.println("Escribe edad");

          p.setEdad(Integer.parseInt(sc.nextLine()));

          sc.close(); // Cierro el scanner

     }

    

     public void escribirDat() throws IOException, ClassNotFoundException{

          File people = new File("personas.dat");

         

          generarPersona();

          // Escribir en fichero

          if(people.exists()){

                EscribirSinCabecera salida = new EscribirSinCabecera(new FileOutputStream("personas.dat", true));

                p.writeExternal(salida);

               salida.close();

          }

          else{

                ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream("personas.dat", true));

                p.writeExternal(salida);

                salida.close();

          }

     }

    

     // Agrego datos al xml conforme voy leyendo

     public void cargarDatEnXML(String ruta) throws IOException, ClassNotFoundException{

          boolean finFichero = false;

          File f = new File(ruta);

          ObjectInputStream entrada = new ObjectInputStream(new FileInputStream("personas.dat"));

         

          // Machaco el anterior (en caso de que exista) para no duplicar datos

          c.crearXML("Gente", ruta);

         

          do{

                try{

                     p.readExternal(entrada);

                     c.anadirDOM(p.getNombre(), String.valueOf(p.getEdad()), ruta);

                }

                catch(EOFException e){

                     finFichero = true;

                }

          }while(!finFichero);

     }

}

ARCHIVO MAIN.JAVA

import java.io.*;

public class Main {

     public static void main(String[] args) throws IOException, ClassNotFoundException{

          // Propiedades

          Acciones a = new Acciones();

          ConfigurarXML x = new ConfigurarXML();

         

          // Código para probar

          //a.escribirDat();

          a.cargarDatEnXML("personas.xml");

          System.out.println(x.leerXML("personas.xml"));

     }

}

2. Utiliza SAX para visualizar el contenido del fichero del apartado b) del ejercicio anterior.

ARCHIVO SAXREADER.JAVA

import javax.xml.parsers.SAXParser;

import javax.xml.parsers.SAXParserFactory;

import org.omg.Messaging.SyncScopeHelper;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.helpers.DefaultHandler;

public class SAXReader extends DefaultHandler{

     public void leerXML(String ruta){

          try{

                // Obtengo y configuro el parseador SAX

                SAXParserFactory factory = SAXParserFactory.newInstance();

               

                // Obtengo el objeto del SAX parser

                SAXParser sParser = factory.newSAXParser();

               

                // Manejador por defecto. Los tres métodos se escriben dentro de él

                DefaultHandler manejador = new DefaultHandler(){

                     String nombreTag = "close";

                     String edadTag = "close";

                    

                     // Abro los elementos para capturar los datos contenidos

                     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException{

                          System.out.println("<"+qName+">");

                         

                     } // fin función startElement

                    

                     // Imprime los datos contenidos entre < y >

                     public void characters(char ch[], int start, int length) throws SAXException{

                          String contenido = new String(ch, start, length).trim();

                          if (contenido.length() > 0)

                               System.out.println(contenido);

                     } // Fin función caracteres

                    

                     // Cierro los elementos para dejar de capturar datos

                     public void endElement(String uri, String localName, String qName) throws SAXException{

                          System.out.println("</"+qName+">");

                     } // Fin función endElement

                    

                }; // Fin DefaultHandler

               

                sParser.parse(ruta, manejador);

          }

          catch(Exception e){

                e.printStackTrace();

          }

     }

    

}

ARCHIVO MAIN.JAVA

import java.io.IOException;

import javax.xml.parsers.ParserConfigurationException;

import org.xml.sax.*;

import org.xml.sax.helpers.XMLReaderFactory;

public class Main {

     public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {

          SAXReader gestor = new SAXReader();

          gestor.leerXML("personas.xml");

     }

}

3.

a) Realiza un programa Java que cree un fichero binario para guardar datos (objetos) de departamentos (departamentos.dat). Los datos para cada departamento son:

- Numdepartamento: entero

- Nombre: String

- Localidad: String

Introduce varios departamentos

b) A partir del fichero departamentos.dat anterior, crea un fichero XML usando la librería XStream.

c) Crea una plantilla XSL para dar una presentación al fichero XML generado en el apartado b) y realiza un programa Java para transformarlo en HTML.

4. Realiza los dos últimos apartados del primer ejercicio pero utilizando Xstream.

ARCHIVO PERSONA.JAVA

import java.io.*;

public class Persona implements Serializable{

     // Propiedades

     private String nombre;

     private int edad;

    

     // Constructor

     public Persona(){}

     public Persona(String nombre, int edad){

          this.nombre = nombre;

          this.edad = edad;

     }

    

     // Métodos

     public void setNombre(String nombre){

          this.nombre = nombre;

     }

    

     public void setEdad(int edad){

          this.edad = edad;

     }

    

     public String getNombre(){

          return nombre;

     }

    

     public int getEdad(){

          return edad;

     }

    

     public String toString(){

          String resultado = "\t<PERSONA>\n" + "\t\t<NOMBRE>" + nombre + "</NOMBRE>\n" + "\t\t<EDAD>" + edad + "</EDAD>\n" + "\t</PERSONA>";

          return resultado;

     }

}

ARCHIVO ACCIONES.JAVA

import java.io.*;

import java.util.*;

import com.thoughtworks.xstream.XStream;

public class Acciones {

     // Propiedades

     private Persona p = new Persona();

    

     // Métodos

     /* Generar archivo para prueba

     public void escribirDat(String ruta) throws IOException, ClassNotFoundException{

          File depto = new File(ruta);

          ObjectOutputStream salida = new ObjectOutputStream(new FileOutputStream(ruta, true));

          Persona p1 = new Persona("Inazio", 23);

          salida.writeObject(p1);

          Persona p2 = new Persona("Claver", 24);

          salida.writeObject(p2);

          Persona p3 = new Persona("Paules", 25);

          salida.writeObject(p3);

          salida.close();

         

          System.out.println("Fichero guardado correctamente");

     }*/

    

     public void datToXML(String rutaDAT, String rutaXML){

          try{

                boolean finFichero = false;

                ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(rutaDAT));

                Vector<Persona> listado = new Vector<Persona>();

               

                do{

                     try{

                          p = (Persona)entrada.readObject();

                          listado.add(p);

                     }

                     catch(EOFException e){

                          finFichero = true;

                     }

                }while(!finFichero);

               

                entrada.close();

               

                XStream xs = new XStream();

                xs.alias("GENTE", Vector.class);

                xs.alias("PERSONA", Persona.class);

                xs.toXML(listado, new FileOutputStream(new File(rutaXML)));

          }

          catch(ClassNotFoundException e){

                e.printStackTrace();

          }

          catch(FileNotFoundException e){

                e.printStackTrace();

          }

          catch(Exception e){

                e.printStackTrace();

          }

     }

    

     public void verXML(String ruta){

          XStream xs = new XStream();

          xs.alias("GENTE", Vector.class);

          xs.alias("PERSONA", Persona.class);

         

          Vector<Persona> listado = (Vector<Persona>)xs.fromXML(new File(ruta));

          Iterator<Persona> iterator = listado.listIterator();

         

          System.out.println("<GENTE>");

          while(iterator.hasNext()){

                System.out.println(((Persona)iterator.next()).toString());

          }

          System.out.println("</GENTE>");

     }

}

ARCHIVO MAIN.JAVA

import java.io.IOException;

public class Main {

     public static void main(String[] args) {

         

          Acciones a = new Acciones();

         

          /*Generar .dat para prueba

           * try{

                a.escribirDat("personas.dat");

          }

          catch(ClassNotFoundException e){

                e.printStackTrace();

          }

          catch(IOException e){

                e.printStackTrace();

          }*/

         

          a.datToXML("personas.dat", "personas.xml");

          a.verXML("personas.xml");

     }

}

5. Realiza los dos últimos apartados del primer ejercicio pero utilizando JDOM.

ARCHIVO PERSONA.JAVA

import java.io.*;

public class Persona implements Externalizable{

     // Propiedades

     private String nombre;

     private int edad;

    

     // Constructor

     public Persona(){}

    

     // Métodos

     public void setNombre(String nombre){

          this.nombre = nombre;

     }

    

     public void setEdad(int edad){

          this.edad = edad;

     }

    

     public String getNombre(){

          return nombre;

     }

    

     public int getEdad(){

          return edad;

     }

    

     public void writeExternal(ObjectOutput out) throws IOException{

          out.writeObject(nombre);

          out.writeObject(edad);

     }

    

     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException{

          nombre = (String)in.readObject();

          edad = (int)in.readObject();

     }

}

ARCHIVO JDOMTOXML.JAVA

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileWriter;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.util.List;

import org.jdom2.*;

import org.jdom2.input.SAXBuilder;

import org.jdom2.output.Format;

import org.jdom2.output.XMLOutputter;

public class JDOMtoXML {

     public void generarXML(String nombreDAT, String nombreXML) throws IOException, ClassNotFoundException{

          boolean finFichero = false;

          Persona p = new Persona();

          ObjectInputStream entrada = new ObjectInputStream(new FileInputStream(nombreDAT));

          Element raiz = new Element("GENTE");

          Document doc = new Document();

         

          doc.setRootElement(raiz);

          do{

                try{

                     p.readExternal(entrada);

                     Element gente = new Element("PERSONA");

                     gente.addContent(new Element("NOMBRE").setText(p.getNombre()));

                     gente.addContent(new Element("EDAD").setText(String.valueOf(p.getEdad())));

                     doc.getRootElement().addContent(gente);

                }

                catch(EOFException e){

                     finFichero = true;

                }

          }while(!finFichero); // Dejo de recorrer el fichero .dat

         

          XMLOutputter x = new XMLOutputter();

          x.setFormat(Format.getPrettyFormat());

          x.output(doc, new FileWriter(nombreXML));

          System.out.println("Fichero generado correctamente");

     }

    

     public void leerXML(String ruta){

          SAXBuilder b = new SAXBuilder();

          File x = new File(ruta);

         

          try{

                // Creo el document

                Document d = (Document)b.build(x);

               

                // Leo la raíz

                Element raiz = d.getRootElement();

               

                // Obtengo listado de los hijos

                List listaHijos = raiz.getChildren("PERSONA");

               

                System.out.println("NOMBRE\t\tEDAD" );

                System.out.println("---------------------");

                for(int i = 0; i < listaHijos.size(); i++){

                     // Obtengo el elemento persona

                     Element persona = (Element)listaHijos.get(i);

                     String nombre = persona.getChildTextTrim("NOMBRE");

                     String edad = persona.getChildTextTrim("EDAD");

                    

                     System.out.println(nombre + "\t\t" + edad);                  

                }

          }

          catch(IOException e){

                e.printStackTrace();

          }

          catch(JDOMException e){

                e.printStackTrace();

          }

     }

}

ARCHIVO MAIN.JAVA

import java.io.IOException;

    

public class main {

     public static void main(String[] args) {

          JDOMtoXML j = new JDOMtoXML();

               

          try{

                j.generarXML("personas.dat", "personas.xml");

               j.leerXML("personas.xml");

          }

          catch(IOException e){

                e.printStackTrace();

          }

          catch(ClassNotFoundException e){

               e.printStackTrace();

          }

     }

}