• .War
• Struts v1
• XStream

1. Présentation
2. Installation
3. Utilisation

Présentation

Le framework de persistance XStream est une API Java qui permet de sérialiser et de dé-sérialiser des objets de ce langage sous la forme d’arbres XML dont les nœuds sont par convention les attributs de l’objet. Rapide à prendre en main, sa facilité d’utilisation pour des résultats parfaitement acceptables est son plus grand atout. Basé sur l’introspection, ces mécanismes complexes sont cependant transparents pour l’utilisateur à moins qu’il ne brigue une stratégie de sérialisation entièrement personnalisée.

Ses principaux avantages sont :

• Grande facilité d’utilisation.
• Les arbres générés sont faciles à comprendre, à l’inverse de la sérialisation Java.
• Aucune modification du code n’est nécessaire, même pour les opérations avancées (cf. méthodes de la classe XStream).
• Rapidité d’exécution et peu de ressources mémoires.
• Pas de mapping entre les classes et les données persistantes.

L'inconvénient majeur de XStream est l'impossibilité de faire de la persistance de données avec SGBD, plus répandue, quand d’autres frameworks permettent les deux (Hibernate, JBoss, iBATIS, etc.).

XStream laisse néanmoins une grande marge de manœuvre à l’utilisateur lorsque celui-ci souhaite effectuer des sérialisation plus poussées. Outre le fait qu’il prenne naturellement en charge les collections d’objets (Array, List, Map), des annotations¹ et des alias peuvent être utilisés pour modifier l’arbre XML généré :

• @XStreamAlias : modification des noms des balises.
• @XStreamOmitField : omission d’attributs (équivalent au qualificatif transient).
• @XStreamAsAttribute : conservation du statut d’attribut en XML.

Enfin, pour les adeptes du Web 2.0, les données peuvent être sérialisées suivant le format JSON².

Installation

Le protocole d'installation qui suit a été rédigé pour l'environnement de développement Eclipse.

1. Commencez par télécharger la dernière version stable de XStream sur le site officiel. Dans notre cas, il s'agit de la version 1.3.1 dont voici un lien direct. Le fichier JAR à importer s'appelle xstream-1.3.1.jar et se trouve dans le répertoire xstream-distribution-1.3.1-bin\xstream-1.3.1\lib, à condition d'avoir dé-zippé l'archive dans le répertoire proposé.
   
   
2. Créez ensuite un nouveau projet JEE sous Eclipse : File > New > Project... > Web > Dynamic Web Project.
   Nous appellerons ce projet ImportXStream.
   
   
3. Il y a ensuite deux manières de procéder :
   • Glisser le JAR dans l'arborescence figurant à gauche d'Eclipse, dans le répertoire ImportXStream/WebContent/WEB-INF/lib.
     
     
   • Ou faites un clic droit sur le projet puis Properties (Project > Properties depuis le menu principal) > Java EE Module Dependencies > Add External JARs... et sélectionnez le JAR en question.

Dans un cas comme dans l'autre, le JAR apparaît normalement dans les bibliothèques importées du Build Path dans la section Web App Libraries.

Utilisation

XStream fonctionne selon deux principes : l'écriture (sérialisation) et la lecture (dé-sérialisation). Nous allons tout d'abord montrer comment sérialiser puis dé-sérialiser un objet Java simple avant de revenir sur les fonctionnalités avancées de XStream évoquées dans la présentation.

Considérons la classe Personne suivante :

public class Personne {
	private int numeroSecuriteSociale;
	private String nom;
	private String prenom;
	private int age;
			
	public Personne(){
						
	}

	public int getNumeroSecuriteSociale() {
		return numeroSecuriteSociale;
	}
	public void setNumeroSecuriteSociale(int numeroSecuriteSociale) {
		this.numeroSecuriteSociale = numeroSecuriteSociale;
	}
	public String getNom() {
		return nom;
	}
	public void setNom(String nom) {
		this.nom = nom;
	}
	public String getPrenom() {
		return prenom;
	}
	public void setPrenom(String prenom) {
		this.prenom = prenom;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

Pour sérialiser un objet Personne sous la forme d'un arbre XML, il suffit d'utiliser la méthode toXML(Object, OutputStream) de la classe XStream, comme indiqué ci-dessous.

import java.io.FileNotFoundException;
import java.io.FileOutputStream;

import com.thoughtworks.xstream.XStream;

public class Writer {

	public static void main(String[] args) {
		Personne p = new Personne();

		p.setNumeroSecuriteSociale(123456789);
		p.setNom("Khan");
		p.setPrenom("Gengis");
		p.setAge(66);

		XStream xs = new XStream();
		//Si l'on veut disposer de l'arbre XML sous la forme
		//d'une chaîne de caractères :

		String xml = xs.toXML(p);

		//Sinon, on ouvre un flux sur un fichier
		try {
			FileOutputStream fs;
			fs = new FileOutputStream("personne.txt");
			xs.toXML(p, fs);
		} catch (FileNotFoundException e1) {
			e1.printStackTrace();
		}
	}
}

On obtient ainsi le fichier personne.txt :

<Personne>
  <numeroSecuriteSociale>123456789</numeroSecuriteSociale>
  <nom>Khan</nom>
  <prenom>Gengis</prenom>
  <age>66</age>
</Personne>

Pour récupérer les informations sauvegardées dans le fichier personne.txt, il suffit d'utiliser la méthode fromXML(InputStream, Object) :

import java.io.FileInputStream;
import java.io.FileNotFoundException;

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

public class Reader {

	public static void main(String[] args) {
		XStream xs = new XStream(new DomDriver());
		Personne p = new Personne();

		try {
			FileInputStream fis = new FileInputStream("personne.txt");
			xs.fromXML(fis, p);

			System.out.println(p.toString());

		} catch (FileNotFoundException ex) {
			ex.printStackTrace();
		}

	}
}

Et, pour peu que l'on ait redéfini la méthode toString() de la classe Personne, on obtient en sortie standard :

numeroSecuriteSociale:123456789
nom:Khan
prenom:Gengis
age:66

Pour aller un peu plus loin, il est possible d'ajouter des annotations afin de modifier l'arbre généré par XStream. La classe Personne se voit ainsi munie d'une floppée de renseignements supplémentaires :

import java.util.List;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.annotations.XStreamImplicit;
import com.thoughtworks.xstream.annotations.XStreamOmitField;

@XStreamAlias("personne")
public class Personne {
	@XStreamAlias("numSecu")
	@XStreamAsAttribute
	private int numeroSecuriteSociale;
	private String nom;
	private String prenom;
	@XStreamOmitField
	private int age;
	@XStreamImplicit(itemFieldName="tel")
	private List<String> numerosTelephone;
	
	//Constructeur, getters, setters...
}

Lors d'une sérialisation, il faut maintenant spécifier à l'objet XStream de rechercher par introspection des annotations dans la classe Personne. Et lorsque l'on voudra dé-sérialiser un objet de la classe Personne, il faudra également stipuler à l'objet XStream de prendre en compte les annotations rajoutées.

XStream xs = new XStream();

//De façon automatique
xs.autodetectAnnotations(true);
//De façon contrôlée
xs.processAnnotations(Personne.class);

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

//La méthode automatique ne fonctionne pas
xs.processAnnotations(Personne.class);

<personne numSecu="123456789">
  <nom>Khan</nom>
  <prenom>Gengis</prenom>
  <tel>0102030405</tel>
  <tel>0011223344</tel>
</personne>

Pour finir, si l'on ne souhaite pas modifier le code en rajoutant des annotations, il est possible de passer directement par des méthodes de l'objet XStream : addImplicitCollection, alias, aliasAttribute, aliasField, omitField, etc. qui doivent être appelées à la lecture comme à l'écriture.

Enfin, on facilement spécifier l'encodage à la déclaration de l'objet XStream :
XStream xs = new XStream(new DomDriver("UTF-8"));

1 : http://xstream.codehaus.org/annotations-tutorial.html
2 : http://xstream.codehaus.org/json-tutorial.html

http://www.ibm.com/developerworks/library/x-xstream/index.html
http://ericreboisson.developpez.com/tutoriel/java/xml/xstream/

Copyright © 2010 - CAROFF BENARD LETEL NORET ROCHER - Tous droits réservés