Comment ajouter un Listener sur uun object quelconque?

Version imprimable

27/04/2009, 14h55
LDPDC

Comment ajouter un Listener sur uun object quelconque?

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
27/04/2009, 15h05
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

salut,

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

Par exemple:
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 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.

27/04/2009, 15h27
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...
27/04/2009, 15h41
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...
27/04/2009, 16h37
LDPDC

Citation:

Envoyé par George7

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 ^^

Citation:

Envoyé par George7

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...

Salut,

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

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

Code:

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;
	}
}

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

Code:

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

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:

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++

27/04/2009, 17h51
LDPDC

Citation:

Envoyé par adiGuba

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

Effectivement :) c'était aussi la solution qu'avait nounouk en tête, il suffisait de changer le constructeur de sa classe.... Ca marche très bien en tout cas, merci à tous pour votre aide.

LDPDC