XStream - Guida rapida

XStream è una semplice libreria basata su Java per serializzare oggetti Java in XML e viceversa.

Caratteristiche

Easy to use - XStream API fornisce una facciata di alto livello per semplificare i casi d'uso comuni.
No need to create mapping - XStream API fornisce la mappatura predefinita per la maggior parte degli oggetti da serializzare.
Performance - XStream è veloce e ha un ingombro di memoria ridotto, adatto per sistemi o grafici a oggetti di grandi dimensioni.
Clean XML - XStream produce un output XML pulito e compatto di facile lettura.
Object modification not required- XStream serializza i campi interni come i campi privati e finali e supporta le classi non pubbliche e interne. Il costruttore predefinito non è un requisito obbligatorio.
Full object graph support - XStream consente di mantenere i riferimenti duplicati incontrati nel modello a oggetti e supporta anche i riferimenti circolari.
Customizable conversion strategies - È possibile registrare strategie personalizzate per consentire la personalizzazione di un tipo particolare da rappresentare come XML.
Security framework - XStream fornisce un controllo equo sui tipi unmarshalled per prevenire problemi di sicurezza con input manipolato.
Error messages - Quando si verifica un'eccezione a causa di XML non valido, fornisce una diagnostica dettagliata per risolvere il problema.
Alternative output format - XStream supporta altri formati di output come JSON e morphing.

Usi comuni

Transport - XML è una rappresentazione testuale di un oggetto e può essere utilizzato per trasportare oggetti in rete indipendentemente dalle tecniche di serializzazione / deserializzazione utilizzate.
Persistence - Gli oggetti possono essere persistenti come XML nei database e possono essere sottoposti a marshalling / unmarshalling come e quando richiesto.
Configuration- XML è autoesplicativo ed è ampiamente utilizzato per definire le configurazioni. Gli oggetti possono essere utilizzati anche a scopo di configurazione dopo averli convertiti in rappresentazione XML.
Unit Tests - XStream API è compatibile con JUnit e può essere utilizzata per migliorare i test unitari dei moduli dell'applicazione.

In questo capitolo discuteremo i diversi aspetti della configurazione di un ambiente congeniale per Java.

Configurazione dell'ambiente locale

Se desideri configurare il tuo ambiente per il linguaggio di programmazione Java, questa sezione spiega come scaricare e configurare Java sulla tua macchina. Segui i passaggi indicati di seguito per configurare il tuo ambiente Java.

Java SE può essere scaricato gratuitamente dal link -

Scarica Java .

Segui le istruzioni per scaricare Java ed eseguire il file .exeper installare Java sulla tua macchina. Dopo aver installato Java sulla macchina, è necessario impostare le variabili di ambiente in modo che puntino alle directory di installazione corrette -

Impostazione del percorso per Windows 2000 / XP

Supponendo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

Fare clic con il tasto destro del mouse su "Risorse del computer" e selezionare "Proprietà".
Fare clic sul pulsante "Variabili d'ambiente" nella scheda "Avanzate".
Modificare la variabile "Path" in modo che contenga anche il percorso dell'eseguibile Java. Ad esempio, se il percorso è attualmente impostato su "C: \ WINDOWS \ SYSTEM32", modificare il percorso in "C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin".

Impostazione del percorso per Windows 95/98 / ME

Supponendo che tu abbia installato Java nella directory c: \ Program Files \ java \ jdk -

Modifica il file "C: \ autoexec.bat" e aggiungi la seguente riga alla fine:

"SET PATH =% PATH%; C: \ Program Files \ java \ jdk \ bin"

Configurazione del percorso per Linux, UNIX, Solaris, FreeBSD

La variabile d'ambiente PATH dovrebbe essere impostata in modo che punti a dove sono stati installati i binari Java. Fare riferimento alla documentazione della shell se si hanno problemi a farlo.

Ad esempio, se usi bash come shell, aggiungi la seguente riga alla fine di '.bashrc: export PATH = / path / to / java: $ PATH'

Editor Java popolari

Per scrivere programmi Java, avrai bisogno di un editor di testo. Sul mercato sono disponibili IDE ancora più sofisticati. Ma per ora, puoi considerare uno dei seguenti:

Notepad - Su Windows, puoi utilizzare qualsiasi semplice editor di testo come Blocco note (consigliato per questo tutorial) o TextPad.
Netbeans - È un IDE Java gratuito e può essere scaricato da https://www.netbeans.org/index.html.
Eclipse - È anche un IDE Java sviluppato dalla comunità open source di eclipse e può essere scaricato da https://www.eclipse.org/.

Scarica XStream Archive

Scarica l'ultima versione del file jar XStream da xstream-1.4.7.jar. Al momento della stesura di questo tutorial, abbiamo scaricato xstream-1.4.7.jar e copiato nella cartella C: \> XStream.

OS	Nome dell'archivio
finestre	xstream-1.4.7.jar
Linux	xstream-1.4.7.jar
Mac	xstream-1.4.7.jar

Imposta l'ambiente XStream

Impostare il XStream_HOMEvariabile di ambiente in modo che punti alla posizione della directory di base in cui xstream jar è archiviato sulla macchina. La tabella seguente mostra come impostare l'ambiente XStream su Windows, Linux e Mac, assumendo che abbiamo estratto xstream-1.4.7.jar nella cartella XStream.

Sr.No.	Sistema operativo e descrizione
1	Windows Imposta la variabile d'ambiente XStream_HOME su C: \ XStream
2	Linux export XStream_HOME = / usr / local / XStream
3	Mac export XStream_HOME = / Library / XStream

Imposta la variabile CLASSPATH

Impostare il CLASSPATHvariabile di ambiente in modo che punti alla posizione del jar XStream. La tabella seguente mostra come impostare la variabile CLASSPATH su sistemi Windows, Linux e Mac, assumendo che abbiamo archiviato xstream-1.4.7.jar nella cartella XStream.

Sr.No.	Sistema operativo e descrizione
1	Windows Imposta la variabile d'ambiente CLASSPATH su% 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;

Prima di entrare nei dettagli della libreria XStream, vediamo un'applicazione in azione. In questo esempio, abbiamo creato le classi Student e Address. Creeremo un oggetto studente e quindi lo serializzeremo in una stringa XML. Quindi de-serializzare la stessa stringa XML per ottenere indietro l'oggetto studente.

Crea un file di classe java denominato XStreamTester in 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 le classi usando javac compilatore come segue -

C:\XStream_WORKSPACE>javac XStreamTester.java

Ora esegui XStreamTester per vedere il risultato -

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

Passi da ricordare

Di seguito sono riportati i passaggi importanti da considerare qui.

Passaggio 1: crea un oggetto XStream

Crea un oggetto XStream passandogli uno StaxDriver. StaxDriver utilizza Stax pull parser (disponibile da java 6) ed è un veloce parser xml.

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

Passaggio 2: serializzare l'oggetto in XML

Utilizzare il metodo toXML () per ottenere la rappresentazione in stringa XML dell'oggetto.

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

Passaggio 3: de-serializzare XML per ottenere l'oggetto

Utilizzare il metodo fromXML () per ottenere l'oggetto dall'XML.

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

L'aliasing è una tecnica per personalizzare l'XML generato o per utilizzare un particolare XML formattato utilizzando XStream. Supponiamo che il seguente formato XML debba essere utilizzato per serializzare / de-serializzare l'oggetto 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>

Sulla base del formato XML sopra, creiamo classi modello.

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

Testiamo la serializzazione degli oggetti di cui sopra usando XStream.

Crea un file di classe java denominato XStreamTester in 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 le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

Nel risultato precedente, il nome dell'oggetto Student è completo. Per sostituirlo come tag studente, segui la sezione successiva.

XStream supporta le annotazioni in modo simile alla configurazione automatica invece della codifica. Nel capitolo precedente, abbiamo visto le seguenti configurazioni nel codice.

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

Il frammento di codice seguente illustra l'uso delle annotazioni per eseguire lo stesso lavoro in un modo molto più semplice.

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

Testiamo l'annotazione sopra usando XStream.

Crea un file di classe java denominato XStreamTester in 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.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;
   }     
}

Verifica il risultato

Compila le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

Per istruire il framework XStream a elaborare l'annotazione, è necessario aggiungere il seguente comando prima di serializzare xml.

xstream.processAnnotations(Student.class);

xstream.autodetectAnnotations(true);

I convertitori XStream sono i componenti chiave della libreria XStream, responsabili della conversione di un oggetto in XML e viceversa. XStream fornisce numerosi convertitori per tipi comuni come primitive, stringhe, file, raccolte, array e date.

Utilizzando Converter

Usiamo un SingleValueConvertor il cui scopo è convertire un oggetto in una singola stringa. Useremo SingleValueConvertor per scrivere un oggetto come stringa di attributi.

Crea un convertitore

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

Registra un convertitore

xstream.registerConverter(new NameConverter());

Esempio senza convertitore

Proviamo prima il codice senza convertitore in XStream.

Crea un file di classe java denominato XStreamTester in 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 le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

Esempio con Converter

Proviamo ora a testare il codice con il convertitore in XStream.

Crea un file di classe java denominato XStreamTester in 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 le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

Convertitore personalizzato

XStream fornisce implementazioni alternative di java.io.ObjectInputStream e java.io.ObjectOutputStream in modo che i flussi di oggetti possano essere serializzati o deserializzati da XML. Ciò è particolarmente utile quando devono essere elaborati grandi set di oggetti, mantenendo in memoria un oggetto alla volta.

Sintassi: createObjectOutputStream ()

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

Sintassi: createObjectInputStream ()

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

Proviamo ora a testare il codice con flussi di oggetti in XStream.

Crea un file di classe java denominato XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

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

Verifica il risultato

Compila le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

Guarda il contenuto del test.txt presente nella cartella 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 supporta JSON inizializzando l'oggetto XStream con un driver appropriato. XStream attualmente supporta JettisonMappedXmlDriver e JsonHierarchicalStreamDriver.

Proviamo ora a testare il codice con la gestione json in XStream.

Crea un file di classe java denominato XStreamTester in C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

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

Verifica il risultato

Compila le classi usando javac compilatore come segue -

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

Ora esegui XStreamTester per vedere il risultato -

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

Verificare l'output come segue:

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

↰ Previous page

XStream - Guida rapida

Caratteristiche

Usi comuni

Configurazione dell'ambiente locale

Impostazione del percorso per Windows 2000 / XP

Impostazione del percorso per Windows 95/98 / ME

Configurazione del percorso per Linux, UNIX, Solaris, FreeBSD

Editor Java popolari

Scarica XStream Archive

Imposta l'ambiente XStream

Imposta la variabile CLASSPATH

Passi da ricordare

Passaggio 1: crea un oggetto XStream

Passaggio 2: serializzare l'oggetto in XML

Passaggio 3: de-serializzare XML per ottenere l'oggetto

File: XStreamTester.java

Verifica il risultato

Utilizzando Converter

Crea un convertitore

Registra un convertitore

Esempio senza convertitore

Esempio con Converter

Sintassi: createObjectOutputStream ()

Sintassi: createObjectInputStream ()

File: XStreamTester.java

Verifica il risultato

File: XStreamTester.java

Verifica il risultato

Tutorial XStream

Risorse utili XStream