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();
}
}
}
