Was ist der Unterschied zwischen einem Listener und Event (java)?

2 Antworten

Vom Fragesteller als hilfreich ausgezeichnet

Erläutern wir das mal anhand eines anderen Beispiels.

Sagen wir mal, du hast eine eigene Label-Klasse. Du möchtest einen Listener,(1) der das Event(2) abfängt, wenn sich der Wert des Labels ändert.

Dann würde deine Basis-Klasse zunächst so aussehen:

class MyLabel {

 private String value;

 public void setValue(String value) {
   this.value = value;
 }


 public String getValue() {
    return this.value;
 }
}

(1) Ein Listener, wie der Name schon sagt: Ist eine Klasse, besser gesagt ein Interface, dessen Aufgabe es ist "zuzuhören". 

(2) Ein Event ist ein Ereignis. Jedoch Codeseitig hat die Event-Klasse nur einen Tieferen Sinn: Informationen bereit zu stellen.

Auf obiges Beispiel bezogen benötigt man nun zwei weitere Teile. Genauer gesagt: Eine Klasse und ein Interface.

Eine Event-Klasse die du mit ausreichend Informationen Bestücken kannst: Hier eignet sich: Event-Name, Quelle, WertVorher, WertNachher.

class MyEvent {

  private String eventName;
  private Object source;
  private Object valueBefore;
  private Object valueAfter;

  public MyEvent(String eventName, Object source, Object valueBefore, Object valueAfter) {...}

  // Getter+Setter


}

Hier kannst du alle nötigen Informationen Speichern, die dem Listener später zur verfügung stehen können.

Der Listener selbst ist ein Interface, mit einer Methode, welche das Event als Parameter bekommt:

public Interface MyListener {
   public void onEvent(MyEvent event);
}

In deinem Label, in dem du das Ereignis abfangen möchtest: Ändert sich der Wert:

Solltest du die Eigenschaft Listener hinzufügen:

private MyListener onValueChangedListener;
// getter + setter

Welche du dann im setter deines Wertes ergänzen kannst:

public void setValue(String value) {
if (onValueChangedListener != null) {
    MyEvent event = new MyEvent("onValueChanged", this, this.value, value);
   onValueChangedListener.onEvent(event);

}
  this.value = value;
}

Du erstellst ein Event-Objekt mit allen nötigen Informationen: EventName, Quelle, Wert-Vorher, Wert-Nachher und gibst dann diese Information als Paramter der Methode deines Listeners mit, die du hier ausführst.

Also Reagiert der Listener auf einen Umstand und teilt nähere Informationen über ein Event-Objekt mit.

Der Event ist immer das Ereignis selbst. Der Tastendruck wird von Java als "keypress" Event interpretiert. Du hast insofern zwar recht, nur die Beschreibung als "der Event reagiert wenn eine Taste gedrückt wurde " ist ungenau von dir. Der Tastendruck IST der Event.

Der Listener hingegen ist der Lauscher, der die ganze Zeit darauf wartet, das dieses Ereignis eintritt, und dann daraufhin eine Aktion ausführt. 

Auch wichtig: nicht der Event leitet zum Listener, sondern das passiert unabhängig. Der Listener ist so lange da bis der Event eintritt. Event und Listener müssen theoretisch nichts voneinander wissen.

und wie weiß der Listener dann dass er initialisiert werden muss?

0
@AnastasiaGi

Von Java kenne ich es nicht so genau, aber von anderen Sprachen, da ist es natürlich schon so, das an einer bestimmten Stelle im Programm klargemacht werden muß das der Listener instanziiert ist, und auf welche einzutretenden Ereignisse er wartet.

In einem Webshop könnte man sich das so vorstellen:

SaveListener -> für das Speichern der Bestellung

MailListener -> für das Versenden von Mails

...

irgendwo im Programm (meist an einer zentralen Stelle) werden die Listener instanziert und ihnen mitgeteilt, das sie auf das Ereignis OrderCompleted warten sollen..

Wenn nun der User auf "jetzt kaufen" klickt, wird der Event "geworfen" und alle mit ihm verbundenen Listener der Reihe nach aufgerufen. Erst der SaveListener, der nun die Order in der Datenbank speichert, anschließend der MailListener, der eine passende Bestellbestätigungs-Email versendet.

Der Vorteil an dieser Architektur ist die gute Erweiterbarkeit. Der Chef verlangt nun, das nach dem Mailversand zusätzlich eine SMS verschickt werden soll. Statt nun den originären Programmcode jedes Mal anzupassen und zu erweitern, wird einfach ein neuer SMS Listener geschrieben und instanziiert, der nun auch auf das OrderCompleted Event warten soll. Tritt das Ereignis ein, werden nun statt der zwei, alle drei Listener nacheinander aktiv. Die Reihenfolge der Listener kann man meist durch Priorisierung beeinflussen.

Aber da kenne ich mich im speziellen Fall zu wenig in Java aus.

1

Was möchtest Du wissen?