Discussion :

[storm_3000]

Bonjour, je viens de faire un programme de base.
l'utilisateur dans la version 1 du programme pouvais rajouter des personnes.
une personne = ( nom et prénom )...

maintenant j'ai la version 2 et l'on peut rajouter une adresse, numéro de téléphone. mais comment faire pour passer les données de la version 1 à 2 ?

Pour sauvegarder, j'utilise les IO ( OjectOutputStream )... ( est que ceci est compatible pour tout les OS ? merci )


merci de votre aide

[Lethal]

Tu ne saurais plus charger tes anciennes personnes vu que ta classe personne à changé. Donc l'ancienne n'existe plus.

Pourquoi ne pas faire un package old avec ton ancienne classe Personne.

Et ajouter un constructeur a ta nouvelle classe Personne dans le genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public Personne(old.Personne oldp)
{
    this.nom = oldp.getNom();
    this.prenom = oldp.getPrenom();
}

Quand tu charge ton fichier tu charges des Object
puis tu peux savoir si c'est une vielle personne ( ) avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Personne p;
Object objetcharge = ois.readObject();
if (objetcharge instanceof(old.Personne))    p = new Personne((old.Personne)objetcharge);
else                                         p = (Personne)objetcharge;

[divxdede]

En passant par un package "old" ne fonctionnera pas puisque la classe serializee ne sera pas la meme.

genre dans le fichier ce sera org.xxxx.Personne alors que la classe à charger dans l'application sera org.old.xxxx.Personne

[had35]

Oui, le principe est là (utiliser un "constructeur par copie"), mais c'est vrai qu'il n'y a pas besoin de créer un package spécifique pour dupliquer l'ancienne librairie, pourvu que l'ancienne librairie soit importée dans le nouveau projet.

[spekal]

Il est possible de se débrouiller en captant le flux de déserialization, mais c'est un peu compliqué. Dans l'immédiat, il faut surtout penser, un peu tard, à mettre un serialVersionUID, comme le dit cet avertissement pour java 5, qui est aussi valable pour les javas < 5.

[divxdede]

Bien l'idée est de creer un projet chargeant via differents ClassLoader les anciennes versions des classes et les nouvelles et effectuer la migration.

Je donne un exemple (écrit à la va vite avant d'aller au taf)

1) Création d'u projet avec une classe Personne tel que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package testser;
 
import java.io.Serializable;
 
/**
 * V1
 * @author André Sébastien
 */
public class Personne implements Serializable
{
    private String nom = null;
    private String prenom = null;
 
    public Personne()
    { }
 
    /** Creates a new instance of Personne */
    public Personne(String nom,String prenom)
    {
        this.setNom(nom);
        this.setPrenom(prenom);
    }
 
    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;
    }
}

Dans ce projet je fais une main-class effectuant une serialization de cette version de Personne (V1)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package testser;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.net.URLClassLoader;
 
/**
 *
 * @author André Sébastien
 */
public class Main1 {
 
    /** Creates a new instance of Main */
    public Main1() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Personne personne = new Personne("Dupond","Jean");
 
        ObjectOutputStream oos = null;
        try
        {
            oos = new ObjectOutputStream( new FileOutputStream( new File("c:\\personne_v1.ser") ) );
            oos.writeObject(personne);
        }
        catch(Exception e) { e.printStackTrace(); }
        finally
        {
            try
            {
                if( oos != null ) oos.close();
            }
            catch(Exception e){ /* do nothing */ }
        }
    }
}

Je créer une classe dans ce projet qui m'aidera plustard à la deserializer

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
package testser;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.ObjectInputStream;
 
/**
 *
 * @author André Sébastien
 */
public class Deserializer {
 
    /** Creates a new instance of Deserializer */
    public Deserializer() {
    }
 
    public Object deserialize(String className, File file)
    {
        try
        {
            Class classObject = getClass().getClassLoader().loadClass(className);
            if( classObject == null ) return null;
 
            ObjectInputStream ois      = new ObjectInputStream( new FileInputStream( file) );
            Object            object   = ois.readObject();
            ois.close();
 
            return object;
        }
        catch(Exception e){ e.printStackTrace(); return null; }
    }
}

J'execute le Main1 pour créer le fichier "personne_v1.ser"
Je genere le Jar du projet contenant la classe Personne
J'appelle le jar "TestSer_v1.jar"

Je modifie la classe Personne pour ajouter une date de naissance tel que:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package testser;
 
import java.io.Serializable;
import java.util.Calendar;
 
/**
 * V2
 * @author André Sébastien
 */
public class Personne implements Serializable
{
    private String nom = null;
    private String prenom = null;
    private Calendar dateNaissance = null;
 
    public Personne()
    { }
 
    /** Creates a new instance of Personne */
    public Personne(String nom,String prenom)
    {   this(nom,prenom,null); }
 
    /** Creates a new instance of Personne */
    public Personne(String nom,String prenom,Calendar naissance)
    {
        this.setNom(nom);
        this.setPrenom(prenom);
        this.setDateNaissance(naissance);
    }
 
    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 Calendar getDateNaissance() {
        return dateNaissance;
    }
 
    public void setDateNaissance(Calendar dateNaissance) {
        this.dateNaissance = dateNaissance;
    }
}

Je genere le projet et j'appelle le jar "TestSer_v2.jar"


Bien faisons un récapitulatif !!!

- j'ai TestSer_v1.jar possédant la classe Personne en V1
- j'ai TestSer_v2.jar possédant la classe Personne en V2
- j'ai personne_v1.ser fichier contenant une Personne V1 sérialisée

Je créér un nouveau projet pour coder l'outil qui va faire le passage d'une version à l'autre

Voici la classe faisant la migration:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
package testupgser;
 
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Calendar;
import java.util.GregorianCalendar;
 
/**
 *
 * @author André Sébastien
 */
public class Main {
 
    /** Creates a new instance of Main */
    public Main() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
 
        try
        {
            // Création d'un classLoader pour charger l'ancienne version de Personne
            URLClassLoader classLoaderV1 = new URLClassLoader( new URL[]{ new File("c:\\TestSer_v1.jar").toURI().toURL() } );
 
            // Chargement de la classe Deserializer à partir du classLoader 'V1'
            Class  deserializerClass = classLoaderV1.loadClass("testser.Deserializer");
 
            // Utilisation du Deserializer, on passe par un deserializer chargé par le classLoaderV1 afin que la méthode "latestUserDefinedLoader" de ObjectInputStream utilise notre classLoader V1
            Object deserializer      = deserializerClass.newInstance();
            Object personneV1        = deserializerClass.getMethod("deserialize",String.class,File.class).invoke(deserializer,"testser.Personne", new File("c:\\personne_v1.ser") );
 
            // Récuperation du Nom et du Prenom
            String nom    = (String)personneV1.getClass().getMethod("getNom",(Class[])null).invoke(personneV1,(Object[])null);
            String prenom = (String)personneV1.getClass().getMethod("getPrenom",(Class[])null).invoke(personneV1,(Object[])null);
            System.out.println("Nom = " + nom);
            System.out.println("Prenom = " + prenom);
 
            // Création d'une date de naissance arbitraire
            Calendar naissance = new GregorianCalendar(1978,8,14);
 
            // Création d'un objet Personne au format V2
            URLClassLoader classLoaderV2   = new URLClassLoader( new URL[]{ new File("c:\\TestSer_v2.jar").toURI().toURL() } );
 
            // Instanciation d'une personne V2
            Class          classPersonneV2 = classLoaderV2.loadClass("testser.Personne");
            Object         personneV2      = classPersonneV2.newInstance();
 
            // Mise en place des données dans l'objet Personne V2
            classPersonneV2.getMethod("setNom",String.class).invoke(personneV2,nom);
            classPersonneV2.getMethod("setPrenom",String.class).invoke(personneV2,prenom);
            classPersonneV2.getMethod("setDateNaissance",Calendar.class).invoke(personneV2,naissance);
 
            // Sauvegarde
            ObjectOutputStream oos = null;
            try
            {
                oos = new ObjectOutputStream( new FileOutputStream( new File("c:\\personne_v2.ser") ) );
                oos.writeObject(personneV2);
            }
            catch(Exception e2) { e2.printStackTrace(); }
            finally
            {
                try
                {
                    if( oos != null ) oos.close();
                }
                catch(Exception e2){ /* do nothing */ }
            }
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
 
    }
 
}

On lance ce programme de migration que créer un fichier personne_v2.ser

Si on reprends le projet précedent et qu'on ecrit une main-class Main2 qui lit le nouveau "personne_v2.ser", il ne devrait y avoir aucun soucis:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
package testser;
 
import java.io.FileInputStream;
import java.io.ObjectInputStream;
 
/**
 *
 * @author André Sébastien
 */
public class Main2 {
 
    /** Creates a new instance of Main2 */
    public Main2() {
    }
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        try
        {
            ObjectInputStream ois = new ObjectInputStream( new FileInputStream("c:\\personne_v2.ser" ) );
            Personne personne = (Personne)ois.readObject();
            ois.close();
 
            System.out.println("Nom = " + personne.getNom() );
            System.out.println("Prenom = " + personne.getPrenom() );
            System.out.println("Naissance = " + personne.getDateNaissance() );
        }
        catch(Exception e)
        { e.printStackTrace(); }
    }
 
}

C'est un peu long et laborieux, mais ce mécanisme est fonctionnel.