Version imprimable
bonjour à tous,
j'ai une classe qui étends Observable. Cette classe est persistée dans mon application.
si je lui ajoute des observateurs par le biais de la méthode addObserver(),et que je la persiste, pour ensuite la récupérer ,je perds la liste des observateurs enregistrés.
Pourquoi les observateurs ne sont pas persistés ?
Il peut y avoir plusieurs raisons à cela... Comment régénères-tu tes observateurs ? Es-tu sûr que ce sont ceux qui ont été mémorisés ?...
En général on ne fait pas de persistance des observateurs, car il est justement difficile, et peu approprié, de les retrouver.
Souvent par exemple dans les GUI on ne mémorise que le niveau "modèle", et pas le niveau "vue". À chaque lancement le niveau vue est recréé par le code, puisque c'est toujours le même, et ce code enregistre la vue en tant qu'observateur auprès des modèles (ou l'inverse).
justement, dans mon cas l'observateur et l'observé sont 2 classes persistantes :la classe Note et Releves de Notes.
Si un changement survient sur la classe Note, elle va de ce fait informer la classe Releves de Notes.
l'installation des observateurs se fait dés que les instances des 2 classes sont crées.
Mais dés que je désérialise les 2 instances, je perds la mémorisation des observateurs. peut etre parceque l'adresse mémoire de Note change à chaque désérialisation
Absolument : tu as trouvé la cause.
Si tu construis ton appli en voulant tout sérialiser, je veux dire aussi bien observateurs qu'observés, il te faut un système qui te permette de retrouver, et non plus recréer, tous les objets sérialisés.
La sérialisation d'un objet sauvegarde tous les objets qu'il contient. Lorsque tu déserializes un objet, tous ces objets contenus sont recréés, dans le respect des références d'origine : si jamais ton objet contenait deux objets identiques, les objets resteront identiques après la désérialization, mais plus identique aux objets d'origine.
Est ce que cette phrase veut dire, que si j'ajoute des observateurs à un objet et que celui ci contient déjà une liste de ceux là (agrégation), ces objets vont être sérialisés deux fois ?Citation:
Envoyé par gifffftane
Je me paume un peu dans tes questions ! Pourquoi voudrais-tu rajouter des observateurs dans un objet qui contient déjà une liste de ceux là, comme tu dis ?
Admettons que tu aies un objet contenant une liste d'observateurs. Dans cet objet, tout est sérializable. Donc la sérialization de cet objet sérializera ces observateurs.
Lorsque tu vas désérializer cet objet, il retrouvera sa liste d'observateurs... mais, en l'état, cette liste ne servira plus à rien, à moins de les retrouver, et de redonner à chacun sont rôle dans ton application. C'est cette opération qui est prise de tête, fort peu éléguante et qui fait que habituellement on ne sérialize pas les observateurs, du moins de cette façon.
pour avoir un joli effet d'interfaces (voir l'image)Citation:
Pourquoi voudrais-tu rajouter des observateurs dans un objet qui contient déjà une liste de ceux là, comme tu dis ?
Dès que j'introduit une note, elle notifie la Classe Releve de notes et celle ci va voir si toutes les notes ont introduites:
si c'est le cas ,la moyenne est calculée et affichée.
classe Relevés de notes:
classe Note:Code:
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
29public class ReleveNotes2 extends Observable implements Observer,Serializable { private Etudiant etudiant; private Semestre semestre; private Map<Module,Note> notes; ... private void initReleveNotes() { // initialisation des notes notes = new HashMap<Module,Note>(); for (Module module :semestre.getModules()) { Note nouvNote = new Note(semestre.getEpreuve(module)); nouvNote.addObserver(this); notes.put(module,nouvNote); } .... } public void update(Observable o, Object arg) { if (isComplet()) { calculerMoyenneGenerale(); calculerMoyenneFinAnnee(); calculerMoyenneApresRattrapage(); } else moyenneGenerale = -1f; setChanged(); notifyObservers(); }
En fait, j'ai triché. j'ai utilisé ce pattern juste pour la notification, et éviter de garder une référence vers Releves De Notes dans chaque instance de Note.Code:
2
3
4
5
6
7
8public class Note extends Observable implements Serializable { ... public void setNoteExamen(float note) { if (this.noteExamen != note){ this.noteExamen = note; notifier(); } }
Donc, y a redondance dans ma façon de faire à cause de ça :Citation:
Admettons que tu aies un objet contenant une liste d'observateurs. Dans cet objet, tout est sérializable. Donc la sérialization de cet objet sérializera ces observateurs.
C'est ce que je craignaisCode:
2