XStream - Guía rápida

XStream es una biblioteca simple basada en Java para serializar objetos Java a XML y viceversa.

Caracteristicas

  • Easy to use - La API XStream proporciona una fachada de alto nivel para simplificar los casos de uso comunes.

  • No need to create mapping - La API XStream proporciona un mapeo predeterminado para la mayoría de los objetos que se serializarán.

  • Performance - XStream es rápido y ocupa poco espacio en la memoria, lo que es adecuado para sistemas o gráficos de objetos grandes.

  • Clean XML - XStream produce una salida XML limpia y compacta que es fácil de leer.

  • Object modification not required- XStream serializa campos internos como campos privados y finales, y admite clases internas y no públicas. El constructor predeterminado no es un requisito obligatorio.

  • Full object graph support - XStream permite mantener referencias duplicadas encontradas en el modelo de objeto y también admite referencias circulares.

  • Customizable conversion strategies - Se pueden registrar estrategias personalizadas para permitir la personalización de un tipo particular para representarlo como XML.

  • Security framework - XStream proporciona un control justo sobre tipos no agrupados para evitar problemas de seguridad con entradas manipuladas.

  • Error messages - Cuando ocurre una excepción debido a un XML con formato incorrecto, proporciona diagnósticos detallados para solucionar el problema.

  • Alternative output format - XStream admite otros formatos de salida como JSON y morphing.

Usos comunes

  • Transport - XML ​​es una representación de texto de un objeto y se puede utilizar para transportar objetos por el cable independientemente de las técnicas de serialización / deserialización utilizadas.

  • Persistence - Los objetos se pueden conservar como XML en las bases de datos y se pueden ordenar / deshacer cuando sea necesario.

  • Configuration- XML ​​se explica por sí mismo y se utiliza mucho para definir configuraciones. Los objetos también se pueden utilizar con fines de configuración después de convertirlos a representación XML.

  • Unit Tests - XStream API es compatible con JUnit y se puede utilizar para mejorar las pruebas unitarias de los módulos de la aplicación.

En este capítulo, discutiremos los diferentes aspectos de la configuración de un entorno agradable para Java.

Configuración del entorno local

Si desea configurar su entorno para el lenguaje de programación Java, esta sección explica cómo descargar y configurar Java en su máquina. Siga los pasos que se indican a continuación para configurar su entorno Java.

Java SE se puede descargar de forma gratuita desde el enlace:

Descarga Java .

Siga las instrucciones para descargar Java y ejecutar el .exepara instalar Java en su máquina. Una vez que haya instalado Java en su máquina, deberá configurar las variables de entorno para que apunten a los directorios de instalación correctos:

Configuración de la ruta para Windows 2000 / XP

Suponiendo que haya instalado Java en el directorio c: \ Archivos de programa \ java \ jdk -

  • Haga clic derecho en 'Mi PC' y seleccione 'Propiedades'.

  • Haga clic en el botón 'Variables de entorno' en la pestaña 'Avanzado'.

  • Modifique la variable 'Ruta' para que también contenga la ruta al ejecutable de Java. Por ejemplo, si la ruta está configurada actualmente en 'C: \ WINDOWS \ SYSTEM32', cambie su ruta para que lea 'C: \ WINDOWS \ SYSTEM32; c: \ Archivos de programa \ java \ jdk \ bin'.

Configuración de la ruta para Windows 95/98 / ME

Suponiendo que haya instalado Java en el directorio c: \ Archivos de programa \ java \ jdk -

  • Edite el archivo 'C: \ autoexec.bat' y agregue la siguiente línea al final:

    'SET PATH =% PATH%; C: \ Archivos de programa \ java \ jdk \ bin'

Configuración de la ruta para Linux, UNIX, Solaris, FreeBSD

La variable de entorno PATH debe establecerse para que apunte a dónde se han instalado los binarios de Java. Consulte la documentación de su shell si tiene problemas para hacer esto.

Por ejemplo, si usa bash como su shell, entonces agregaría la siguiente línea al final de su '.bashrc: export PATH = / path / to / java: $ PATH'

Editores populares de Java

Para escribir programas Java, necesitará un editor de texto. Hay IDE aún más sofisticados disponibles en el mercado. Pero por ahora, puede considerar uno de los siguientes:

  • Notepad - En Windows, puede usar cualquier editor de texto simple como el Bloc de notas (recomendado para este tutorial) o TextPad.

  • Netbeans - Es un IDE de Java que es gratuito y se puede descargar desde https://www.netbeans.org/index.html.

  • Eclipse - También es un IDE de Java desarrollado por la comunidad de código abierto eclipse y se puede descargar desde https://www.eclipse.org/.

Descarga XStream Archive

Descargue la última versión del archivo jar XStream desde xstream-1.4.7.jar. En el momento de escribir este tutorial, hemos descargado xstream-1.4.7.jar y lo hemos copiado en la carpeta C: \> XStream.

SO Nombre de archivo
Ventanas xstream-1.4.7.jar
Linux xstream-1.4.7.jar
Mac xstream-1.4.7.jar

Establecer el entorno XStream

Selecciona el XStream_HOMEvariable de entorno para apuntar a la ubicación del directorio base donde se almacena xstream jar en su máquina. La siguiente tabla muestra cómo configurar el entorno XStream en Windows, Linux y Mac, asumiendo que hemos extraído xstream-1.4.7.jar en la carpeta XStream.

No Señor. SO y descripción
1

Windows

Establezca la variable de entorno XStream_HOME en C: \ XStream
2

Linux

exportar XStream_HOME = / usr / local / XStream
3

Mac

exportar XStream_HOME = / Library / XStream

Establecer la variable CLASSPATH

Selecciona el CLASSPATHvariable de entorno para apuntar a la ubicación del jar XStream. La siguiente tabla muestra cómo configurar la variable CLASSPATH en sistemas Windows, Linux y Mac, asumiendo que hemos almacenado xstream-1.4.7.jar en la carpeta XStream.

No Señor. SO y descripción
1

Windows

Establezca la variable de entorno CLASSPATH en% CLASSPATH%;% XStream_HOME% \ xstream-1.4.7.jar;
2

Linux

export CLASSPATH = $ CLASSPATH: $ XStream_HOME / xstream-1.4.7.jar;
3

Mac

export CLASSPATH = $ CLASSPATH: $ XStream_HOME / xstream-1.4.7.jar;

Antes de entrar en los detalles de la biblioteca XStream, veamos una aplicación en acción. En este ejemplo, hemos creado clases de estudiantes y direcciones. Crearemos un objeto de estudiante y luego lo serializaremos en una cadena XML. Luego deserialice la misma cadena XML para recuperar el objeto del estudiante.

Cree un archivo de clase java llamado XStreamTester en C: \> XStream_WORKSPACE.

File: XStreamTester.java

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;
import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      
      Student student = tester.getStudentDetails();
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));
      
      //XML to Object Conversion
      Student student1 = (Student)xstream.fromXML(xml);
      System.out.println(student1);
   }
   
   private Student getStudentDetails() {
   
      Student student = new Student();
      student.setFirstName("Mahesh");
      student.setLastName("Parashar");
      student.setRollNo(1);
      student.setClassName("1st");

      Address address = new Address();
      address.setArea("H.No. 16/3, Preet Vihar.");
      address.setCity("Delhi");
      address.setState("Delhi");
      address.setCountry("India");
      address.setPincode(110012);

      student.setAddress(address);
      return student;
   }
   
   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

class Student {
   private int rollNo;
   private String firstName;
   private String lastName;
   private String className;
   private Address address;

   public String getFirstName() {
      return firstName;
   }
   
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   
   public String getLastName() {
      return lastName;
   }
   
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }
   
   public int getRollNo() {
      return rollNo;
   }
   
   public void setRollNo(int rollNo) {
      this.rollNo = rollNo;
   }
   
   public String getClassName() {
      return className;
   }
   
   public void setClassName(String className) {
      this.className = className;
   }
   
   public Address getAddress() {
      return address;
   }
   
   public void setAddress(Address address) {
      this.address = address;
   }
   
   public String toString() {
      StringBuilder stringBuilder = new StringBuilder();
      
      stringBuilder.append("Student [ ");
      stringBuilder.append("\nfirstName: ");
      stringBuilder.append(firstName);
      stringBuilder.append("\nlastName: ");
      stringBuilder.append(lastName);
      stringBuilder.append("\nrollNo: ");
      stringBuilder.append(rollNo);
      stringBuilder.append("\nclassName: ");
      stringBuilder.append(className);
      stringBuilder.append("\naddress: ");
      stringBuilder.append(address);
      stringBuilder.append(" ]");
      
      return stringBuilder.toString();
   }
}

class Address {
   private String area;
   private String city;
   private String state;
   private String country;
   private int pincode;

   public String getArea() {
      return area;
   }

   public void setArea(String area) {
      this.area = area;
   }

   public String getCity() {
      return city;
   }

   public void setCity(String city) {
      this.city = city;
   }

   public String getState() {
      return state;
   }

   public void setState(String state) {
      this.state = state;
   }

   public String getCountry() {
      return country;
   }

   public void setCountry(String country) {
      this.country = country;
   }

   public int getPincode() {
      return pincode;
   }

   public void setPincode(int pincode) {
      this.pincode = pincode;
   }

   public String toString() {

      StringBuilder stringBuilder = new StringBuilder();

      stringBuilder.append("\nAddress [ ");
      stringBuilder.append("\narea: ");
      stringBuilder.append(area);
      stringBuilder.append("\ncity: ");
      stringBuilder.append(city);
      stringBuilder.append("\nstate: ");
      stringBuilder.append(state);
      stringBuilder.append("\ncountry: ");
      stringBuilder.append(country);
      stringBuilder.append("\npincode: ");	
      stringBuilder.append(pincode);
      stringBuilder.append(" ]");

      return stringBuilder.toString();
   }
}

Verify the Result

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE>java XStreamTester

Verify the output as follows

<?xml version = "1.0" encoding = "UTF-8"?>
<Student>
   <firstName>Mahesh</firstName>
   <lastName>Parashar</lastName>
   <rollNo>1</rollNo>
   <className>1st</className>
   <address>
      <area>H.No. 16/3, Preet Vihar.</area>
      <city>Delhi</city>
      <state>Delhi</state>
      <country>India</country>
      <pincode>110012</pincode>
   </address>
</Student>

Student [ 
   firstName: Mahesh
   lastName: Parashar
   rollNo: 1
   className: 1st
   address: 
   Address [ 
      area: H.No. 16/3, Preet Vihar.
      city: Delhi
      state: Delhi
      country: India
      pincode: 110012
   ] 
]

Pasos para recordar

Los siguientes son los pasos importantes que se deben considerar aquí.

Paso 1: crear un objeto XStream

Cree un objeto XStream pasándole un StaxDriver. StaxDriver usa el analizador de extracción de Stax (disponible en java 6) y es un analizador xml rápido.

XStream xstream = new XStream(new StaxDriver());

Paso 2: serializar el objeto en XML

Utilice el método toXML () para obtener la representación de cadena XML del objeto.

//Object to XML Conversion
String xml = xstream.toXML(student);

Paso 3: Desserializar XML para obtener el objeto

Utilice el método fromXML () para obtener el objeto del XML.

//XML to Object Conversion		
Student student1 = (Student)xstream.fromXML(xml);

La creación de alias es una técnica para personalizar el XML generado o para utilizar un XML formateado particular utilizando XStream. Supongamos que se va a utilizar el siguiente formato XML para serializar / deserializar el objeto Student.

<student name = "Suresh">
   <note>
      <title>first</title>
      <description>My first assignment.</description>
   </note>
   
   <note>
      <title>second</title>
      <description>My second assignment.</description>
   </note>
</student>

Basándonos en el formato XML anterior, creemos clases de modelo.

class Student {
   private String studentName;
   private List<Note> notes = new ArrayList<Note>();
   
   public Student(String name) {
      this.studentName = name;
   }
   
   public void addNote(Note note) {
      notes.add(note);
   }
   
   public String getName() {
      return studentName;
   }
   
   public List<Note> getNotes() {
      return notes;
   }
}

class Note {
   private String title;
   private String description;

   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }

   public String getTitle() {
      return title;
   }

   public String getDescription() {
      return description;
   }     
}

Probemos la serialización de los objetos anteriores usando XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }	

   private Student getStudentDetails() {
   
      Student student = new Student("Mahesh");
      
      student.addNote(new Note("first","My first assignment."));
      student.addNote(new Note("second","My Second assignment."));
      
      return student;
   }

   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

class Student {
   private String studentName;
   private List<Note> notes = new ArrayList<Note>();
   
   public Student(String name) {
      this.studentName = name;
   }
   
   public void addNote(Note note) {
      notes.add(note);
   }
   
   public String getName() {
      return studentName;
   }
   
   public List<Note> getNotes() {
      return notes;
   }
}

class Note {
   private String title;
   private String description;
   
   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }
   
   public String getTitle() {
      return title;
   }
   
   public String getDescription() {
      return description;
   }     
}

Verify the Result

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

<?xml version = "1.0" encoding = "UTF-8"?>
<com.tutorialspoint.xstream.Student>
   <studentName>Mahesh</studentName>
   <notes>
      <com.tutorialspoint.xstream.Note>
         <title>first</title>
         <description>My first assignment.</description>
      </com.tutorialspoint.xstream.Note>
      
      <com.tutorialspoint.xstream.Note>
         <title>second</title>
         <description>My Second assignment.</description>
     </com.tutorialspoint.xstream.Note>
   </notes>
</com.tutorialspoint.xstream.Student>

En el resultado anterior, el nombre del objeto Student está completamente calificado. Para reemplazarlo como etiqueta de estudiante, siga la siguiente sección.

XStream admite anotaciones de manera similar a la configuración automática en lugar de la codificación. En el capítulo anterior, hemos visto las siguientes configuraciones en código.

xstream.alias("student", Student.class);
xstream.alias("note", Note.class);

xstream.useAttributeFor(Student.class, "studentName");
xstream.aliasField("name", Student.class, "studentName");
xstream.addImplicitCollection(Student.class, "notes");

El siguiente fragmento de código ilustra el uso de anotaciones para hacer el mismo trabajo de una manera mucho más sencilla.

@XStreamAlias("student")   //define class level alias
class Student {

   @XStreamAlias("name")   //define field level alias
   @XStreamAsAttribute     //define field as attribute
   private String studentName;
   
   @XStreamImplicit        //define list as an implicit collection
   private List<Note> notes = new ArrayList<Note>();
   
   @XStreamOmitField       //omit a field to not to be a part of XML
   private int type;
}

Probemos la anotación anterior usando XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Archivo: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import java.util.ArrayList;
import java.util.List;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.annotations.XStreamImplicit;
import com.thoughtworks.xstream.annotations.XStreamOmitField;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {

      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      
      xstream.processAnnotations(Student.class);		

      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }
   
   private Student getStudentDetails() {
   
      Student student = new Student("Mahesh");
      
      student.addNote(new Note("first","My first assignment."));
      student.addNote(new Note("second","My Second assignment."));
      student.setType(1);
      
      return student;
   }

   public static String formatXml(String xml) {
   
      try {
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res = new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute   
   private String studentName;

   @XStreamImplicit
   private List<Note> notes = new ArrayList<Note>();

   public Student(String name) {
      this.studentName = name;
   }

   public void addNote(Note note) {
      notes.add(note);
   }

   public String getName() {
      return studentName;
   }

   public List<Note> getNotes() {
      return notes;
   }
   
   @XStreamOmitField		
   private int type;

   public int getType() {
      return type;
   }

   public void setType(int type) {
      this.type = type;
   }
}

@XStreamAlias("note")
class Note {
   private String title;
   private String description;

   public Note(String title, String description) {
      this.title = title;
      this.description = description;
   }

   public String getTitle() {
      return title;
   }

   public String getDescription() {
      return description;
   }     
}

Verificar el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

<?xml version = "1.0" encoding = "UTF-8"?>
<student name = "Mahesh">
   <note>
      <title>first</title>
      <description>My first assignment.</description>
   </note>

   <note>
      <title>second</title>
      <description>My Second assignment.</description>
   </note>
</student>

Para indicarle al marco XStream que procese la anotación, debe agregar el siguiente comando antes de serializar xml.

xstream.processAnnotations(Student.class);

O

xstream.autodetectAnnotations(true);

Los convertidores XStream son los componentes clave de la biblioteca XStream, que son responsables de convertir un objeto a XML y viceversa. XStream proporciona numerosos convertidores para tipos comunes como primitivas, cadenas, archivos, colecciones, matrices y fechas.

Usando convertidor

Usemos un SingleValueConvertor cuyo propósito es convertir un objeto en una sola cadena. Usaremos SingleValueConvertor para escribir un objeto como cadena de atributos.

Crear un convertidor

class NameConverter implements SingleValueConverter {

   public Object fromString(String name) {
      String[] nameparts = name.split(",");
      return new Name(nameparts[0], nameparts[1]);
   }
   
   public String toString(Object name) {
      return ((Name)name).getFirstName() + "," + ((Name)name).getLastName();
   }
   
   public boolean canConvert(Class type) {
      return type.equals(Name.class);
   }	
}

Registrar un convertidor

xstream.registerConverter(new NameConverter());

Ejemplo sin convertidor

Primero probemos el código sin convertidor en XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();
      xstream.autodetectAnnotations(true);
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));
   }
   
   private Student getStudentDetails() {
      Student student = new Student("Mahesh","Parashar");
      return student;
   }
   
   public static String formatXml(String xml) {
   
      try {
      
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res =  new StreamResult(new ByteArrayOutputStream());
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute
   private Name studentName;

   public Student(String firstName, String lastName) {
      this.studentName = new Name(firstName, lastName);
   }

   public Name getName() {
      return studentName;
   }	
}

class Name {
   private String firstName;
   private String lastName;

   public Name(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }     
}

Verify the Result

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

<?xml version = "1.0" encoding = "UTF-8"?>
<student>
   <name>
      <firstName>Mahesh</firstName>
      <lastName>Parashar</lastName>
   </name>
</student>

Ejemplo con convertidor

Probemos ahora el código con convertidor en XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

File: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamResult;

import org.xml.sax.InputSource;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.converters.SingleValueConverter;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {

   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      Student student = tester.getStudentDetails();		
      
      xstream.autodetectAnnotations(true);
      xstream.registerConverter(new NameConverter());
      
      //Object to XML Conversion
      String xml = xstream.toXML(student);
      System.out.println(formatXml(xml));		
   }	

   private Student getStudentDetails() {
      Student student = new Student("Mahesh","Parashar");		
      return student;
   }

   public static String formatXml(String xml) {

      try {
      
         Transformer serializer = SAXTransformerFactory.newInstance().newTransformer();
         
         serializer.setOutputProperty(OutputKeys.INDENT, "yes");         
         serializer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
         
         Source xmlSource = new SAXSource(new InputSource(
            new ByteArrayInputStream(xml.getBytes())));
         StreamResult res = new StreamResult(new ByteArrayOutputStream());            
         
         serializer.transform(xmlSource, res);
         
         return new String(((ByteArrayOutputStream)res.getOutputStream()).toByteArray());
         
      } catch(Exception e) {   
         return xml;
      }
   }
}

@XStreamAlias("student")
class Student {

   @XStreamAlias("name")
   @XStreamAsAttribute	
   private Name studentName;

   public Student(String firstName, String lastName) {
      this.studentName = new Name(firstName, lastName);
   }

   public Name getName() {
      return studentName;
   }	
}

class Name {
   private String firstName;
   private String lastName;

   public Name(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }     
}

class NameConverter implements SingleValueConverter  {

   public Object fromString(String name) {
      String[] nameparts = name.split(",");
      return new Name(nameparts[0], nameparts[1]);
   }

   public String toString(Object name) {
      return ((Name)name).getFirstName() + "," + ((Name)name).getLastName();
   }

   public boolean canConvert(Class type) {
      return type.equals(Name.class);
   }
}

Verify the Result

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

<?xml version = "1.0" encoding = "UTF-8"?>
<student name = "Mahesh,Parashar"/>

Convertidor personalizado

XStream proporciona implementaciones alternativas de java.io.ObjectInputStream y java.io.ObjectOutputStream para que los flujos de objetos se puedan serializar o deserializar desde XML. Esto es particularmente útil cuando se van a procesar grandes conjuntos de objetos, manteniendo un objeto en la memoria a la vez.

Sintaxis: createObjectOutputStream ()

ObjectOutputStream objectOutputStream = xstream.createObjectOutputStream(
   new FileOutputStream("test.txt"));

Sintaxis: createObjectInputStream ()

ObjectInputStream objectInputStream = xstream.createObjectInputStream(
   new FileInputStream("test.txt"));

Probemos ahora el código con flujos de objetos en XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Archivo: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.io.xml.StaxDriver;

public class XStreamTester {
   public static void main(String args[]) {
   
      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new StaxDriver());
      
      xstream.autodetectAnnotations(true);
      
      Student student1 = new Student("Mahesh","Parashar");
      Student student2 = new Student("Suresh","Kalra");
      Student student3 = new Student("Ramesh","Kumar");
      Student student4 = new Student("Naresh","Sharma");
      
      try {
      
         ObjectOutputStream objectOutputStream = xstream.createObjectOutputStream(
            new FileOutputStream("test.txt"));
         
         objectOutputStream.writeObject(student1);
         objectOutputStream.writeObject(student2);
         objectOutputStream.writeObject(student3);
         objectOutputStream.writeObject(student4);
         objectOutputStream.writeObject("Hello World");
         
         objectOutputStream.close();
         
         ObjectInputStream objectInputStream = xstream.createObjectInputStream(
            new FileInputStream("test.txt"));
         
         Student student5 = (Student)objectInputStream.readObject();
         Student student6 = (Student)objectInputStream.readObject();
         Student student7 = (Student)objectInputStream.readObject();
         Student student8 = (Student)objectInputStream.readObject();
         
         String text = (String)objectInputStream.readObject();
         
         System.out.println(student5);
         System.out.println(student6);
         System.out.println(student7);
         System.out.println(student8);
         System.out.println(text);
      
      } catch (IOException e) {
         e.printStackTrace();
         
      } catch (ClassNotFoundException e) {
         e.printStackTrace();
      }
   }
}

@XStreamAlias("student")
class Student {

   private String firstName;
   private String lastName;
   
   public Student(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }   

   public String toString() {
      return "Student [ firstName: "+firstName+", lastName: "+ lastName+ " ]";
   }	
}

Verificar el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

Student [ firstName: Mahesh, lastName: Parashar ]
Student [ firstName: Suresh, lastName: Kalra ]
Student [ firstName: Ramesh, lastName: Kumar ]
Student [ firstName: Naresh, lastName: Sharma ]
Hello World

Mire el contenido del test.txt presente en la carpeta C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

<?xml version = "1.0" ?>
<object-stream>
   <student>
      <firstName>Mahesh</firstName>
      <lastName>Parashar</lastName>
   </student>
   
   <student>
      <firstName>Suresh</firstName>
      <lastName>Kalra</lastName>
   </student>
   
   <student>
      <firstName>Ramesh</firstName>
      <lastName>Kumar</lastName>
   </student>
   
   <student>
      <firstName>Naresh</firstName>
      <lastName>Sharma</lastName>
   </student>
   <string>Hello World</string>
</object-stream>

XStream admite JSON al inicializar el objeto XStream con un controlador apropiado. XStream actualmente admite JettisonMappedXmlDriver y JsonHierarchicalStreamDriver.

Probemos ahora el código con el manejo de json en XStream.

Cree un archivo de clase de Java llamado XStreamTester en C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Archivo: XStreamTester.java

package com.tutorialspoint.xstream;

import java.io.Writer;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.io.json.JsonHierarchicalStreamDriver;
import com.thoughtworks.xstream.io.json.JsonWriter;

public class XStreamTester {

   public static void main(String args[]) {

      XStreamTester tester = new XStreamTester();
      XStream xstream = new XStream(new JsonHierarchicalStreamDriver() {
      
         public HierarchicalStreamWriter createWriter(Writer writer) {
            return new JsonWriter(writer, JsonWriter.DROP_ROOT_MODE);
         }
      });

      Student student = new Student("Mahesh","Parashar");

      xstream.setMode(XStream.NO_REFERENCES);
      xstream.alias("student", Student.class);
      
      System.out.println(xstream.toXML(student));
   }
}

@XStreamAlias("student")
class Student {

   private String firstName;
   private String lastName;

   public Student(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }

   public String getFirstName() {
      return firstName;
   }

   public String getLastName() {
      return lastName;
   }   
	
   public String toString() {
      return "Student [ firstName: "+firstName+", lastName: "+ lastName+ " ]";
   }	
}

Verificar el resultado

Compila las clases usando javac compilador de la siguiente manera:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>javac XStreamTester.java

Ahora ejecute XStreamTester para ver el resultado:

C:\XStream_WORKSPACE\com\tutorialspoint\xstream>java XStreamTester

Verifique la salida de la siguiente manera:

{
   "firstName": "Mahesh",
   "lastName": "Parashar"
}