Sérialization ...

ju

03/04/2005 à 19:29

Le dimanche 03 avril 2005 à 19:17 +0200, Hamiral a chanté :

Bonjour,

Je suis en train de programmer une application dans laquelle je dois
pouvoir sérialiser des objets. Je pensais à le faire en implémentan t
l'interface Serializable, mais une question m'est venue à l'esprit :
Si jamais, lors de futures versions de mon logiciel, mon objet est amen é
à être modifié, par ajouts ou suppressions de membres, je ne pourra i
plus charger des objets qui auraient été sérialisés par une pré cédente
version ?
bingo, tu montres du doigt la principale faiblesse de la sérialization,

en plus du fait que ca prend de la place sur le disque comparé aux
données brutes

Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?
oui, c'est une idée qui a fait ses preuves, le xml et java, ca va bien

ensemble

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?
Moi je te conseille de gérer tout ca avec jdom : www.jdom.org

Un ptit fichier .jar a inclure dans ton projet, et ca roule.
Ca repose sur le parseur de SAX, c'est relativement simple a
implémenter, tu peux générer du xml, ou en lire. La documentation est
dispo sur le site, avec des exemples. Tu peux pas te louper.

Merci d'avance,
de rien

Hervé AGNOUX

04/04/2005 à 08:41

Hamiral wrote:

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

Non, ton raisonnement est faux, mais oui, tu peux tout de même te tourner
vers la sérialization xml si tu veux.

Pour te protéger contre les changements de version de classe, il faut
spécifier le "serialVersionUID".

Des infos là dessus :

"Versioning of Serializable Objects"
http://java.sun.com/j2se/1.4.2/docs/guide/serialization/spec/version.html#wp9419

Des exemples :

http://java.sun.com/j2se/1.4.2/docs/guide/serialization/examples/index.html

Avec ça tu es paré pour 90% des changements de classes que tu pourras
imaginer, pour le reste l'API de sérialisation te permettra de les
résoudre.

Pour le coté XML, je te conseille les classes java.beans.XMLDecoder /
Encoder.

--
Hervé AGNOUX
http://www.diaam-informatique.com

Pif

04/04/2005 à 09:24

Si jamais, lors de futures versions de mon logiciel, mon objet est amené
à être modifié, par ajouts ou suppressions de membres, je ne pourrai
plus charger des objets qui auraient été sérialisés par une précédente
version ?

Si tu peux forcer la conversion en indiquant le numéro de version de
classe, c'est un long, c'est pas compliqué, mais ca prend du temps...

Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?

ca marche pas mal... mais si tu change les membres, tu aboutis au meme
problèmes de compatibilité des versions que précédemment !

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

pour moi, la sérialisation, c'est du "dump" mémoire, c'est pas de
l'archivage.. alors tout dépend de l'application. Si l'objectif est de
sauvegarder et archiver des données, alors il faut utiliser des outils
de persistence ou du XML (meme parsé manuellement...).

Sinon, la sérialisation, c'est une petite bidouille bien pratique et
automatisée...

Merci d'avance,

Hamiral

Arnaud Berger

04/04/2005 à 09:35

Bonjour,

Pour reprendre la remarque précédente sur l'ID de version de classe, il
s'agit d'ajouter dans la classe
une instruction du type :

private static final long serialVersionUID = -6849794470754667710L;

où la valeur (ici, c'est celle de la classe String) est obtenue en faisant :

"serialver nomDeLaClasse" (serialver est un executable dans bin).

Arnaud

"Hamiral" a écrit dans le message news:
42502515$0$15275$

Bonjour,

Je suis en train de programmer une application dans laquelle je dois
pouvoir sérialiser des objets. Je pensais à le faire en implémentant
l'interface Serializable, mais une question m'est venue à l'esprit :
Si jamais, lors de futures versions de mon logiciel, mon objet est amené
à être modifié, par ajouts ou suppressions de membres, je ne pourrai
plus charger des objets qui auraient été sérialisés par une précédente
version ? Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

Merci d'avance,

Hamiral

fg

04/04/2005 à 12:24

Sinon, la sérialisation, c'est une petite bidouille bien pratique et
automatisée...

Je la vois également comme ca : quand au sein d'un programme, on veut
enregistrer des données autre part qu'en mémoire, sans se casser trop la
tête (par exemple, il m'est arrivé de manipuler des centaines de grosses
images : au bout d'un moment, j'en sérialize quelques-unes dont je sais que
je n'aurai pas besoin tout de suite, et je les reprends plus tard....), ou
bien pour transmettre des données par Socket par exemple, sans se créer tout
un "protocole" maison de transmission des membres
(stream.writeObject(MyRequest), où MyRequest est un objet avec tout plein de
propriétés, et le tour est joué....)

Par contre, pour une "sauvegarde pérenne", préfère en effet le XML, ou, si
tu veux pas faire gros, écris les champs (dont tu connais la taille...) dans
un ordre précis. C'est moins propre, mais si la taille du fichier est un
critère important, ca peut jouer...

Goulou.

Trognon Patrice

04/04/2005 à 15:52

Hamiral wrote:

Bonjour,

Je suis en train de programmer une application dans laquelle je dois
pouvoir sérialiser des objets. Je pensais à le faire en implémentant
l'interface Serializable, mais une question m'est venue à l'esprit :
Si jamais, lors de futures versions de mon logiciel, mon objet est amené
à être modifié, par ajouts ou suppressions de membres, je ne pourrai
plus charger des objets qui auraient été sérialisés par une précédente
version ? Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

Merci d'avance,

Hamiral

Bonjour,

Déjà traité dans ce NG il me semble, un excellent produit
avait été conseillé a l'époque db4object http://www.db4o.com/
il y a une version Java.

J'ai testé le produit en question c'est vraimetn du bonheur
et pas de problème comme celui dont tu parles il gere ca très
bien.

voici le samplecode :

package com.db4o.f1.chapter1;

public class Pilot {
private String name;
private int points;

public Pilot(String name,int points) {
this.name=name;
this.points=points;
}

public int getPoints() {
return points;
}

public void addPoints(int points) {
this.points+=points;
}

public String getName() {
return name;
}

public String toString() {
return name+"/"+points;
}
}

package com.db4o.f1.chapter1;

import java.io.File;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.f1.Util;

public class FirstStepsExample {
public static void main(String[] args) {
new File(Util.YAPFILENAME).delete();
ObjectContainer dbÛ4o.openFile(Util.YAPFILENAME);
try {
storeFirstPilot(db);
storeSecondPilot(db);
retrieveAllPilots(db);
retrievePilotByName(db);
retrievePilotByExactPoints(db);
updatePilot(db);
deleteFirstPilotByName(db);
deleteSecondPilotByName(db);
}
finally {
db.close();
}
}

public static void storeFirstPilot(ObjectContainer db) {
Pilot pilot1=new Pilot("Michael Schumacher",100);
db.set(pilot1);
System.out.println("Stored "+pilot1);
}

public static void storeSecondPilot(ObjectContainer db) {
Pilot pilot2=new Pilot("Rubens Barrichello",99);
db.set(pilot2);
System.out.println("Stored "+pilot2);
}

public static void retrieveAllPilots(ObjectContainer db) {
Pilot proto=new Pilot(null,0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByName(ObjectContainer db) {
Pilot proto=new Pilot("Michael Schumacher",0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByExactPoints(ObjectContainer db) {
Pilot proto=new Pilot(null,100);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void updatePilot(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
found.addPoints(11);
db.set(found);
System.out.println("Added 11 points for "+found);
retrieveAllPilots(db);
}

public static void deleteFirstPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}

public static void deleteSecondPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Rubens Barrichello",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}
}

--
Cordialement,

Patrice Trognon
http://wwW.javadevel.com

Hamiral wrote:

Bonjour,

Je suis en train de programmer une application dans laquelle je dois
pouvoir sérialiser des objets. Je pensais à le faire en implémentant
l'interface Serializable, mais une question m'est venue à l'esprit :
Si jamais, lors de futures versions de mon logiciel, mon objet est amené
à être modifié, par ajouts ou suppressions de membres, je ne pourrai
plus charger des objets qui auraient été sérialisés par une précédente
version ? Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

Merci d'avance,

Hamiral

Bonjour,

Déjà traité dans ce NG il me semble, un excellent produit
avait été conseillé a l'époque db4object http://www.db4o.com/
il y a une version Java.

J'ai testé le produit en question c'est vraimetn du bonheur
et pas de problème comme celui dont tu parles il gere ca très
bien.

voici le samplecode :

package com.db4o.f1.chapter1;

public class Pilot {
private String name;
private int points;

public Pilot(String name,int points) {
this.name=name;
this.points=points;
}

public int getPoints() {
return points;
}

public void addPoints(int points) {
this.points+=points;
}

public String getName() {
return name;
}

public String toString() {
return name+"/"+points;
}
}

package com.db4o.f1.chapter1;

import java.io.File;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.f1.Util;

public class FirstStepsExample {
public static void main(String[] args) {
new File(Util.YAPFILENAME).delete();
ObjectContainer dbÛ4o.openFile(Util.YAPFILENAME);
try {
storeFirstPilot(db);
storeSecondPilot(db);
retrieveAllPilots(db);
retrievePilotByName(db);
retrievePilotByExactPoints(db);
updatePilot(db);
deleteFirstPilotByName(db);
deleteSecondPilotByName(db);
}
finally {
db.close();
}
}

public static void storeFirstPilot(ObjectContainer db) {
Pilot pilot1=new Pilot("Michael Schumacher",100);
db.set(pilot1);
System.out.println("Stored "+pilot1);
}

public static void storeSecondPilot(ObjectContainer db) {
Pilot pilot2=new Pilot("Rubens Barrichello",99);
db.set(pilot2);
System.out.println("Stored "+pilot2);
}

public static void retrieveAllPilots(ObjectContainer db) {
Pilot proto=new Pilot(null,0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByName(ObjectContainer db) {
Pilot proto=new Pilot("Michael Schumacher",0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByExactPoints(ObjectContainer db) {
Pilot proto=new Pilot(null,100);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void updatePilot(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
found.addPoints(11);
db.set(found);
System.out.println("Added 11 points for "+found);
retrieveAllPilots(db);
}

public static void deleteFirstPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}

public static void deleteSecondPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Rubens Barrichello",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}
}

--
Cordialement,

Patrice Trognon
http://wwW.javadevel.com

Vous avez filtré cet utilisateur ! Consultez son message

Hamiral wrote:

Bonjour,

Je suis en train de programmer une application dans laquelle je dois
pouvoir sérialiser des objets. Je pensais à le faire en implémentant
l'interface Serializable, mais une question m'est venue à l'esprit :
Si jamais, lors de futures versions de mon logiciel, mon objet est amené
à être modifié, par ajouts ou suppressions de membres, je ne pourrai
plus charger des objets qui auraient été sérialisés par une précédente
version ? Dans ce cas, peut-être devrais-je plutôt me tourner vers XML
pour sauvegarder mes objets ?

Est-ce que mon raisonnement est bon ? Si oui, que me conseillez-vous
pour créer et charger des fichiers XML ?

Merci d'avance,

Hamiral

Bonjour,

Déjà traité dans ce NG il me semble, un excellent produit
avait été conseillé a l'époque db4object http://www.db4o.com/
il y a une version Java.

J'ai testé le produit en question c'est vraimetn du bonheur
et pas de problème comme celui dont tu parles il gere ca très
bien.

voici le samplecode :

package com.db4o.f1.chapter1;

public class Pilot {
private String name;
private int points;

public Pilot(String name,int points) {
this.name=name;
this.points=points;
}

public int getPoints() {
return points;
}

public void addPoints(int points) {
this.points+=points;
}

public String getName() {
return name;
}

public String toString() {
return name+"/"+points;
}
}

package com.db4o.f1.chapter1;

import java.io.File;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;
import com.db4o.f1.Util;

public class FirstStepsExample {
public static void main(String[] args) {
new File(Util.YAPFILENAME).delete();
ObjectContainer dbÛ4o.openFile(Util.YAPFILENAME);
try {
storeFirstPilot(db);
storeSecondPilot(db);
retrieveAllPilots(db);
retrievePilotByName(db);
retrievePilotByExactPoints(db);
updatePilot(db);
deleteFirstPilotByName(db);
deleteSecondPilotByName(db);
}
finally {
db.close();
}
}

public static void storeFirstPilot(ObjectContainer db) {
Pilot pilot1=new Pilot("Michael Schumacher",100);
db.set(pilot1);
System.out.println("Stored "+pilot1);
}

public static void storeSecondPilot(ObjectContainer db) {
Pilot pilot2=new Pilot("Rubens Barrichello",99);
db.set(pilot2);
System.out.println("Stored "+pilot2);
}

public static void retrieveAllPilots(ObjectContainer db) {
Pilot proto=new Pilot(null,0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByName(ObjectContainer db) {
Pilot proto=new Pilot("Michael Schumacher",0);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void retrievePilotByExactPoints(ObjectContainer db) {
Pilot proto=new Pilot(null,100);
ObjectSet resultÛ.get(proto);
Util.internalListResult(result);
}

public static void updatePilot(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
found.addPoints(11);
db.set(found);
System.out.println("Added 11 points for "+found);
retrieveAllPilots(db);
}

public static void deleteFirstPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Michael Schumacher",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}

public static void deleteSecondPilotByName(ObjectContainer db) {
ObjectSet resultÛ.get(new Pilot("Rubens Barrichello",0));
Pilot found=(Pilot)result.next();
db.delete(found);
System.out.println("Deleted "+found);
retrieveAllPilots(db);
}
}

--
Cordialement,

Patrice Trognon
http://wwW.javadevel.com

Pif

05/04/2005 à 09:42

on m'a parlé de castor récemment... http://castor.codehaus.org/index.html

quelqu'un connait ca vaut quoi ?

et JSX ne semble plus open-source ?? quelqu'un a des nouvelles ?

Lequel choisir parmis les 2 ou 3 .... ?

Sérialization ...

7 réponses

Veuillez sélectionner un problème