web-dev-qa-db-fra.com

À quoi sert un écouteur en Java?

J'ai cherché cela en ligne, mais je n'ai pas trouvé d'explication adéquate à ce qu'il fait exactement. Ce que j'ai vu était une interface Java et elle a été passée comme paramètre dans une autre classe en tant que "Listener". Les gens ont ajouté divers écouteurs à une liste et les ont tous appelés par une seule méthode.

Je ne sais pas pourquoi je l'utiliserais. Quelqu'un peut-il se soucier d'expliquer?

Ceci est mon message d'aide d'origine où quelqu'un m'a dit d'utiliser des écouteurs.

Lien

javalistener
11
Jacob Macallan

Dans l'exemple de code que vous avez lié le KillMonsterEventListener

public interface KillMonsterEventListener {
    void onKillMonster ();
}

fournit aux utilisateurs de votre API un moyen de vous dire quelque chose comme ceci:

Voici un morceau de code. Lorsqu'un monstre est tué, rappelez-le. Je déciderai quoi faire.

C'est une façon pour moi de brancher mon code à un moment précis de votre flux d'exécution (en particulier, au moment où un monstre est tué). Je peux faire quelque chose comme ça:

yourClass.addKillMonsterEventListener(
    new KillMonsterEventListener() {
        public onKillMonster() {
            System.out.println("A good monster is a dead monster!");
        }
    }
);

Quelque part ailleurs, je pourrais ajouter un autre auditeur:

yourClass.addKillMonsterEventListener(
    new KillMonsterEventListener() {
        public onKillMonster() {
            monsterCount--;
        }
    }
);

Lorsque votre code parcourt la liste des auditeurs pour tuer un monstre, c'est-à-dire.

for (KillMonsterEventListener listener : listeners) {
    listener.onKillMonster()
}

mes deux extraits de code (c'est-à-dire le monsterCount-- et l'impression) s'exécutent. Ce qui est bien, c'est que votre code est complètement découplé du mien: il n'a aucune idée de ce que j'imprime, de la variable que je décrémente, etc.

12
dasblinkenlight

Listener est une forme courante d'implémentation du observateurdesign patter en Java. Cette technique est également appelée callback , qui est un terme provenant du monde des langages procéduraux.

Les observateurs s'enregistrent par le observable , qui à son tour rappelle le observateurs chaque fois qu'un événement se produit ou quand ils doivent être informés de quelque chose.

De nombreuses bibliothèques de frameworks jouent le rôle de l'observable, par exemple:

  • Vous vous enregistrez (c'est-à-dire votre implémentation de l'interface d'écoute) en tant qu'écouteur de messages entrants dans un middleware de messagerie.
  • Vous vous enregistrez en tant qu'écouteur de certaines modifications apportées par l'utilisateur dans le système d'exploitation.
  • Vous vous enregistrez en tant qu'écouteur d'événements GUI, tel qu'un bouton sur lequel vous avez cliqué.

Exemple en Java:

Partie 1 - L'entité observable

import Java.util.LinkedList;
import Java.util.List;

public class Observable {
    private List<Observer> observers;

    public Observable() {
        observers = new LinkedList<>();
    }

    public void addObsever(Observer observer) {
        observers.add(observer);
    }

    private  void notifyObservers(String whatHappened) {
        for (Observer observer : observers) {
            observer.onSomethingHappened(whatHappened);
        }
    }

    public void doSomeStuff() {
        // ...
        // Do some business logic here.
        // ...

        // Now we want to notify all the listeners about something.
        notifyObservers("We found it!");

        // ...
        // Do some business logic here
        // ...
    }
}

Partie 2 - L'interface observateur/auditeur

public interface Observer {
    void onSomethingHappened(String whatHappened);
}

Partie 3 - Implémentation de base de l'interface observateur/auditeur

public class MyObserver implements Observer {
    @Override
    public void onSomethingHappened(String whatHappened) {
        System.out.println(whatHappened);
    }
}

Partie 4 - Tout mettre ensemble

public class Main {
    public static void main(String[] args) {

        // Create the observable.
        Observable myObservable = new Observable();

        // Create the observers (aka listeners).
        Observer myObserverA = new MyObserver();
        Observer myObserverB = new MyObserver();

        // Register the observers (aka listeners).
        myObservable.addObsever(myObserverA);
        myObservable.addObsever(myObserverB);

        myObservable.doSomeStuff();

    }
}

Et le résultat sur la sortie standard sera:

We found it!
We found it!
10
MartinCz

Cela fait partie d'un paradigme de programmation appelé programmation événementielle . Les objets envoient des messages à d'autres objets à certaines occasions, par exemple lorsqu'ils changent. Ceci est souvent utilisé dans la programmation GUI. Chaque widget GUI est implémenté par une classe. Lorsque vous souhaitez gérer par exemple clics de souris de l'utilisateur, vous ajoutez un écouteur (également appelé gestionnaire d'événements) au widget GUI. Lorsque l'utilisateur clique sur le widget, le widget envoie l'événement aux auditeurs enregistrés pour que l'application puisse répondre au clic de la souris. Cela sépare le cadre (la classe de widget GUI) et le code d'application. (Dans certains cadres d'interface graphique, tels que Swing, vous pouvez ajouter un nombre arbitraire d'écouteurs à un objet; dans d'autres, vous ne pouvez en spécifier qu'un.)

Dans d'autres domaines également, la programmation événementielle est utile. Vous pourriez vouloir observer un objet (voir Modèle d'observateur ). Par exemple, une collection qui prend en charge cela peut envoyer un événement si son contenu change. Si vous devez effectuer un traitement si cela se produit, vous pouvez vous ajouter en tant qu'écouteur à cette classe. L'alternative serait d'appeler le post-traitement à chaque fois que vous ajoutez un élément à la collection, mais cela est sujet aux erreurs.

6
Hoopje

L'écouteur de servlet est utilisé pour écouter les événements dans un conteneur Web, par exemple lorsque vous créez une session ou placez un attribut dans une session ou si vous passivez et activez dans un autre conteneur, pour vous abonner à ces événements, vous pouvez configurer l'écouteur dans web.xml , par exemple, HttpSessionListener.

Les écouteurs sont déclenchés pour une demande physique réelle qui peut être attachée aux événements de votre serveur d'applications. Avec les écouteurs, vous pouvez suivre les modifications au niveau de l'application, de la session, du cycle de vie, des changements d'attributs, etc.

Vous pouvez surveiller et réagir aux événements du cycle de vie d'un servlet en définissant des objets écouteurs dont les méthodes sont appelées lorsque des événements de cycle de vie se produisent.

Voici le blog pour Servener Listener http://array151.blogspot.in/2016/12/servlet-listener.html

1
Sunil Garg

Utilisez un écouteur pour laisser un autre code vous informer des "conditions"/"événements". Par exemple, un "écouteur de souris" pourrait être appelé si la souris avait été déplacée/cliquée/glissée. Cela dépend de votre application pourquoi elle prévoit des auditeurs.

0
Christopher Oezbek

Les auditeurs font un peu de travail lorsqu'un événement se produit. Ils sont appelés "écouteurs d'événements". Des événements comme le clic, le survol, etc. Par exemple, nous avons l'interface ActionListener en Java. Il appelle la méthode actionPerformed () lorsqu'un événement se produit. Vous pouvez vous référer http://Java.about.com/od/a/g/Actionlistener.htm pour plus d'informations.

0
Sachin Tanna

Les écouteurs sont utilisés pour informer des changements d'état. Vous pouvez penser aux auditeurs la plupart du temps en tant qu'observateurs, donc chaque fois que quelque chose d'intéressant se produit, votre auditeur sera appelé.

Vous pouvez en savoir plus sur les modèles dans Java sur les sites Web suivants:

http://www.journaldev.com/1739/observer-design-pattern-in-Java-example-tutorial

http://www.developer.com/Java/implementing-behavioral-patterns-in-Java.html

0
jakubbialkowski