POO sauvegarde et mise a jour

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

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:

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 (:P ) avec
Code:

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;

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

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.

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.

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:

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:

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:

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:

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:

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:

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.