EventListener

  Dieser Ansatz definiert ein generisches Eventmodell. Die Events können durch den Benutzer durch Erzeugung einer Klasse selbst spezifiziert werden. Der Vorgang, ein M-Bean mit einem EventListener zu versehen und diesen durch einen Client zu überwachen ist durch mehrere Schritte festgelegt:

1. Spezifikation Event-Klasse
   Wenn ein benutzerdefinierter Typ von Events gewünscht wird, dann ist eine eigene Klasse zu entwickeln, welche die Art des Events darstellt. Die Klasse ist als Unterklasse von java.util.EventObject zu implementieren. Innerhalb dieser Klasse können Properties verwendet werden, die bei Empfang und Auswertung des Events zusätzliche Informationen enthalten können (z.B. Laufzeit des Objekts innerhalb eines Netzes). Die Erstellung einer Klasse ermöglicht die Verwendung mehrerer Konstruktoren. Dadurch kann die Art und Struktur der Event-Klasse spezifischen Erfordernissen angepaßt werden. Ein Beispiel für eine Event-Klasse ist nachfolgend dargestellt:

   package tis20.impl;
   
   import java.util.EventObject;
   
   public class NetworkParmsImplEvent extends EventObject {
     
     /**
      * Create a NetworkParmsImplEvent object. The source of the event
      * as well as the value of the "NbChanges" property needs
      * to be specified.
      */
     public NetworkParmsImplEvent(NetworkParmsImpl source) {
       super(source);
     }
   
     public NetworkParmsImplEvent(NetworkParmsImpl source
                                  , String ComputerName) {
       super(source);
     }
   
     /**
      * Returns the version of this class.
      */
     public String getClassVersion() {
       return (sccs_id);
     }
   
     /**
      * Version of the implementation
      */
     private static final 
       String sccs_id = "@(#)NetworkParmsImplEvent.java 1.0 01/01/99";
   }

2. Spezifikation Listener-Interface
   Nun muß ein Interface entwickelt werden, das als M-Bean in das CMF des Agenten eingefügt werden muß, um eventuelle Events abzufangen. Die Realisierung als M-Bean macht diesen Listener durch die Adapter und damit den verschiedenen Möglichkeiten des Managements zugreifbar. Da das Listener-Objekt durch eine Client-Applikation in das CMF integriert wird, ist mit MOGEN (vgl. 3.3) ein Interface und Stub zu erzeugen. Dieses Interface ist von java.util.EventListener abzuleiten und es sind die Methoden bekanntzugeben, welche bei Erhalt eines Events angewendet werden sollen. Eine Listener-Klasse kann folgendermaßen aussehen:

   package tis20.impl;
   
   import java.util.*;
   
   /**
    * A NetworkParmsImpl event listener interface. 
    * This interface needs to be implemented
    * in order to receive
    * 
    * NetworkParmsImpl events emitted by the
    * NetworkParmsImplEvent M-bean.
    *
    * @version     1.0     01/01/99
    * @author      Harald Knoechlein
    */
   
   public interface NetworkParmsImplListener extends java.util.EventListener {
     
     public void handleEvent1(NetworkParmsImplEvent evt);
     
     public void handleEvent2(NetworkParmsImplEvent evt);
   }

3. Entwicklung Client-Applikation
   Um das Listener-Objekt innerhalb des CMF des Agenten integrieren zu können, ist ein Client zu entwickeln. Die Events, welche später durch dieses Objekt gesendet werden, können allerdings von allen Clients oder Agenten, welche dieses Listener-Objekt spezifiziert haben, empfangen werden.
   Es ist zu beachten, daß Agenten selbst ebenso die Möglichkeit besitzen, Listener-Objekte für ihre eigenen aber auch M-Beans anderer Agenten anzulegen.
4. Ausführen der Client Applikation und Anlegen des Listener-Objekts
   Um dieses Objekt zu integrieren, muß zunächst der Agent über einen Adapter kontaktiert werden. Gegebenenfalls ist ein Paßwort und Login zu verwenden, falls dies der Adapter erfordert.
   Danach muß das M-Bean, welches überprüft werden soll, mit dessen Objektnamen ausgewählt und als Managed-Objekt gehandhabt werden. (Dies geschieht durch einen Cast auf die MO-Klasse).
   Ist nun das M-Bean ermittelt, so kann durch Verwendung der add<M-Bean-Klasse>Listener Methode der Listener dem CMF hinzugefügt werden. Es ist zu beachten, daß diese Methode, ebenso wie die Methode für das Entfernen des Listeners von dem M-Bean zu Verfügung gestellt werden muß. Falls solche Methoden zum M-Bean hinzugefügt werden sollen, so muß das M-Bean gestoppt, um den erforderlichen Quellcode erweitert und wieder dem Agenten hinzugefügt werden (Restart). Es kann allerdings in Erwägung gezogen werden, generell diese Methoden zu den M-Beans hinzuzunehmen und sich damit eine Hintertür offen zu halten.
   Ausschnittsweise kann ein solcher Vorgang innerhalb der Client-Applikation folgendermaßen implementiert werden:

   ...
   // connect to Adaptor ...
     AdaptorClient adaptor = new AdaptorClient();
     adaptor.connect(null, agentHost, agentPort, ServiceName.APT_RMI);
   ...
   // Get the instance of the NetworkParmsImpl m-bean in the 
   // remote object server.
     String NetworkParmsImplClass = "NetworkParmsImpl";
     ObjectName NetworkParmsImplName 
       = new ObjectName(domain + ":tis20.impl.NetworkParmsImpl");
     tis20.impl.NetworkParmsImplMO NetworkParmsImpl 
       = (tis20.impl.NetworkParmsImplMO) 
         ((Vector)adaptor.getObject(NetworkParmsImplName, null)).firstElement();
   ...
   // Create an event listener.
     ClientListener listener= new ClientListener();
   ... 
   // Register a listener with the remote event source.
     NetworkParmsImpl.addNetworkParmsImplListenerMO(listener);
   ...

5. Senden von Events durch Agent
   Treten bei den ``überwachten'' Properties Veränderungen ein (beispielsweise das Hinzufügen eines neuen Tabelleneintrags oder das Setzen einer MIB-Variablen), werden Events an alle Listener gesandt. Das Senden muß ebenso wie die Methoden zum Hinzufügen und Entfernen von Listener-Objekten innerhalb der überwachten M-Bean-Klasse durch Methodenaufrufe realisiert werden. Ein Aufruf bei Veränderung einer MIB-Variablen kann beispielsweise so aussehen:

   ...
   /**
    * Setter for the "ComputerName" variable.
    */
   public  void setComputerName(String x) throws SnmpStatusException {
      String oid =  "1.3.6.1.4.1.2206.5.1.1.1.1.0";
      ComputerName = x;
      nativeBase.setNative(tools.ConvertTools.String2Int(oid), x);
      // Send an event !
      //
      NetworkParmsImplEvent event
        = new NetworkParmsImplEvent(this, new String(ComputerName));
      deliverChange(event);
   }
   ...
   /**
    * Send an event to all the registered listeners.
    *
    * @param event the event to emmit.
    *
    */
   private void deliverChange(NetworkParmsImplEvent event) {
     Vector listeners;
     int n;
     synchronized (this) {
       listeners = (Vector)NetworkParmsImplListeners.clone();
       n = listeners.size();
       if (n == 0) return;
     }
     Vector symbols = new Vector();
     for (int i = 0; i < listeners.size(); i++) {
       NetworkParmsImplListener NetworkParmsImplListener 
         = (NetworkParmsImplListener)listener.elementAt(i);
       NetworkParmsImplListener.handleEvent1(event);
     }
   }
   ...

   Es wird ein Event-Objekt mit entsprechendem Konstruktor instantiiert und mittels der deliverChange-Methode an alle Listener geschickt. Eine Empfangsüberprüfung findet nicht statt. Eine Möglichkeit wäre, in den Objekten, die Events erhalten, Methoden zur Versendung von ``EmpfangsEvents'' vorzusehen. Diese Event-Klasse ist jedoch selbst zu implementieren, es wird kein expliziter Mechanismus von JDMK unterstützt. Wie aus dem obigen Beispiel zu ersehen ist, wird das EventHandler-Interface von JDMK verwendet. Dieses Interface ist für die Weiterleitung und Verarbeitung der Events zuständig.
6. Entfernen von Event-Listener-Objekten
   Ist ein Überwachen des M-Beans nicht mehr erforderlich, so werden die Listener-Objekte wieder entfernt. Dies geschieht durch die Methode remove<M-Bean-Klasse>Listener, welche von der M-Bean-Klasse zur Verfügung gestellt werden muß.

Die Verwendung von Listenern ist in Abbildung 3.6 dargestellt.