Stellen Sie kurz vor, wie Sie mit Java einen ereignisgesteuerten Mechanismus implementieren

In diesem Artikel wird hauptsächlich die Implementierung eines ereignisgesteuerten Mechanismus mit Java vorgestellt. Der Herausgeber findet ihn recht gut, daher werde ich ihn jetzt mit Ihnen teilen und als Referenz verwenden. Folgen wir dem Editor, um einen Blick darauf zu werfen

Aufgrund der Projektanforderungen ist es notwendig, eine Reihe von Klassenbibliotheken für Java bereitzustellen, die ereignisgesteuerte Mechanismen unterstützen, die Ereignis- und Delegate-Mechanismen ähnlich wie C# implementieren können. Wie wir alle wissen, bieten die Java-Sprache selbst und ihre Standardbibliothek keine relevanten Schnittstellen für ereignisgesteuerte Mechanismen, obwohl es in Swing verwandte Klassen gibt (ich glaube nicht, dass sie zur Standardbibliothek gehören, da sie im Allgemeinen niemand verwendet). :) um diesen Mechanismus zum Implementieren der Ereignisverarbeitung zu unterstützen, aber er ist schließlich mit der GUI gekoppelt und scheint bei der Verwendung in anderen Arten von Anwendungen etwas umständlich zu sein und es mangelt ihm an Vielseitigkeit. Daher ist es notwendig, eine universelle Klassenbibliothek für ereignisgesteuerte Java-Mechanismen zu implementieren und diese dann auf universelle Java-Anwendungen anzuwenden, obwohl dies nicht schwierig ist :)

Lassen Sie uns zunächst den Ereignistreiber von C# untersuchen. Wie man schreibt ein Mechanismus. Das in C# bereitgestellte Ereignisschlüsselwort kann einfach zum Definieren eines Ereignisses verwendet werden. Durch Hinzufügen einer Ereignisverarbeitungsfunktion zum Ereignis (in C# wird im Allgemeinen ein Delegat zum Verweisen auf eine Funktion verwendet) kann die entsprechende Verarbeitung aufgerufen werden, wenn die Ereignis wird ausgelöst. Funktionen sind ereignisgesteuerte Prozesse. Zum Beispiel:

//定义事件和对应的委托
public event MyDelegate Click;
public delegate void MyDelegate();

//定义委托
void OnClick(){
  console.writeline("you just clicked me!");
}

//将委托与事件关联
Click += OnClick;

//触发事件
Click();

Der obige Code ist ein einfaches Beispiel für den in C# implementierten ereignisgesteuerten Mechanismus stammt aus der Sprache von C#, die durch die Ebene (eigentlich CLR) bereitgestellt wird. Leider bietet Java diesen Komfort nicht und erfordert die Implementierung durch Menschen. Der folgende Artikel stellt lediglich als Referenz zwei Methoden zur Implementierung ereignisgesteuerter Mechanismen vor.

Beobachtermuster

Das Beobachtermuster abonniert das beobachtete Objekt (Subjekt) zunächst einmal Wenn im Subjekt (Subject) eine bestimmte Änderung auftritt, wird die Änderung dem Beobachter (Observer) mitgeteilt.

Dieses Entwurfsmuster kann im ereignisgesteuerten Mechanismus verwendet werden. Das Ereignis entspricht dem beobachteten Objekt (Subjekt). Sobald das Ereignis ausgelöst wird, wird das Ereignis angezeigt Die Verarbeitungsfunktion (in C# der Delegat) kann als Beobachter betrachtet werden. Daher können die oben genannten Funktionen wie folgt implementiert werden.

/*事件类*/
public Event {
  //与事件相关的事件处理函数
  public ArrayList<Callback> callbackList;
  
  //事件触发函数
  public void emit(){
    for(Callback cb : callbackList){
      cb.run();
    }
  }
  
  //注册事件处理函数
  public registerCallback(Callback cb){
    callbackList.add(cb);
  }
}

/*事件处理函数类*/
public interface Callback {
  void run();
}

public OnClick implements Callback {
  //函数
  public void run(){
    System.out.println("you just clicked me!");
  }
  
  
/*实现事件驱动*/
Event e = new Event(); 
//将OnClick事件处理函数注册到事件中
e.registerCallback(new OnClick()); 
//触发事件
e.emit();

Der obige Java-Code implementiert einen einfachen ereignisgesteuerten Mechanismus. Das Prinzip ist sehr einfach und es handelt sich um einen typischen Anwendungsfall des Beobachtermusters.

Reflexion verwenden

Die Java-Sprache bietet eine leistungsstarke Reflexionsfunktion, mit der verschiedene Komponenten einer Klasse zur Laufzeit abgerufen werden können (z. B. Klassenname, Klassenmitglied). Funktionen, Klassenattribute usw.) und bearbeiten sie. Im Folgenden wird Reflection verwendet, um einen einfachen ereignisgesteuerten Mechanismus zu implementieren.

/*事件处理类*/
public class EventHandler {
  //事件源
  private Object sender;
  //事件处理函数名称（用于反射）
  private String callback;
  
  public EventHandler(Object sender, String callback){
    this.sender = sender;
    this.callback = callback;
  }
  
  //事件触发
  public void emit(){
  Class senderType = this.sender.getClass();
  try {
    //获取并调用事件源sender的事件处理函数
    Method method = senderType.getMethod(this.callback);
    method.invoke(this.sender);
    } catch (Exception e2) {
      e2.printStackTrace();
    }
  }
}


/*事件源*/
public class Button(){
  /*可以在此设置Button类的相关属性，比如名字等*/
  private String name;
  ...
  
  
  //事件处理函数
  public void onClick(){
    System.out.println("you just clicked me!");
  }
}
  
  
/*实现事件驱动机制*/
Button b = new Button();
if(/*收到按钮点击信号*/){
  EventHandler e = new EventHandler(b, "onClick");
  e.emit();
}

Der obige Code zeigt den mithilfe von Reflektion implementierten ereignisgesteuerten Mechanismus. Der Vorteil der Verwendung des Reflexionsmechanismus besteht darin, dass er eine starke Skalierbarkeit aufweist, wie in meinem Fall Verarbeitungsfunktion Sie können einen formalen Parameter von EventArgs einführen, sodass das Ereignis selbst Parameter haben kann, sodass das Ereignis mehr Informationen enthalten kann. Die neu geschriebene Ereignisverarbeitungsfunktion ist wie im folgenden Code dargestellt:

public class EventArgs {
  //参数
  String p1;
  Integer p2;
  ...
  
}

//onClick事件处理函数改写
public void onClick(Object sender, EventArgs e){
  //参数e提供更多的信息
  System.out.println("Hello, you clicked me! " + e.p1 + e.p2);
}

//触发函数emit改写
public void emit(EventArgs e){
Class senderType = this.sender.getClass();
try {
  //获取并调用事件源sender的事件处理函数
  Method method = senderType.getMethod(this.callback, this.getClass(), e.getClass());
  method.invoke(this.sender, this.sender, e);
  } catch (Exception e2) {
    e2.printStackTrace();
  }
}

Kommt Ihnen das bekannt vor? Richtig, die Ereignisbehandlungsfunktion (onClick-Funktion im Code), die Visual Studio beim Schreiben eines Winform-Formulars in C# automatisch für Sie generiert, hat fast die gleiche Form, aber dieses Mal implementieren wir sie in Java.

Natürlich gibt es zusätzlich zu den beiden oben genannten Methoden, die den ereignisgesteuerten Mechanismus von Java implementieren können, beispielsweise die Verwendung der internen Klassen von Java. Ich habe auch einige Beispielcodes geschrieben Ich gehe hier nicht auf Details ein, das überlasse ich Ihnen später.

Das obige ist der detaillierte Inhalt vonStellen Sie kurz vor, wie Sie mit Java einen ereignisgesteuerten Mechanismus implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!