Instrumentierung von Javabeans und Javabibliotheken

1.

Instrumentierung des Startbuttons Der StartButton, der den Beginn einer BTA bildet, wird instrumentiert durch:

• Einbringen von standardisierten Get- und Setmethoden für den Wert BTA_name:
  

  String getBTA_name()
  void setBTA_name(String BTA_name)
  

• Übergabe des durch Customizing erhaltenen Anwendungsidentifikation BTA_name in der Methode MousePressed an das Messobjekt MessBean durch:
  
  • MessBean.BTA_start( BTA_name, BeanName,thread);
    
  Die Methode MousePressed wird durch Anklicken des Buttons mit der Maus aktiviert und startet die BTA.
  

Da der Kontrollfluss zu dem Startbutton zurückkehrt, wird dann in diesem Baustein mit rem_control_flow der Kontrollfluss beim Messobjekt abgemeldet.

2.

Instrumentierung des Präsentationsbausteins

Die Methode

MessBean.BTA_end

wird im Präsentationsbaustein aufgerufen, wenn dort das Ergebnis präsentiert wird. Wichtig ist diese Instrumentierung des Präsentationsbausteins für die Berechnung der Antwortzeit, die vom Agenten durchgeführt wird (siehe Abbildung ).

 

Abbildung: Ermittlung der Antwortzeit 

3.

Instrumentierung der Beanbox

In der Entwicklungsumgebung Beanbox werden die Hook-Programme instrumentiert, die die Verbindung zwischen den Bausteinen bilden. Da sie automatisch vom HookupManager erzeugt werden, erfolgt die Instrumentierung dort.
Der HookupManager schreibt die Hooks mit out.println.

Die für die Performanz-Messung in den Hook eingefügten Zeilen sind mit //* gekennzeichnet (Beispiel ClientBean):

// Automatically generated event hookup file.

package tmp.sunw.beanbox;
import ClientBean;
import java.awt.event.ActionListener;
import java.util.*;  //* fuer alternative Events
import java.io.*;    //* fuer Fehler- und Testausgaben
import MessBean;     //* Schnittstelle zum Messobjekt 
import java.awt.event.ActionEvent;

public class ___Hookup_16d0c7a4d1 implements java.awt.event.ActionListener,
java.io.Serializable {  

    public void setTarget(ClientBean t) {
        target = t;
    }               

    public void actionPerformed(java.awt.event.ActionEvent arg0) {   
 
     String fbName =  target.toString(); //* Targetnamen ermitteln
     int endpos = fbName.indexOf('[');   //* " "
     String tName = fbName.substring(0,endpos);    //* Targetname
     Thread ct = Thread.currentThread();  //* get Hauptthread
     String th = ct.getName();            //* get Hauptthreadname 
     MessBean.TA_start(th, tName);  //* Messpunkt Beginn der Transaktion
     
     success = true;  //* Ergebnis initialisieren
     try {            //* Exception abfangen
        target.orderTask(arg0);        // auch im originalen Hook 
     } catch ( Exception e) {    //*
       System.err.println("ERROR"+ e); //*
       success = false;          //* Ergebnis setzen
     }
       MessBean.TA_stop(th, tName, success); //* Messpunkt Ende Transaktion
    }
    private ClientBean target;    
    private boolean success;  //* Ergebnisvariable
}

4.

Instrumentierung von aktiven Javabeans

Eine aktive JavaBean enthält öffentliche Methoden, die von auftraggebenden Javabeans (Clients) zur Speicherung von Aufträgen aufgerufen werden. In der implementierten Beispielbean AktiBean ist dies die Methode

- setTask (param).

Zunächst muss die aktive Javabean die BTA-Instanz des Auftraggebers ermitteln mit:

- String BTA_ID = MessBean.getBTA_ID();

BTA_ID und param werden in einer Tabelle abgelegt.
Ferner enthält AktiBean einen eigenen Thread, der in einer run-Methode zyklisch Aufträge aus der Auftragstabelle liest und sie ausführt. Bei der Auftragsausführung ist folgende Instrumentierung erforderlich, um die entsprechenden Messpunkte mittels Messobjekt zu setzen:
Beim Start:

- MessBean.ATA_start(BTA_ID, Name des eigenen Threads)

Dabei ist BTA_ID die BTA-Instanz der auftraggebenden BTA.

Nach der Auftragsbeendigung:

- MessBean.ATA_stop(BTA_ID, Name des eigenen Threads, success)

Der Name des eigenen Threads wird eingefügt, weil auch in der aktiven Javabean ein Multithreading möglich ist und eine Zuordnung von Anfang und Ende eines Threads möglich sein soll.

5.

Instrumentierung von Client-Javabeans

Unter Client-Javabeans wird hier eine Javabean verstanden, die Aufträge an eine aktive Bean erteilt. Optional wird sie (es könnte auch jede andere Javabean sein) mit einem Informationsaufruf an die MessBean instrumentiert:

- MessBean.logInfo( info) // (String info)

6.

Instrumentierung der Multithread-Javabeans

Multithread- Javabeans erzeugen zusätzliche Threads, Der Kontrollfluss wird parallel zur Ausführung der Thread-Aktivitäten im Hauptthread fortgesetzt.
Bausteine, die eigene Threads erzeugen, um Aufgaben parallel zu bearbeiten, erzeugen die Threads mit:

- BThread tm = new BThread( threadname);

Mit tm.start() wird der neue Thread gestartet, mit tm.stop(success) beendet. (BThread s.u.; Instrumentierung entfällt mit neuer Thread-Klasse, die in Nachfolge-Fopra implementiert wird.)

7.

Instrumentierung der Javabibliotheken

Die Java-Klasse BThread wird als Extension der Klasse Thread aus der Javabibliothek erzeugt. Dazu werden die Methoden start und stop erweitert. Die neue start-Methode meldet das Starten eines neuen Threads mit

- add_control_flow

an das Messobjekt und ruft danach die Standardmethode start der Oberklasse auf.

Die neue stop-Methode meldet das Stoppen eines Threads mit

- rem_control_flow

an das Messobjekt und ruft danach die Standardmethode stop der Oberklasse auf.

Da die Methode stop in Java1.2 deprecated ist, und auch nicht alle Threadbeendigungen damit erfasst werden, wird BThread in einem folgenden Fopra durch eine geänderte Thread-Klasse in der Javabibliothek ersetzt.