Exemples de la façon dont Java implémente des mécanismes basés sur les événements

Cet article présente principalement l'implémentation d'un mécanisme événementiel utilisant Java. L'éditeur pense que c'est assez bon, je vais donc le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur pour y jeter un œil

En raison des exigences du projet, il est nécessaire de fournir un ensemble de bibliothèques de classes pour Java qui prennent en charge les mécanismes pilotés par les événements, qui peuvent implémenter des mécanismes d'événements et de délégation similaires à C#. Comme nous le savons tous, le langage Java lui-même et sa bibliothèque standard ne fournissent pas d'interfaces pertinentes pour les mécanismes événementiels, bien qu'il existe des classes associées dans Swing (je ne pense pas qu'il appartienne à la bibliothèque standard, car généralement personne ne l'utilise :) pour prendre en charge ce mécanisme pour implémenter le traitement des événements, mais il est après tout couplé à l'interface graphique, et il semble un peu délicat à utiliser dans d'autres types d'applications et manque de polyvalence. Par conséquent, il est nécessaire d'implémenter un ensemble de bibliothèques générales de classes de mécanismes Java basées sur les événements, puis de l'appliquer aux applications Java générales, bien que ce ne soit pas difficile :)

Examinons d'abord le pilotage événementiel de C# Comment écrire un mécanisme. Le mot-clé event fourni en C# peut être facilement utilisé pour définir un événement, puis en ajoutant une fonction de traitement d'événement à l'événement (en C#, un délégué est généralement utilisé pour référencer une fonction), et le traitement approprié peut être appelé lorsque le l'événement est déclenché. Les fonctions sont des processus pilotés par des événements. Par exemple :

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

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

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

//触发事件
Click();

Le code ci-dessus est un exemple simple du mécanisme événementiel implémenté en C#. On peut voir que tout cela est très simple. vient du langage C#. La commodité apportée par la couche (en fait CLR). Malheureusement, Java n'offre pas une telle commodité et nécessite des humains pour le mettre en œuvre. L'article suivant fournira deux méthodes pour implémenter des mécanismes basés sur les événements, à titre de référence uniquement.

Modèle d'observateur

Le modèle d'observateur est un modèle de conception couramment utilisé. L'observateur s'abonne d'abord à l'objet observé (sujet) de cette manière, une fois. un certain changement se produit dans le sujet (Sujet), le changement sera notifié à l'observateur (Observateur).

Ce modèle de conception peut être utilisé dans le mécanisme événementiel. L'événement est équivalent à l'objet observé (Sujet). Une fois l'événement déclenché, la fonction de traitement d'événement sera appelée. la fonction de traitement (en C# Le délégué) peut être considérée comme un observateur. Par conséquent, les fonctions ci-dessus peuvent être implémentées comme suit.

/*事件类*/
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();

Le code Java ci-dessus implémente un mécanisme simple piloté par les événements. Le principe est très simple et c'est un cas d'application typique du modèle d'observateur.

Utiliser la réflexion

Le langage Java fournit une fonction de réflexion puissante, qui peut obtenir divers composants d'une classe au moment de l'exécution (tels que le nom de la classe, le membre de la classe fonctions, attributs de classe, etc.) et opérer sur eux. La réflexion est utilisée ci-dessous pour implémenter un mécanisme simple piloté par les événements.

/*事件处理类*/
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();
}

Le code ci-dessus montre le mécanisme événementiel implémenté à l'aide de la réflexion. L'avantage d'utiliser le mécanisme de réflexion est qu'il a une forte évolutivité, comme dans mon événement. fonction de gestion Vous pouvez introduire un paramètre formel de EventArgs, afin que l'événement lui-même puisse avoir des paramètres, afin que l'événement puisse transporter plus d'informations. La fonction de traitement d'événement réécrit est comme indiqué dans le code ci-dessous :

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();
  }
}

Ça vous semble familier ? C'est vrai, lors de l'écriture d'un formulaire Winform en C#, la fonction de gestion des événements (fonction onClick dans le code) générée automatiquement par Visual studio a presque la même forme, mais cette fois nous l'implémentons en Java.

Bien sûr, en plus des deux méthodes mentionnées ci-dessus qui peuvent implémenter le mécanisme événementiel de Java, il existe d'autres méthodes, comme l'utilisation des classes internes de Java. L'auteur a également écrit quelques exemples de code, j'ai gagné. Je n'entre pas dans les détails ici, je vous le laisse plus tard.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!