Ecouteur d'évenements en Java

Version imprimable

03/07/2007, 20h21
demcoul

Ecouteur d'évenements en Java

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

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

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

;)

05/07/2007, 08h58
hydraland

Salut,

Si tu veux faire ce que tu demandes je te conseille d'utiliser les Aspect. Personellement j'utilise AspectJ.

A+
Hydraland
05/07/2007, 09h12
®om

http://rom.developpez.com/java-listeners
05/07/2007, 20h02
demcoul

Merci, je farai les essais.

A+
05/07/2007, 20h24
CyberChouan

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.
05/07/2007, 20h48
demcoul

Est il possible d'avoir un exemple ?
05/07/2007, 22h41
CyberChouan

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
06/07/2007, 01h49
bouye

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...
06/07/2007, 09h14
®om

Citation:

Envoyé par CyberChouan

1) Dans la classe que tu veux suivre, tu déclares une variable de classe de type "PropertyChangeSupport"

Que pensez-vous de PropertyChangeListener/PropertyChangeSupport?

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