No es un bug, es una característica no documentada

jueves, 22 de octubre de 2015

Acceso a datos. Ejercicios (IV). Ficheros XML

18:34 Posted by Inazio , , No comments
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();
          }
     }

}

0 comentarios:

Publicar un comentario