Discussion :

[Nasky]

Bonjour

J'ai un client qui attend la réception d'une chaine de la part du serveur. Cette attente se fait dans un thread (dans la méthode run()) lancé dans une autre classe pour ne pas géner le reste du programme. Le reste du programme c'est l'interface graphique.
Comment faire pour que dès qu'il y a récéption d'une ligne provenant du serveur, je l'affiche dans un composant Swing?
Une solution serait d'avoir une référence sur le composant Swing dans la classe lançant le thread. Ou une autre solution serait de mettre mon composant Swing en static pour y accéder avec le nom de classe.
Donc des solutions j'en ai. Mais existe-t-il une autre façon de faire plus propre?
Parce que par exemple, la première méthode, je ne la trouve pas propre parce que pourquoi une classe Connexion qui gére la connexion aurait une référence sur un composant de l'interface graphique? Je ne trouve pas ça "normal".
Pour la seconde méthode, j'aimerais bien l'éviter mais bon, si y'a pas d'autres solutions....
Merci

Nas'

[bulbo]

Tu fais comme dans Swing, ton objet Connexion accepte des ConnexionListeners par exemple et tu as une methode messageReceived par exemple qui sera appellee a chaque message recu.

C'est ce qu'il y a de plus propre pour faire ca a mon avis.

Bulbo

[adiGuba]

Salut,


En fait tu es obligé d'avoir dans ton thread la référence de l'objet qui va traiter les données. Toutefois c'est vrai qu'il n'est pas très propre ni très réutilisable d'utiliser une référence en "dur"...

Mais existe-t-il une autre façon de faire plus propre?

Pour moi la meilleure solution est d'utiliser un Listener, comme c'est souvent le cas avec Swing/AWT...


Cf la FAQ : Comment créer son propre Listener ?



Par exemple dans ton cas, tu te crée un objet MyDataEvent qui contiendra les information à passer. Cela peut tout simplement se résumer à ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class MyDataEvent extends EventObject {
 
    private final String data;
 
    public MyDataEvent(Thread source, String data) {
        super(source);
        this.data = data;
    }
 
    public String getData() {
        return this.data;
    }
 
}

Ensuite tu te crée une interface qui décriera les différents "évenements" possible, par exemple :

Code :

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

1
2
3
4
5
public interface MyDataListener extends EventListener {
 
    public void dataReceived(MyDataEvent evt);
 
}

Enfin dans ton Thread (qui est la source des évenements), tu rajouteras des méthodes pour ajouter/supprimer des Listeners, ainsi qu'une ou plusieurs méthodes qui devront appeller les méthodes de tous les listeners enregistrées...

Cela pourrait donner :

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
public class MonThread extends Thread {
 
    protected EventListenerList listenerList = new EventListenerList();
 
 
    public void addMyDataListener (MyDataListener l) {
            this.listenerList.add (MyDataListener.class, l);
    }
 
    public void removeMyDataListener (MyDataListener l) {
            this.listenerList.remove (MyDataListener.class, l);
    }
 
    protected void fireMyDatareceived(String data) {
        MyDataListener[] listeners = (MyDataListener[]) this.listenerList.getListeners(MyDataListener.class);
 
        MyDataEvent e = new MyDataEvent (this, data);
        for (int i = listeners.length-1; i>=0; i--) {
            listeners[i].dataReceived(e);
        } 
    }
 
 
    public void run() {
 
        // Ton code de lecture de la socket :
        while (true) {
 
            String data = ....;
            // ...
 
            // Et après chaque reception de donnée :
            fireMyDatareceived(data); 
 
        }
 
    }
 
}

Et ainsi à chaque reception de données, la méthode fireMyDatareceived() appellera implicitement la référence d'un objet qui traitera les données (un composant Swing qui implémenterait l'interface par exemple).


Dans cet exemple le traitement des données est effecuté dans le thread de lecture. Il peut être préférable d'utiliser un autre thread dans le listener. En particulier s'il s'agit de mettre une interface à jours où l'on utilisera l'EDT :

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
public class MonComposant extends JLabel implements MyDataListener {
 
    public MonComposant() {
        super("<empty>");
    }
 
    public void dataReceived(final MyDataEvent evt) {
        SwingUtilities.invokeLater(new Runnable(){
            public void run() {
                setText(evt.getData());
            }
        });
    }
 
}

a++

[Xavinou]

Tu peux aussi tout simplement utiliser l'implémentation fournie par java du design pattern Observer / Observable.