[Serialisation] methode générique ?

Version imprimable

Bonjour,

Suite à ce cour sur la sérialisation, j'ai souhaité le mettre en application et je me posais une question.

Est-il possible de faire une fonction qui permettrait de sérialiser n'importe quel objet qui implémenterai le serializable ?

quelque chose du genre :

Code:

public void serializer(Object o){

Prenons deux classes. Avion et Bateau.

Actuellement, j'utiliserai ceci pour faire la sérialisation :

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
 
    public void serializerAvion(Avion a){
        try {
            // ouverture d'un flux de sortie vers le fichier "avion.serial"
            FileOutputStream fos = new FileOutputStream("avion.serial");
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(a);
                // on vide le tampon
                oos.flush();
                System.out.println(a + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }

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
 
    public void serializerBateau(Bateau b){
        try {
            // ouverture d'un flux de sortie vers le fichier "bateau.serial"
            FileOutputStream fos = new FileOutputStream("bateau.serial");
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(b);
                // on vide le tampon
                oos.flush();
                System.out.println(b + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }

Si j'avais 36 classes, je serais obligé de décrire 36 méthodes... pour rien >.<

Comment pourrais-je rendre cette sérialisation générique ?

Merci à vous :)

25/01/2009, 17h37
herch

Utiliser les generics??

Salut,
juste une petite remarque, les deux méthodes ne diffèrent que du type d'objet à sérialiser, peut être que faire une méthode générique ferait l'affaire, quelque chose du genre

Code:

public <T> void serializerAvion(T t, String fichierSortie)

.
Je ne sais si j'ai bien compris la question, mais bon, j'espère que c'est ce que tu cherchais.
25/01/2009, 17h40
Deallyra

xD

En effet, je demandais s'il pouvait être utilisé une méthode générique.

T représente quelque chose de particulier ? Une classe spécifique ou justement le terme générique ?
25/01/2009, 17h44
Deallyra

Nickel, c'est bien ce que je souhaitais ^^

Mais si tu peux me donner un ou deux renseignements sur <T> :)

Resalut,
tu sais, c'est toi qui a plein d'étoiles :mouarf:

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
public <T> void serializerObjet(T t, String fichierSortie)
{
try {
            // ouverture d'un flux de sortie vers le fichier "avion.serial"
            FileOutputStream fos = new FileOutputStream(fichierSortie);
 
            // création d'un "flux objet" avec le flux fichier
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            try {
                // sérialisation : écriture de l'objet dans le flux de sortie
                oos.writeObject(t);
                // on vide le tampon
                oos.flush();
                System.out.println(t + " a ete serialise");
            } finally {
                //fermeture des flux
                try {
                    oos.close();
                } finally {
                    fos.close();
                }
            }
        }
        catch(IOException ioe) {
            ioe.printStackTrace();
        }
    }
 
}

T représente la classe qui sera donné en paramètre; par exp, si on met :

Code:

serializerObjet(Avion a, "avion.serial");

T sera remplacé par Avion, et ainsi de suite.
Rmq: j'ai pas testé le code ci-dessus, mais je crois que c'est correcte ( suis trop paresseux :oops:)
Voilà, j'espère que ça aidera.

25/01/2009, 19h41
Deallyra

Nan mais j'avais bien modifié mon code xD

Je voulais juste savoir à quoi correspondait le T :)

Citation:

java.lang
Class Class<T>

java.lang.Object
extended by java.lang.Class<T>

Type Parameters:
T - the type of the class modeled by this Class object. For example, the type of String.class is Class<String>. Use Class<?> if the class being modeled is unknown.

All Implemented Interfaces:
Serializable, AnnotatedElement, GenericDeclaration, Type

__________________________

public final class Class<T>
extends Object
implements Serializable, GenericDeclaration, Type, AnnotatedElement

Instances of the class Class represent classes and interfaces in a running Java application. An enum is a kind of class and an annotation is a kind of interface. Every array also belongs to a class that is reflected as a Class object that is shared by all arrays with the same element type and number of dimensions. The primitive Java types (boolean, byte, char, short, int, long, float, and double), and the keyword void are also represented as Class objects.

Class has no public constructor. Instead Class objects are constructed automatically by the Java Virtual Machine as classes are loaded and by calls to the defineClass method in the class loader.

The following example uses a Class object to print the class name of an object:

void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}

It is also possible to get the Class object for a named type (or for void) using a class literal (JLS Section 15.8.2). For example:

System.out.println("The name of class Foo is: "+Foo.class.getName());

Bonjour,

Je ne vois pas pourquoi dans la solution proposée, vous utilisez les Generics. Les méthodes du premier message ne retournent rien. De plus l'appelant de la méthode connait l'objet à sérialiser donc il n'y a pas besoin de le renvoyer.

Donc pour faire simple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public static void serializer(Serializable o, String fichier) throws IOException { try { // try/catch pour logger l'exception ObjectOutput os = new ObjectOutputStream(new FileOutputStream(fichier)); try { // try/finally pour bien fermer os os.writeObject(o); } finally { os.close(); } } catch (IOException e) { e.printStackTrace(); throw e; } }
Je rajouterai que l'appel à flush n'est pas nécessaire : la méthode close l'appelle. De plus la fermeture du ObjectOutputStream entraine la fermeture du FileOutputStream => il n'est donc pas nécessaire de fermer les deux explicitement.

Gronono.

26/01/2009, 10h24
herch

Salut,
tu as peut être raison, mais je crois qu'il est tout de même mieux d'utiliser les generics. Avec les generics, on peut restreindre les types passés en argument en mettant par exp

Code:

<T extends UneClasse> void serializerObjet(T t, String fichierSortie)

je crois que c'est mieux, et c'est généralement déconseillé de passer en argument des Object, et je crois que ça s'applique aussi pour Serializable.

Salut,

Citation:

Envoyé par gronono

De plus la fermeture du ObjectOutputStream entraine la fermeture du FileOutputStream => il n'est donc pas nécessaire de fermer les deux explicitement.

Oui et non... Si on veut vraiment pinailler il faudrait séparer les deux, car les ObjectInput/OutputStream ont la particularité d'effectuer des accès I/O dans leurs constructeurs, ce qui fait que leurs constructeurs peuvent remonter une exception ce qui empêcherait la fermeture du FileStream pourtant bien ouvert...

Mais bon c'est vraiment pour pinailler...

Citation:

Envoyé par herch

tu as peut être raison, mais je crois qu'il est tout de même mieux d'utiliser les generics. Avec les generics, on peut restreindre les types passés en argument en mettant par exp

Code:

<T extends UneClasse> void serializerObjet(T t, String fichierSortie)

Dans ce cas précis, les Generics n'apportent rien par rapport à un typage standard des paramètres. En clair ton code ci dessous n'apporte rien par rapport à ceci :

Code:

void serializerObjet(UneClasse t, String fichierSortie)

Citation:

Envoyé par herch

je crois que c'est mieux, et c'est généralement déconseillé de passer en argument des Object, et je crois que ça s'applique aussi pour Serializable.

Pourquoi ?
Si une méthode accepte tout type d'objet c'est logique d'utiliser Object... de même que Serializable si la méthode accepte n'importe quel objet Serializable...

Les Generics sont utiles lorsqu'ils permettent de limiter le type de plusieurs paramètres et/ou du type de retour selon plusieurs autres paramètres.

A la rigueur on pourrait s'en servir lors de la désérialisation pour cacher le cast :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public static <T> T unserialize(String fichier) throws IOException, ClassNotFoundException { FileInputStream fis = new FileInputStream(fichier); try { ObjectInputStream ois = new ObjectInputStream(fis); try { @SuppressWarnings("unchecked") T result = (T) ois.readObject(); return result; } finally { ois.close(); } } finally { fis.close(); } }
Ce qui permettrait d'utiliser la méthode sans cast :
Code:

1 2 3 String string = unserialize("fichier1"); Number number = unserialize("fichier1"); MyObject object = unserialize("fichier1");
(par contre cela risque de générer des ClassCastException à l'exécution si les types ne correspondent pas ;))

a++

26/01/2009, 11h05
herch

Salut,
la question était de pouvoir utiliser une seule méthode pour sérialiser plusieurs objets

Citation:

Dans ce cas précis, les Generics n'apportent rien par rapport à un typage standard des paramètres. En clair ton code ci dessous n'apporte rien par rapport à ceci :

Code:

void serializerObjet(UneClasse t, String fichierSortie)

je crois que c'est pas vraiment la réponse à la question, et je crois que les generics sont bien à leur place ici.
La question qui se pose est : Doit-on utiliser les generics ou simplement passer un Object ou un Serializable à la méthode serializerObjet??