Discussion :

[LDPDC]

Bonjour,

Mon problème actuel est d'arriver à notifier les changements sur un object quelconque au cours d'une execution d'un programme. L'object en question, pour être plus précis est un object de type Map<String,Object> dans lequel seront inscrits à intervalles de temps irréguliers des informations que j'ai besoin de récupérer en temps réel.
Après avoir lu le tutorial de ®om sur la creation de listeners, j'ai l'impression qu'il ne me sera pas possible d'ajouter un listner sur une Map sans redéfinir une classe de Map possédant la définition d'un listener.
Cela me semble étrange d'autant qu'il ne semble pas exister d'interface du genre "Listenable"....

Pouvez vous me suggérer une solution/une autre méthode?
Merci d'avance,
LDPDC

[Invité]

Salut,
Et bien non tu n'auras pas trop le choix. Tu peux étendre Hashmap en ajoutant les méthodes de gestions de listeners, mais tu ne peux pas modifier la classe déjà implémentée.
Après tu peux toujours utiliser AspectJ pour faire ca si tu veux sur la classe existante
Mais bon une classe ObservableHashmap qui étend Hashmap et qui redéfinit les méthodes que tu veux écouter tout en ajoutant les méthodes de gestion des listeners dedans, ca va encore

A plus

[nouknouk]

salut,

l'autre solution serait d'encapsuler ta HashMap dans une classe qui s'occupe de gérer les données.

Par exemple:

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
 
public class DataManager {
    public static interface Listener extends EventListener {
        public void onDataAdded(String str, Object o);
    }
 
    EventListenerList listeners;
    HashMap<String, Object> map = new HashMap<String, Object>();
 
    public DataManager() {
        /* ... */
    }
 
    public void addListener(Listener l) {
        listeners.add(Listener.class, l);
    }
    public void removeListener(Listener m) {
        listeners.remove(Listener.class, l);
    }
 
    public void addObject(String str, Object o) {
        map.put(str,o);
        for (Listener l : listeners.getListeners(Listener.class))
            l.onDataAdded(str, o);
    }

Ainsi, lorsqu'une partie de ton programme voudra ajouter une entrée, elle passera par la fonction addObject(...).

... Et toute autre partie de ton programme qui voudra être notifiée d'un ajout devra:
- implémenter l'interface DataManager.Listener
- s'enregistrer auprès de l'instance de DataManager avec addListener()
- verra sa fonction onDataAdded(...) appelée à chaque ajout.

A toi de voir en fonction de tes besoins/contraintes.

[LDPDC]

En fait je travaille sur du code généré donc je suis obligé "d'écouter" une instance de Map... S'il n'y a aucun moyen de récupérer les changements d'une Map, je ne vois pas trop de solution alternative à un thread qui viendrait récupérer l'état de la Map avec une certaine fréquence. Map étant synchronisé je pense que ça risque de pas mal ralentir l'appli.
Je ne connaissais pas du tout AspectJ et en regardant rapidement je ne vois pas trop où ça mène... Y at'il un tutorial un peu concis et clair que je puisse me faire un idée de l'interêt de cette solution?

Merci de votre aide,
LDPDC

Edit: Pour info, il existe IObervableMap/ObservableMap dans l'API d'Eclipse Ganymede...

[Invité]

AspectJ était un peu une blague, mais permet bel et bien d'ajouter des action à exécuter à l'entrée/sortie d'autres méthodes sur d'autres objets. Ceci dit si tu connais pas du tout les concepts c'est peut-être un peu lourd
Map en soit n'est pas synchronisé, c'est une interface. Hashtable est une implémentation synchronisée mais dont l'usage est désormais déconseillé (cf Javadoc).
Dans ton cas si tu ne peux vraiment pas changer le type de ta Map, il va falloir vérifier à intervalles réguliers de l'extérieur...

[LDPDC]

AspectJ était un peu une blague, mais permet bel et bien d'ajouter des action à exécuter à l'entrée/sortie d'autres méthodes sur d'autres objets. Ceci dit si tu connais pas du tout les concepts c'est peut-être un peu lourd

Oui c'est un peu lourd ^^

Map en soit n'est pas synchronisé, c'est une interface. Hashtable est une implémentation synchronisée mais dont l'usage est désormais déconseillé (cf Javadoc).
Dans ton cas si tu ne peux vraiment pas changer le type de ta Map, il va falloir vérifier à intervalles réguliers de l'extérieur...

Je ne vois effectivement pas d'autre solution...

[adiGuba]

Salut,


On peut très bien faire cela en utilisant une classe englobante :

1. On se définit une classe "event", de préférence immuable :
   

   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
   public final class ObservableMapEvent<K, V> {
    
   	private final Map<K,V> source;
   	private final K key;
   	private final V value;
    
   	public ObservableMapEvent(Map<K, V> source, K key, V value) {
   		super();
   		this.source = source;
   		this.key = key;
   		this.value = value;
   	}
    
   	public Map<K, V> getSource() {
   		return source;
   	}
   	public K getKey() {
   		return key;
   	}
   	public V getValue() {
   		return value;
   	}
   }

   
   
2. On définit notre listener et sa(ses) méthode(s) événementielles :
   

   Code :

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

   1
   2
   3
   public interface ObservableMapListener<K, V> extends EventListener {
   	public void elementAdded(ObservableMapEvent<K, V> event);
   }

   
   
3. On définit une classe qui implémente Map<K,V> en redirigeant tous les appels vers une autre instance, tout en interceptant les modifications utiles :
   

   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
   class ObservableMap<K, V> implements Map<K, V> {
    
   	private final EventListenerList listeners = new EventListenerList();
   	private final Map<K, V> inner;
    
   	public ObservableMap(Map<K, V> map) {
   		this.inner = map;
   	}
    
    
   	// On ajoute les méthodes de gestion des evenements :
    
   	public void addListener(ObservableMapListener<K, V> listener) {
   		this.listeners.add(ObservableMapListener.class, listener);
   	}
    
   	public void removeListener(ObservableMapListener<K, V> listener) {
   		this.listeners.remove(ObservableMapListener.class, listener);
   	}
    
   	protected void fireElementAdded(K key, V value) {
    
   		ObservableMapEvent<K, V> event = new ObservableMapEvent<K, V>(this, key, value);
    
   		for (ObservableMapListener listener : this.listeners.getListeners(ObservableMapListener.class)) {
   			listener.elementAdded(event);
   		}
   	}
    
   	// Puis on redirige les méthodes de Map vers notre Map,
   	// en gérant les cas où on a un evenement :
    
   	public V put(K key, V value) {
   		// On appelle la méthode "inner" :
   		V previousValue = inner.put(key, value);
   		// puis on génère l'évenement :
   		fireElementAdded(key, value);
   		return previousValue;
   	}
    
    
   	public boolean containsKey(Object key) {
   		// ici on n'a pas d'évenement, donc on appelle 
   		// directement la méthode sur "inner" :
   		return inner.containsKey(key);
   	}
    
   	// De même pour toutes les méthodes de Map :
    
   	// ...
    
   }

Le code est incomplet mais le principe est là

Cela permet une utilisation de base de la Map avec un listener. Toutefois cela est limité aux modif direct sur la Map (il faudrait modifier plus en profondeur pour gérer les itérateurs).

A noter qu'une telle classe doit surement déjà exister dans les jakarta-collections ou les google-collections...

a++