XStream - Guide rapide

XStream est une bibliothèque Java simple pour sérialiser des objets Java en XML et vice versa.

traits

Easy to use - L'API XStream fournit une façade de haut niveau pour simplifier les cas d'utilisation courants.
No need to create mapping - L'API XStream fournit un mappage par défaut pour la plupart des objets à sérialiser.
Performance - XStream est rapide et a une faible empreinte mémoire, ce qui convient aux graphes ou systèmes d'objets volumineux.
Clean XML - XStream produit une sortie XML claire et compacte qui est facile à lire.
Object modification not required- XStream sérialise les champs internes comme les champs privés et finaux, et prend en charge les classes non publiques et internes. Le constructeur par défaut n'est pas une exigence obligatoire.
Full object graph support - XStream permet de conserver les références dupliquées rencontrées dans le modèle objet et prend également en charge les références circulaires.
Customizable conversion strategies - Des stratégies personnalisées peuvent être enregistrées afin de permettre la personnalisation d'un type particulier à représenter en XML.
Security framework - XStream fournit un contrôle équitable sur les types non mixtes pour éviter les problèmes de sécurité avec une entrée manipulée.
Error messages - Lorsqu'une exception se produit en raison d'un XML mal formé, il fournit des diagnostics détaillés pour résoudre le problème.
Alternative output format - XStream prend en charge d'autres formats de sortie comme JSON et le morphing.

Usages courants

Transport - XML est une représentation textuelle d'un objet et peut être utilisé pour transporter des objets sur le fil indépendamment des techniques de sérialisation / désérialisation utilisées.
Persistence - Les objets peuvent être persistants en tant que XML dans les bases de données et peuvent être rassemblés / désorganisés au fur et à mesure des besoins.
Configuration- XML est explicite et est largement utilisé pour définir les configurations. Les objets peuvent également être utilisés à des fins de configuration après les avoir convertis en représentation XML.
Unit Tests - L'API XStream est compatible JUnit et peut être utilisée pour améliorer les tests unitaires des modules d'application.

Dans ce chapitre, nous discuterons des différents aspects de la configuration d'un environnement convivial pour Java.

Configuration de l'environnement local

Si vous souhaitez configurer votre environnement pour le langage de programmation Java, cette section explique comment télécharger et configurer Java sur votre machine. Veuillez suivre les étapes ci-dessous pour configurer votre environnement Java.

Java SE peut être téléchargé gratuitement à partir du lien -

Téléchargez Java .

Suivez les instructions pour télécharger Java et exécuter le .exepour installer Java sur votre machine. Une fois que vous avez installé Java sur votre machine, vous devez définir les variables d'environnement pour qu'elles pointent vers les répertoires d'installation corrects -

Configuration du chemin pour Windows 2000 / XP

En supposant que vous ayez installé Java dans le répertoire c: \ Program Files \ java \ jdk -

Cliquez avec le bouton droit sur «Poste de travail» et sélectionnez «Propriétés».
Cliquez sur le bouton "Variables d'environnement" sous l'onglet "Avancé".
Modifiez la variable «Path» afin qu'elle contienne également le chemin d'accès à l'exécutable Java. Par exemple, si le chemin est actuellement défini sur «C: \ WINDOWS \ SYSTEM32», modifiez votre chemin pour lire «C: \ WINDOWS \ SYSTEM32; c: \ Program Files \ java \ jdk \ bin».

Configuration du chemin pour Windows 95/98 / ME

En supposant que vous ayez installé Java dans le répertoire c: \ Program Files \ java \ jdk -

Editez le fichier 'C: \ autoexec.bat' et ajoutez la ligne suivante à la fin -

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

Configuration du chemin pour Linux, UNIX, Solaris, FreeBSD

La variable d'environnement PATH doit être définie pour pointer vers l'endroit où les binaires Java ont été installés. Reportez-vous à la documentation de votre shell si vous rencontrez des problèmes pour cela.

Par exemple, si vous utilisez bash comme shell, vous ajouteriez la ligne suivante à la fin de votre '.bashrc: export PATH = / path / to / java: $ PATH'

Éditeurs Java populaires

Pour écrire des programmes Java, vous aurez besoin d'un éditeur de texte. Il existe des IDE encore plus sophistiqués disponibles sur le marché. Mais pour l'instant, vous pouvez envisager l'un des éléments suivants -

Notepad - Sous Windows, vous pouvez utiliser n'importe quel éditeur de texte simple comme Notepad (recommandé pour ce didacticiel) ou TextPad.
Netbeans - Il s'agit d'un IDE Java gratuit et téléchargeable sur https://www.netbeans.org/index.html.
Eclipse - C'est aussi un IDE Java développé par la communauté open source eclipse et peut être téléchargé depuis https://www.eclipse.org/.

Télécharger les archives XStream

Téléchargez la dernière version du fichier jar XStream à partir de xstream-1.4.7.jar. Au moment d'écrire ce tutoriel, nous avons téléchargé xstream-1.4.7.jar et l' avons copié dans le dossier C: \> XStream.

OS	Nom de l'archive
les fenêtres	xstream-1.4.7.jar
Linux	xstream-1.4.7.jar
Mac	xstream-1.4.7.jar

Définir l'environnement XStream

Met le XStream_HOMEvariable d'environnement pour pointer vers l'emplacement du répertoire de base où xstream jar est stocké sur votre machine. Le tableau suivant montre comment définir l'environnement XStream sur Windows, Linux et Mac, en supposant que nous avons extrait xstream-1.4.7.jar dans le dossier XStream.

Sr.No.	OS et description
1	Windows Définissez la variable d'environnement XStream_HOME sur C: \ XStream
2	Linux export XStream_HOME = / usr / local / XStream
3	Mac export XStream_HOME = / Bibliothèque / XStream

Définir la variable CLASSPATH

Met le CLASSPATHvariable d'environnement pour pointer vers l'emplacement du fichier XStream. Le tableau suivant montre comment définir la variable CLASSPATH sur les systèmes Windows, Linux et Mac, en supposant que nous ayons stocké xstream-1.4.7.jar dans le dossier XStream.

Sr.No.	OS et description
1	Windows Définissez la variable d'environnement CLASSPATH sur% 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;

Avant d'entrer dans les détails de la bibliothèque XStream, voyons une application en action. Dans cet exemple, nous avons créé des classes Student et Address. Nous allons créer un objet étudiant, puis le sérialiser en une chaîne XML. Désérialisez ensuite la même chaîne XML pour récupérer l'objet étudiant.

Créez un fichier de classe Java nommé XStreamTester dans 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

Compilez les classes en utilisant javac compilateur comme suit -

C:\XStream_WORKSPACE>javac XStreamTester.java

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Étapes à retenir

Voici les étapes importantes à considérer ici.

Étape 1: créer un objet XStream

Créez un objet XStream en lui passant un StaxDriver. StaxDriver utilise l'analyseur d'extraction Stax (disponible à partir de java 6) et est un analyseur XML rapide.

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

Étape 2: sérialiser l'objet en XML

Utilisez la méthode toXML () pour obtenir la représentation sous forme de chaîne XML de l'objet.

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

Étape 3: désérialiser XML pour obtenir l'objet

Utilisez la méthode fromXML () pour obtenir l'objet à partir du XML.

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

L'aliasing est une technique pour personnaliser le XML généré ou pour utiliser un XML formaté particulier à l'aide de XStream. Supposons que le format XML suivant soit utilisé pour sérialiser / désérialiser l'objet 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>

Sur la base du format XML ci-dessus, créons des classes de modèle.

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

Testons la sérialisation des objets ci-dessus à l'aide de XStream.

Créez un fichier de classe Java nommé XStreamTester dans 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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

Dans le résultat ci-dessus, le nom de l'objet Student est pleinement qualifié. Pour le remplacer comme étiquette d'étudiant, suivez la section suivante.

XStream prend en charge les annotations de la même manière que la configuration automatique au lieu du codage. Dans le chapitre précédent, nous avons vu les configurations suivantes dans le code.

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

L'extrait de code suivant illustre l'utilisation d'annotations pour effectuer le même travail de manière beaucoup plus simple.

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

Testons l'annotation ci-dessus en utilisant XStream.

Créez un fichier de classe Java nommé XStreamTester dans C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

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

Vérifiez le résultat

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

Pour indiquer au framework XStream de traiter les annotations, vous devez ajouter la commande suivante avant de sérialiser xml.

xstream.processAnnotations(Student.class);

xstream.autodetectAnnotations(true);

Les convertisseurs XStream sont les composants clés de la bibliothèque XStream, qui sont chargés de convertir un objet en XML et vice versa. XStream fournit de nombreux convertisseurs pour les types courants tels que les primitives, les chaînes, les fichiers, les collections, les tableaux et les dates.

Utilisation du convertisseur

Utilisons un SingleValueConvertor dont le but est de convertir un objet en une seule chaîne. Nous utiliserons SingleValueConvertor pour écrire un objet sous forme de chaîne d'attribut.

Créer un convertisseur

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

Enregistrer un convertisseur

xstream.registerConverter(new NameConverter());

Exemple sans convertisseur

Testons d'abord le code sans convertisseur dans XStream.

Créez un fichier de classe Java nommé XStreamTester dans 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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

Exemple avec convertisseur

Testons maintenant le code avec le convertisseur dans XStream.

Créez un fichier de classe Java nommé XStreamTester dans 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

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

Convertisseur personnalisé

XStream fournit des implémentations alternatives de java.io.ObjectInputStream et java.io.ObjectOutputStream afin que les flux d'objets puissent être sérialisés ou désérialisés à partir de XML. Ceci est particulièrement utile lorsque de grands ensembles d'objets doivent être traités, en gardant un objet en mémoire à la fois.

Syntaxe: createObjectOutputStream ()

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

Syntaxe: createObjectInputStream ()

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

Testons maintenant le code avec des flux d'objets dans XStream.

Créez un fichier de classe Java nommé XStreamTester dans C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

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

Vérifiez le résultat

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

Regardez le contenu du dossier test.txt présent dans le dossier 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 prend en charge JSON en initialisant l'objet XStream avec un pilote approprié. XStream prend actuellement en charge JettisonMappedXmlDriver et JsonHierarchicalStreamDriver.

Testons maintenant le code avec la gestion json dans XStream.

Créez un fichier de classe Java nommé XStreamTester dans C: \> XStream_WORKSPACE \ com \ tutorialspoint \ xstream.

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

Vérifiez le résultat

Compilez les classes en utilisant javac compilateur comme suit -

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

Maintenant, exécutez le XStreamTester pour voir le résultat -

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

Vérifiez la sortie comme suit -

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

↰ Previous page

XStream - Guide rapide

traits

Usages courants

Configuration de l'environnement local

Configuration du chemin pour Windows 2000 / XP

Configuration du chemin pour Windows 95/98 / ME

Configuration du chemin pour Linux, UNIX, Solaris, FreeBSD

Éditeurs Java populaires

Télécharger les archives XStream

Définir l'environnement XStream

Définir la variable CLASSPATH

Étapes à retenir

Étape 1: créer un objet XStream

Étape 2: sérialiser l'objet en XML

Étape 3: désérialiser XML pour obtenir l'objet

Fichier: XStreamTester.java

Vérifiez le résultat

Utilisation du convertisseur

Créer un convertisseur

Enregistrer un convertisseur

Exemple sans convertisseur

Exemple avec convertisseur

Syntaxe: createObjectOutputStream ()

Syntaxe: createObjectInputStream ()

Fichier: XStreamTester.java

Vérifiez le résultat

Fichier: XStreamTester.java

Vérifiez le résultat

Tutoriel XStream

Ressources utiles XStream