Bonjour tout le monde,
Je voulais savoir s'il est possible d'écrire un écouteur d'évènement qui puisse savoir si une méthode quelconque vient de s'exécuter et en recuperer son nom, les noms de ses paramètres.
merci.
Version imprimable
Bonjour tout le monde,
Je voulais savoir s'il est possible d'écrire un écouteur d'évènement qui puisse savoir si une méthode quelconque vient de s'exécuter et en recuperer son nom, les noms de ses paramètres.
merci.
si c'est pour une de tes propres classes oui.
il faut faire ton propre EvenObject et EventListener.
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
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 /* * TreeEvent.java * * Created on 3 juillet 2007, 19:48 * * To change this template, choose Tools | Template Manager * and open the template in the editor. */ package altersig.lib.gui.nav; import java.util.EventObject; import org.geotools.map.MapContext; import org.jdesktop.swingx.JXTreeTable; /** * * @author eclesia */ public class TreeEvent extends EventObject{ private MapContext mapcontext; private int fromindex; private int toindex; public TreeEvent(JXMapContextTree treetable, MapContext mapcontext, int fromindex, int toindex) { super(treetable); this.mapcontext = mapcontext; this.fromindex = fromindex; this.toindex = toindex; } public TreeEvent(JXMapContextTree treetable, MapContext mapcontext, int position) { super(treetable); this.mapcontext = mapcontext; this.fromindex = position; this.toindex = position; } public MapContext getMapContext() { return this.mapcontext; } public int getFromIndex() { return this.fromindex; } public int getToIndex() { return this.toindex; } }
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package altersig.lib.gui.nav; import java.util.EventListener; /** * * @author eclesia */ public interface TreeListener extends EventListener{ public void ContextAdded(TreeEvent event) ; public void ContextRemoved(TreeEvent event); public void ContextActivate(TreeEvent event); public void ContextMoved(TreeEvent event); }
si c'est pour une classe de la JVM, tout les ecouteurs dont tu as besoin peuvent deja etre implemente. (actionlistenr,focuslistener...etc...)
Hello,
Les écouteurs, en java, s'implémentent selon un modèle proche du pattern Observer...
Dans l'idée, tu as une liste d'abonnés (List<MyListener>) qui est notifiée lorsque tel ou tel événement se produit (via appel d'une méthode).
Ensuite, pour avoir tous les paramètres qui sont passés à myMethod, il faut soit modifier la signature de "onMyMethod" et ajouter les paramètres, soit les encapsuler dans les instances de "MyClassEvent"-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 // Interface des écouteurs. Implémentent onMyMethod, qui est levé à chaque fois que "myMethod" est appelé sur une instance de MyClass. interface MyClassListener { void onMyMethod(MyClassEvent event); } // Paramètre passé lors de la levée d'un événement class MyClassEvent extends EventObject { MyClassEvent(Object source) { super(source); } } // Classe qui produit des événements class MyClass { private List<MyClassListener> listeners = new ArrayList<MyClassListener>(); // Ajoute un écouteur void addMyClassListener(MyClassListener listener) { listeners.add(listener); } // Supprime un écouteur void removeMyClassListener(MyClassListener listener) { listeners.remove(listener); } // Génère l'événement vers tous les écouteurs private void fireOnMyMethod(MyClassEvent event) { for (MyClassListener l : listeners) { l.onMyMethod(event); } } // Méthode qui est écoutée public void myMethod() { fireOnMyMethod(new MyClassEvent(this)); // work here... } }
;)
Salut,
Si tu veux faire ce que tu demandes je te conseille d'utiliser les Aspect. Personellement j'utilise AspectJ.
A+
Hydraland
Merci, je farai les essais.
A+
Pour la même problématique, j'avais utilisé ProperyChangeSupport et PropertyChangeListener. C'est très simple à mettre en place.
L'inconvénient est qu'il faut invoquer "manuellement" le PropertyChangeSupport pour notifier les changements qui t'intéressent.
Est il possible d'avoir un exemple ?
1) Dans la classe que tu veux suivre, tu déclares une variable de classe de type "PropertyChangeSupport"
2) Tu crées des méthodes:
- d'enregistrement des listeners
- de désenregistrement des listeners
- de propagation des changements
=> ces méthodes ne sont que des relais qui invoquent les mêmes méthodes de ton instance de PropertyChangeSupport
3) Les classes qui doivent être informées implémentent une interface Listener et s'inscrivent à l'instanciation à la classe qu'elle doivent suivre
4) La classe à suivre invoque la méthode de propagation des changements quand elle a une information pertinente pour les classes réceptrices
La question etant somme toute tres generique et pas trop liee a Swing/AWT (a priori) je serai tente de dire d'aller voir du cote de l'API de deboggage...
Que pensez-vous de PropertyChangeListener/PropertyChangeSupport?Citation:
Envoyé par CyberChouan
Moi je trouve que c'est trop "runtime", quand on implémente PropertyChangeListener on ne sait pas ce que l'on peut écouter (c'est juste des tests de Strings), contrairement à un vrai Listener où il y a une méthode par évènement, mais bien sûr c'est plus long à écrire...