Serialización de objetos a XML

Para serializar de forma sencilla objetos Java a XML y viceversa se usa la librería XStream
para lo cual hay que descargarla de la página http://x-stream.github.io/download.html.
Los pasos a seguir para configurar el entorno de trabajo son:
. Descargar la distribución binaria (xstream-distribution-1.4.11.1-bin.zip
. Se descomprime y se coge el fichero xstream-1.4.11.1.jar que se encuentra en la carpeta
xstream-1.4.11.1\lib y se guarda en C:\Program Files\Java\jdk1.8.0_144\jre\lib\ext
Una vez se tiene el entorno configurado, ya se puede empezar a trabajar para lo cual se hará:
 Crear un objeto de la clase XStream. Se tienen 3 opciones:

 A través de un constructor vacío: XStream xs = new Xstream();

 Enviando en el constructor un objeto StaxDriver:
XStream xs = new Xstream(new StaxDriver());
 Enviando en el constructor un objeto DomDriver:
XStream xs = new Xstream(new DomDriver());
Las dos operaciones a realizar son:
 Serializar a XML: Se realiza llamando al método toXML() y enviándole como parámetro el
objeto y devuelve un String con los datos del objeto en formato XML.
1xstream. String xml= xs.toXML(objeto);
 Deserializar: El objeto xstream llamará al método fromXML(), pasandóle el xml como un
String y devuelve el objeto correspondiente a ese XML.
1xstream. objeto=(Clase) xs.fromXML(stringXml);

Al convertir el objeto Java en XML, XStream convierte de forma predeterminada el nombre

de clase en nombre de etiqueta XML. Existen una serie de métodos para personalizar el XML
creado. Se deben tener en cuenta las siguientes especificaciones:
 La conversión entre etiqueta y clases/atributos es directa si coincide exactamente
con el nombre, incluyendo mayúsculas.
 Si no coinciden se usa alias para indicar la relación
 A las listas hay que darle una etiqueta e indicar con alias la clase de las etiquetas
que contiene.
Existen 5 tipos de alias:
1. Alias de clase
2. Alias de campo
3. Alias de colecciones
4. Alias de atributo
5. Alias de paquete
 1º. Alias de clase
Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
am XStream xs= new XStream(new DomDriver());
String xml=xstream.toXML(al);
2º. Alias de campo
Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
XStream xs = new XStream(new DomDriver());
xs.alias("Alumno",Alumno.class);
String xml=xs.toXML(al);
Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
XStream xs = new XStream(new DomDriver());
String xml=xs.toXML(al);
Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
XStream xs = new XStream(new DomDriver());
xs.alias("Alumno",Alumno.class);
xs.aliasField("Matricula", Alumno.class,"Mat");
xs.aliasField("Ciclo", Alumno.class,"Curso");
String xml=xs.toXML(al);
 3º. Alias de colecciones
Generalmente, una colección (Array / Collection) en Java cuando se convierte a XML está
encerrada en una etiqueta. Puede usar el alias implícito para la colección para eliminar esta
etiqueta.

4º. Alias de atributo

Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
XStream xs = new XStream(new DomDriver());
xs.alias("Alumno",Alumno.class);
xs.aliasField("Matricula", Alumno.class,"Mat");
xs.aliasField("Ciclo", Alumno.class,"Curso");
String xml=xs.toXML(al);
Alumno al=null;
al=new Alumno("123","Lorena","DAM",8.5);
XStream xs = new XStream(new DomDriver());
xs.alias("Alumno",Alumno.class);
xs.aliasField("Matricula", Alumno.class, "Mat");
xs.aliasField("Ciclo", Alumno.class, "Curso");
String xml=xs.toXML(al);
5º. Alias de paquete

Creación del fichero XML.

Una vez creados o leídos los objetos, se pueden guardar en un ArrayList para guardarlos en
el fichero XML. Para ello se usa una variación del método toXML.
xs.toXML(nombre_del_arraylist,new FileOutputStream(nombre_del_fichero_XML));

Ej: Alumno al=null;

ArrayList<Alumno> lista=new ArrayList<Alumno>();
XStream xs = new XStream(new DomDriver());
for(int i=1;i<=5;i++){
al=new Alumno(""+i,"Lorena","DAM",8.5);
lista.add(al);
}
xs.alias("Alumno",Alumno.class);
xs.aliasField("Matricula", Alumno.class, "Mat");
xs.aliasField("Ciclo", Alumno.class, "Curso");
xs.useAttributeFor(Alumno.class, "Mat");
xs.toXML(lista,new FileOutputStream("alumnos.xml"));

Existe otra forma de guardar elementos XML en un fichero serializable y como objetos los
elementos del ficheroXML. Para ello se van a utilizar los métodos createObjectOutputStream()
y createObjectInputStream().
Ej: …………………………………………………..
ObjectOutputStream oos=xs.createObjectOutputStream(new FileOutputStream("alumnos.xml"));
for(int i=1;i<=5;i++){
al=new Alumno("Lorena","DAM",8.5);
oos.writeObject(al);
}
oos.close();

ObjectInputStream ois=xs.createObjectInputStream(new FileInputStream("alumnos.xml"));

try{
while(true){
al=(Alumno)ois.readObject();
System.out.println(al.toString());
}
}catch(EOFException e){}
ois.close();

Crear objetos persistentes

Cuando se quieren guardar objetos en el fichero lo que se quiere es que sean objetos
persistentes para lo cual se utilizan las clases PersistenceStrategy, FilePersistenceStrategy y
XmlArrayList para crear dicho objetos.

Ej: PersistenceStrategy ps=new FilePersistenceStrategy(new File("."));

XmlArrayList lista=new XmlArrayList(ps);

XStream xs = new XStream(new DomDriver());

ObjectOutputStream oos=xs.createObjectOutputStream(new FileOutputStream("alumnos.xml"));
for(int i=0;i<lista.size();i++){
oos.writeObject(lista.get(i));
}
oos.close();