ATTENTION, la copie de ce code ne marchera pas ... veuillez télécharger le ZIP !
import java.beans.XMLDecoder;
import java.beans.XMLEncoder;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
/*
* Cet exemple est très simple, tout comme l'est la sérialisation XML. POur de
* plus amples informations sur ce principe, veuillez consulter la javadoc :
* - http://java.sun.com/j2se/1.4.2/docs/api/java/beans/XMLEncoder.html
* - http://java.sun.com/j2se/1.4.2/docs/api/java/beans/XMLDecoder.html
* - http://java.sun.com/j2se/1.4.2/docs/guide/serialization/
*
* Attention : la sérialisation XML est spécialisé dans les JavaBeans
* (c'est à dire les classes possédant des propriétés (un attributs et
* des accesseurs get/set appropriés) publiques.
*
* Il y a 4 choses qui sont donc INDISPENSABLE pour ça :
* - Un constructeur par défaut (sans paramètres)
* - La classe doit implémenter l'interface Serializable
* - Toutes les propriétés que vous devez enregistrer doivent avoir
* des accesseurs (get/set)
* - Etre une classe PUBLIQUE !! public class (La classe doit être dans son propre fichier !)
*/
/**
* Exemple d'une application utilisant la sérialisation XML.
* Nous utilisons une implémentation légère d'une liste chainée ...
*
* @author neodante (webmaster@neogamedev.com)
* @version 0.1 01-11-2004
* @since 01-11-2004
*/
public class XMLSerialisationSample {
/* Notre fonction principale. */
public static void main(String[] args) {
// Création des noeuds
System.out.println("Affichage avant sérialisation :");
Node root = new Node("Racine"); // Noued racine
Node node1 = new Node("Noeud 1"); // D'autres noeuds
Node node2 = new Node("Noeud 2");
// Construction de la liste chainée
root.attach(node1);
node1.attach(node2);
// Affichage de notre liste
root.printList();
// Enregistrement de nos noeuds à partir de la racine
try {
XMLEncoder e = new XMLEncoder(
new BufferedOutputStream(
new FileOutputStream("TestNode.xml")));
e.writeObject(root);
e.close();
} catch (FileNotFoundException e1) {
e1.printStackTrace();
}
// Destruction de notre liste
node2 = null;
node1 = null;
root = null;
// Lecture (désérialisation) de notre fichier XML
try {
XMLDecoder d = new XMLDecoder(new BufferedInputStream(
new FileInputStream("TestNode.xml")));
root = (Node) d.readObject();
d.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
// Affichage de notre liste
System.out.println("Affichage après désérialisation :");
root.printList();
}
}
import java.io.Serializable;
/**
* @author neodante (webmaster@neogamedev.com)
* @version 0.1 01-11-2004
* @since 01-11-2004
*/
public class Node implements Serializable {
/** Valeur de ce noeud. */
private Object value;
private Node prev;
private Node next;
/**
* Constructeur par défaut. Obligatoire pour la sérialisation XML
*/
public Node() {
prev = null;
next = null;
value = null;
}
/**
* Un autre constructeur ...
* @param val
* La valeur de ce noeud.
*/
public Node(Object val){
value = val;
}
/* Voici nos accesseurs. */
/**
* @return Returns the next.
*/
public Node getNext() {
return next;
}
/**
* @param next
* The next to set.
*/
public void setNext(Node next) {
this.next = next;
}
/**
* @return Returns the prev.
*/
public Node getPrev() {
return prev;
}
/**
* @param prev
* The prev to set.
*/
public void setPrev(Node prev) {
this.prev = prev;
}
/**
* @return Returns the value.
*/
public Object getValue() {
return value;
}
/**
* @param value
* The value to set.
*/
public void setValue(Object value) {
this.value = value;
}
/**
* Attacher un noeud à celui-ci. La référence next de cet objet
* est défini vers le noeud spécifié. Et la référence prev du
* noeud spécifié est définie vers ce noeud.
*
* @param node
* Noeud à attacher à celui-ci. Référence next.
*/
public void attach(Node node){
next = node;
node.prev = this;
}
/**
* Renvoie un booléen spécifiant si ce noeud est le premier
* d'une liste. A savoir, si la référence <i>next</i> est égale à <b>null</b>.
*
* @return <b>true</b> si ce noeud est le premier d'une liste, sinon renvoie <b>false</b>.
*/
public boolean isFirst(){
return prev == null;
}
/**
* Imprime tous les noeuds à partir de celui-ci jusqu'au dernier de la liste.
*/
public void printList(){
Node n = this;
while (n != null){
System.out.print(n + "\n");
n = n.next;
}
}
public String toString() {
return "<Node> value = " + (value != null ? value : "NULL");
}
}