XStream - Guia rápido

XStream é uma biblioteca simples baseada em Java para serializar objetos Java para XML e vice-versa.

Características

Easy to use - A API XStream fornece uma fachada de alto nível para simplificar os casos de uso comuns.
No need to create mapping - A API XStream fornece mapeamento padrão para a maioria dos objetos a serem serializados.
Performance - XStream é rápido e ocupa pouco espaço na memória, o que é adequado para grandes gráficos de objetos ou sistemas.
Clean XML - XStream produz saída XML limpa e compacta que é fácil de ler.
Object modification not required- XStream serializa campos internos como campos privados e finais e oferece suporte a classes internas e não públicas. O construtor padrão não é um requisito obrigatório.
Full object graph support - XStream permite manter referências duplicadas encontradas no modelo de objeto e também suporta referências circulares.
Customizable conversion strategies - Estratégias personalizadas podem ser registradas para permitir a personalização de um tipo específico para ser representado como XML.
Security framework - O XStream fornece um controle justo sobre os tipos não marcados para evitar problemas de segurança com entrada manipulada.
Error messages - Quando ocorre uma exceção devido a XML malformado, ele fornece diagnósticos detalhados para corrigir o problema.
Alternative output format - XStream suporta outros formatos de saída como JSON e morphing.

Usos Comuns

Transport - XML é uma representação de texto do objeto e pode ser usado para transportar objetos pela rede, independentemente das técnicas de serialização / desserialização usadas.
Persistence - Os objetos podem ser persistidos como XML em bancos de dados e podem ser empacotados / descompactados como e quando necessário.
Configuration- XML é autoexplicativo e muito usado para definir configurações. Os objetos também podem ser usados para fins de configuração após convertê-los em representação XML.
Unit Tests - A API XStream é compatível com JUnit e pode ser usada para aprimorar o teste de unidade de módulos de aplicativo.

Neste capítulo, discutiremos os diferentes aspectos da configuração de um ambiente adequado para Java.

Configuração de ambiente local

Se você deseja configurar seu ambiente para a linguagem de programação Java, esta seção explica como baixar e configurar o Java em sua máquina. Siga as etapas abaixo para configurar seu ambiente Java.

Java SE pode ser baixado gratuitamente no link -

Baixe o Java .

Siga as instruções para baixar o Java e executar o .exepara instalar o Java em sua máquina. Depois de instalar o Java em sua máquina, você precisará definir as variáveis de ambiente para apontar para os diretórios de instalação corretos -

Configurando o caminho para Windows 2000 / XP

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

Clique com o botão direito em 'Meu Computador' e selecione 'Propriedades'.
Clique no botão 'Variáveis de ambiente' na guia 'Avançado'.
Altere a variável 'Path' para que também contenha o caminho para o executável Java. Por exemplo, se o caminho estiver definido atualmente para 'C: \ WINDOWS \ SYSTEM32', altere seu caminho para 'C: \ WINDOWS \ SYSTEM32; c: \ Arquivos de programas \ java \ jdk \ bin'.

Configurando o Caminho para Windows 95/98 / ME

Supondo que você tenha instalado o Java no diretório c: \ Arquivos de programas \ java \ jdk -

Edite o arquivo 'C: \ autoexec.bat' e adicione a seguinte linha no final -

'SET PATH =% PATH%; C: \ Arquivos de programas \ java \ jdk \ bin'

Configurando o caminho para Linux, UNIX, Solaris, FreeBSD

A variável de ambiente PATH deve ser definida para apontar para onde os binários Java foram instalados. Consulte a documentação do shell se tiver problemas para fazer isso.

Por exemplo, se você usar bash como shell, adicione a seguinte linha no final de seu '.bashrc: export PATH = / path / to / java: $ PATH'

Editores Java populares

Para escrever programas Java, você precisará de um editor de texto. Existem IDEs ainda mais sofisticados disponíveis no mercado. Mas, por enquanto, você pode considerar um dos seguintes -

Notepad - No Windows, você pode usar qualquer editor de texto simples como o Notepad (recomendado para este tutorial) ou TextPad.
Netbeans - É um IDE Java que é gratuito e pode ser baixado de https://www.netbeans.org/index.html.
Eclipse - Também é um IDE Java desenvolvido pela comunidade de código aberto eclipse e pode ser baixado de https://www.eclipse.org/.

Baixar Arquivo XStream

Baixe a versão mais recente do arquivo jar XStream em xstream-1.4.7.jar. No momento em que escrevemos este tutorial, baixamos xstream-1.4.7.jar e o copiamos para a pasta C: \> XStream.

SO	Nome do arquivo
janelas	xstream-1.4.7.jar
Linux	xstream-1.4.7.jar
Mac	xstream-1.4.7.jar

Definir ambiente XStream

Colocou o XStream_HOMEvariável de ambiente para apontar para o local do diretório base onde xstream jar está armazenado em sua máquina. A tabela a seguir mostra como definir o ambiente XStream no Windows, Linux e Mac, supondo que extraímos xstream-1.4.7.jar na pasta XStream.

Sr. Não.	SO e descrição
1	Windows Defina a variável de ambiente XStream_HOME para C: \ XStream
2	Linux export XStream_HOME = / usr / local / XStream
3	Mac export XStream_HOME = / Library / XStream

Definir variável CLASSPATH

Colocou o CLASSPATHvariável de ambiente para apontar para o local do jar XStream. A tabela a seguir mostra como definir a variável CLASSPATH no sistema Windows, Linux e Mac, assumindo que armazenamos xstream-1.4.7.jar na pasta XStream.

Sr. Não.	SO e descrição
1	Windows Defina a variável de ambiente CLASSPATH como% 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 nos detalhes da biblioteca XStream, vamos ver um aplicativo em ação. Neste exemplo, criamos as classes Student e Address. Criaremos um objeto de aluno e o serializaremos em uma string XML. Em seguida, desserialize a mesma string XML para obter o objeto do aluno de volta.

Crie um arquivo de classe java denominado XStreamTester em 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

Compile as classes usando javac compilador da seguinte forma -

C:\XStream_WORKSPACE>javac XStreamTester.java

Agora execute o XStreamTester para ver o 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
   ] 
]

Passos para lembrar

A seguir estão as etapas importantes a serem consideradas aqui.

Etapa 1: Criar um objeto XStream

Crie um objeto XStream passando um StaxDriver. StaxDriver usa o analisador pull Stax (disponível em java 6) e é um analisador xml rápido.

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

Etapa 2: serializar o objeto para XML

Use o método toXML () para obter a representação de string XML do objeto.

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

Etapa 3: desserializar o XML para obter o objeto

Use o método fromXML () para obter o objeto do XML.

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

Aliasing é uma técnica para personalizar o XML gerado ou usar um determinado XML formatado usando XStream. Vamos supor que o seguinte formato XML seja usado para serializar / desserializar o objeto Aluno.

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

Com base no formato XML acima, vamos criar classes 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;
   }     
}

Vamos testar a serialização dos objetos acima usando o XStream.

Crie um arquivo de classe java denominado XStreamTester em 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

<?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>

No resultado acima, o nome do objeto Aluno é totalmente qualificado. Para substituí-la como etiqueta de aluno, siga a próxima seção.

Aliasing de classe
Aliasing de campo
Aliasing de coleções implícitas
Atributo Aliasing
Aliasing de pacote

O XStream oferece suporte a anotações de forma semelhante, como configuração automática em vez de codificação. No capítulo anterior, vimos as seguintes configurações no 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");

O fragmento de código a seguir ilustra o uso de anotações para fazer o mesmo trabalho de uma maneira muito mais fácil.

@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;
}

Vamos testar a anotação acima usando XStream.

Crie um arquivo de classe java denominado XStreamTester em C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Arquivo: 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;
   }     
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

<?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 instruir a estrutura XStream a processar a anotação, você precisa adicionar o seguinte comando antes de serializar o xml.

xstream.processAnnotations(Student.class);

xstream.autodetectAnnotations(true);

Os conversores XStream são os principais componentes da biblioteca XStream, responsáveis por converter um objeto em XML e vice-versa. XStream fornece vários conversores para tipos comuns, como primitivos, String, Arquivo, Coleções, arrays e Datas.

Usando o conversor

Vamos usar um SingleValueConvertor cujo objetivo é converter um objeto em uma única string. Usaremos SingleValueConvertor para escrever um objeto como string de atributo.

Crie um conversor

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

Registre um conversor

xstream.registerConverter(new NameConverter());

Exemplo sem conversor

Vamos primeiro testar o código sem conversor em XStream.

Crie um arquivo de classe java denominado XStreamTester em 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

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

Exemplo com conversor

Vamos agora testar o código com conversor em XStream.

Crie um arquivo de classe java denominado XStreamTester em 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

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

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

Conversor Personalizado

XStream fornece implementações alternativas de java.io.ObjectInputStream e java.io.ObjectOutputStream para que fluxos de objetos possam ser serializados ou desserializados de XML. Isso é particularmente útil quando grandes conjuntos de objetos devem ser processados, mantendo um objeto na memória por vez.

Sintaxe: createObjectOutputStream ()

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

Sintaxe: createObjectInputStream ()

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

Vamos agora testar o código com fluxos de objetos no XStream.

Crie um arquivo de classe java denominado XStreamTester em C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Arquivo: 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+ " ]";
   }	
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

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

Observe o conteúdo do test.txt presente na pasta 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 oferece suporte a JSON inicializando o objeto XStream com um driver apropriado. XStream atualmente oferece suporte a JettisonMappedXmlDriver e JsonHierarchicalStreamDriver.

Vamos agora testar o código com manipulação json no XStream.

Crie um arquivo de classe java denominado XStreamTester em C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

Arquivo: 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+ " ]";
   }	
}

Verifique o resultado

Compile as classes usando javac compilador da seguinte forma -

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

Agora execute o XStreamTester para ver o resultado -

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

Verifique a saída da seguinte forma -

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