Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage
<< | < | > | >> | API | Kapitel 44 - Beans

## 44.3 Die Beanbox

- 44.3 Die Beanbox
  - 44.3.1 Beschreibung und Installation
    - Installation des BDK
    - Die Aufrufscripte
  - 44.3.2 Grundlagen der Bedienung
    - Bedienelemente
    - Einfügen und Modifizieren von Beans
    - Events
  - 44.3.3 Integration eigener Beans
    - Entwickeln und Übersetzen der Bean
    - Erzeugen einer Manifest-Datei
    - Erzeugen des jar-Archivs
    - Verwenden der eigenen Bean
  - 44.3.4 Serialisierte Beans
    - Serialisieren von Beans mit der Beanbox
    - Einbinden serialisierter Beans

### 44.3.1 Beschreibung und Installation

Zur Unterstützung beim Entwurf und Testen von Beans und als Referenzplattform für die Demonstration des Bean-Konzepts wurde von SUN das Bean Development Kit (kurz BDK) entwickelt. Es wird frei zur Verfügung gestellt und kann beispielsweise über die Java Beans Homepage von http://java.sun.com/beans/index.html heruntergeladen werden. Während der Erstellung dieses Kapitels wurde die Version 1.1 verwendet. Wichtigster Bestandteil des BDK ist die Beanbox, die eine einfache Umgebung zum Testen von selbstentwickelten Beans zur Verfügung stellt. Bevor wir uns ihrer Bedienung zuwenden, soll die Installation des BDK beschrieben werden.

|  |  |  | Die Beanbox sollte nicht als vollwertige Test- und Entwicklungsumgebung für Java-Beans betrachtet werden. Dazu ist sie zu schwach. Sie wurde lediglich entwickelt, um die Bean-Konzepte zu illustrieren und eine erste Möglichkeit für ihre Anwendung zur Verfügung zu stellen. Bei weitergehendem Einsatz stößt man schnell an die Grenzen der Beanbox, und ihr praktischer Nutzen ist recht begrenzt. |  |
Warnung

#### Installation des BDK

Die Installation des BDK ist einfach; Voraussetzung ist ein funktionierendes JDK. Unter Windows gibt es ein menügesteuertes Installationsprogramm "bdk1_1-win.exe", das die meisten Schritte übernimmt. Nachdem es gestartet wurde, müssen zunächst die Lizenzbedingungen akzeptiert werden, dann ist die Eingabe des Installationsverzeichnisses erforderlich. Sind mehrere Java-Interpreter vorhanden, muß anschließend ausgewählt werden, welcher von ihnen zum Betrieb des BDK verwendet werden soll. Nach Drücken des "Install"-Buttons wird dann mit der Installation begonnen. Die Installationsroutine legt auch einen Uninstall-Eintrag an, mit dem das BDK bei Bedarf deinstalliert werden kann.

#### Die Aufrufscripte

Nach der Installation befindet sich eine Datei run.bat im Unterverzeichnis `beanbox` des BDK-Verzeichnisses (analog dazu gibt es das Shell-Script `run.sh` zum Starten der Beanbox auf UNIX-Systemen). Diese Batchdatei setzt den `CLASSPATH` auf die benötigten Klassen- und .jar-Dateien und startet die Beanbox. Sie ist leider etwas archaisch. Einerseits wird der aktuelle `CLASSPATH` überschrieben. Zudem war sie im Test mitunter instabil, wenn der HotSpot-Compiler aktiviert war. Eine modifizierte Version von `run.bat` könnte etwa so aussehen (analoge Anpassungen können für die UNIX-Version vorgenommen werden):

    @echo off
    set OLDCP=%CLASSPATH%
    echo saving old CLASSPATH in OLDCP: %OLDCP%
    set CLASSPATH=classes;..\lib\methodtracer.jar;..\infobus.jar
    java -classic sun.beanbox.BeanBoxFrame
    set CLASSPATH=%OLDCP%
    set OLDCP=
    echo CLASSPATH restored to %CLASSPATH%

### 44.3.2 Grundlagen der Bedienung

Nach dem Aufruf des Startscripts `run` wird die Beanbox gestartet und präsentiert ihre aus vier Top-Level-Frames bestehende Arbeitsoberfläche:

#### Bedienelemente

Abbildung 44.2: Die Beanbox

- Das linke Fenster zeigt die Toolbox an. Sie enthält eine Liste mit allen verfügbaren Beans.
- Das mittlere Fenster stellt den GUI-Designer dar, in dem ausgewählte Beans plaziert werden. Hier können die Beans verschoben, in der Größe verändert und zur Bearbeitung ausgewählt werden.
- Das rechte obere Fenster enthält den Property-Editor, mit dessen Hilfe die Eigenschaften der ausgewählten Bean modifiziert werden können.
- Der rechts unten angezeigte Method Tracer dient zur Unterstützung beim Debuggen und soll hier nicht weiter behandelt werden. Er kann mit dem Menüpunkt "Services.Hide_Method_Tracing" deaktiviert werden.

#### Einfügen und Modifizieren von Beans

Um eine Bean zu bearbeiten, muß sie zunächst im GUI-Designer plaziert werden. Dazu ist sie in der Toolbox anzuklicken und mit einem erneuten Klick im GUI-Designer zu plazieren. Der schraffierte Rand zeigt an, daß sie ausgewählt wurde und ihre Eigenschaften im Property-Editor modifiziert werden können. Durch Ziehen an einem der vier Ränder kann die Bean beliebig verschoben werden. Ist ihre Größe variabel, kann sie durch Ziehen an einer der vier Ecken verändert werden. Soll eine Bean aus dem GUI-Designer entfernt werden, ist sie zu markieren und mit dem Menüpunkt "Edit.Cut" zu löschen.

|  |  |  | Beachten Sie bitte, daß das Verschieben der Bean und das Ändern ihrer Größe ausschließlich durch Mausklicks auf ihrem Rand ausgeführt wird. Mausoperationen im Inneren der Bean werden als reguläre Ereignisse gewertet und direkt an das zu diesem Zeitpunkt bereits instanzierte Bean-Objekt weitergeleitet. |  |
Tip

Als Beispiel wollen wir die vordefinierte Bean "OrangeButton" im GUI-Designer plazieren. Sie stellt sich zunächst als oranges Rechteck dar, das nach einem Mausklick kurz die Farbe wechselt. Im Property-Editor können die öffentlichen Eigenschaften der Bean verändert werden:

- "background" verändert die Hintergrundfarbe. Sie ist standardmäßig orange und kann durch Klick auf das farbige Panel verändert werden. Der angezeigte Farbauswahldialog ist allerdings etwas rudimentär und erlaubt lediglich die direkte Eingabe eines RGB-Werts oder die Auswahl einer vordefinierten Farbkonstante.
- "foreground" verändert die Farbe, in der der Rahmen des Buttons gezeichnet wird. Hier kommt derselbe Farbdialog wie zuvor zum Einsatz.
- Die Eigenschaft "label" definiert die Bezeichnung des Buttons. Wird der Wert in diesem Textfeld geändert, paßt sich die Beschriftung des Buttons entsprechend an.
- Schließlich kann mit der Eigenschaft "font" die Schriftart und -größe geändert werden, in der die Beschriftung des Buttons angezeigt wird. Auch hier wird der Änderungsdialog durch Klicken auf den angezeigten Wert aufgerufen und präsentiert sich ähnlich spartanisch wie der Farbdialog. Immerhin können die relevanten Font-Parameter verändert werden, und auch die Eigenschaftenanzeige verändert sich in Abhängigkeit von der Fontauswahl.

#### Events

Die Beanbox bietet die Möglichkeit, eine Bean über die von ihr generierten Events mit einer anderen Bean zu verbinden. Um das beispielhaft zu demonstrieren, soll zusätzlich eine Instanz der Bean vom Typ "EventMonitor" im GUI-Designer plaziert werden. Dann klicken wir den Button an und rufen den Menüpunkt "edit.Events.buttonPushed.actionPerformed" auf. Wenn die Maus nun den Button verläßt, bleibt sie über eine rote Linie mit dem Button verbunden. Wir ziehen diese Linie auf den "EventMonitor" und führen einen weiteren Mausklick aus. In der nun angezeigten Liste aufrufbarer Methoden wählen wir den (einzigen) Eintrag `initiateEventSourceMonitoring` aus.

Die Beanbox generiert nun Java-Code für eine Adapterklasse, kompiliert ihn und legt die resultierenden Dateien im Unterverzeichnis tmp\sunw\beanbox ab. Gleichzeitig registriert sie die Adapterklasse für das Action-Ereignis des Buttons und sorgt durch den Aufruf der ausgewählten Methode innerhalb von `actionPerformed` dafür, daß der Event-Listener bei jedem Buttonklick benachrichtigt wird. Seine Aufgabe besteht darin, die ausgelösten Ereignisse zu speichern und in einer Listbox auf dem Bildschirm anzuzeigen.

|  | Auf diese Weise lassen sich prinzipiell beliebige Beans miteinander verbinden. Die Einschränkung der Beanbox besteht lediglich darin, daß sie nur Adapterklassen für den Aufruf von parameterlosen Methoden erzeugen kann. Fortgeschrittenere GUI-Designer würden es erlauben, auch parametrisierte Methoden aufzurufen. Sie würden zusätzlich einen Editor zur Verfügung stellen, mit dem der erzeugte Code per Hand angepaßt werden kann. |  |
Hinweis

### 44.3.3 Integration eigener Beans

Neben den vordefinierten können auch eigene Beans in die Beanbox integriert werden. Sie können dann wie vordefinierte verwendet, manipuliert und serialisiert werden. Im folgenden wollen wir beschreiben, welche Schritte nötig sind, um eine Bean in der Beanbox verwendbar zu machen. Für die Einbindung in eigene GUI-Designer kann eventuell eine etwas andere Vorgehensweise erforderlich sein. Dazu sollte die Bean-Dokumentation des jeweiligen Entwicklungssystems konsultiert werden.

#### Entwickeln und Übersetzen der Bean

Die ersten beiden Schritte, das Entwickeln und Übersetzen der Bean, haben wird schon erledigt. Sie unterscheiden sich in keiner Weise von der einer herkömmlichen Java-Klasse. Als Ergebnis ensteht eine Klasse `LightBulb.class` mit dem Bytecode der Glühlampen-Bean.

#### Erzeugen einer Manifest-Datei

Um bei GUI-Designern mit einer großen Anzahl unterschiedlicher Beans ein schwer zu durchschauendes Sammelsurium kleiner Klassendateien zu vermeiden, werden Beans in jar-Archive verpackt und so an den GUI-Designer übergeben. Eine jar-Datei darf beliebig viele Beans enthalten. Um dem GUI-Designer die Möglichkeit zu geben, Klassen für Beans von solchen mit reinen Hilfsfunktionen zu unterscheiden, wird dem jar-Archiv eine Manifest-Datei hinzugefügt, die ihren Inhalt beschreibt. Es handelt sich um eine normale Textdatei, die für jede enthaltene Bean einen Eintrag der folgenden Form enthält:

    Name: BeanClassFile.class
    Java-Bean: True

Der erste Eintrag gibt den Klassennamen an. Der zweite besagt, daß es sich um eine Bean handelt (Manifest-Dateien können auch noch andere Informationen über die im Archiv gespeicherten Dateien enthalten). Die Informationen werden zweckmäßigerweise in eine Textdatei manifest.txt geschrieben und beim Erzeugen der jar-Datei mit der Option "m" eingebunden. Zum Einbinden der Glühlampe muß diese Datei also folgenden Inhalt haben:

    Name: LightBulb.class
    Java-Bean: True

#### Erzeugen des jar-Archivs

Nun kann das Kommando zum Erzeugen der jar-Datei abgesetzt werden (wir wollen sie hjp3beans.jar nennen):

    jar cfm hjp3beans.jar manifest.txt LightBulb.class bulb*.gif

Die Option "c" steht für "create" und besagt, daß eine neue jar-Datei angelegt werden soll. Das "f" steht für "file" und gibt an, daß als erstes Argument hinter den Kommandobuchstaben der Name der jar-Datei steht. Das "m" steht für "manifest" und besagt, daß als nächstes Argument der Name der Manifest-Datei folgt. Ganz zum Schluß stehen die Namen der einzubindenden Dateien. In diesem Fall sind das die Klassendatei und die zur Darstellung benötigten gif-Dateien bulb1.gif und bulb2.gif.

Die jar-Datei muß nun in das Unterverzeichnis jars des BDK-Installationsverzeichnisses kopiert werden. Beim nächsten Start der Beanbox wird sie automatisch gefunden, analysiert, und die darin enthaltenen Beans werden im GUI-Designer zur Verfügung gestellt.

#### Verwenden der eigenen Bean

Unsere Glühlampe wird nun in der Toolbox angezeigt und kann wie jede andere Bean in den GUI-Designer übernommen werden. Im Eigenschaftenfenster werden ihre Eigenschaften angezeigt und können interaktiv verändert werden. Wird beispielsweise die Eigenschaft `lightOn` von `false` auf `true` gesetzt, ändert die Bean ihren Zustand und die Glühlampe leuchtet auf (siehe Abbildung 44.3). Auch auf das Verändern der ererbten Eigenschaften (z.B. der Hintergrundfarbe) reagiert unsere neue Komponente erwartungsgemäß mit einer entsprechenden Änderung der graphischen Darstellung.

Abbildung 44.3: Die Glühlampe in der BeanBox

|  | Die Definition der Klasse `LightBulb` in Listing 44.3 enthält eine Methode `toggleLight`, mit der der Zustand der Lampe umgeschaltet werden kann. Da ihr Name nicht den Design-Konventionen für getter- und setter-Methoden entspricht, ist sie im GUI-Designer der Beanbox nicht sichtbar. In Abschnitt 44.6 werden wir erläutern, wie man sie mit Hilfe einer `BeanInfo`-Klasse dennoch sichtbar machen kann. |  |
Hinweis

### 44.3.4 Serialisierte Beans

#### Serialisieren von Beans mit der Beanbox

Im vorigen Abschnitt wurde erwähnt, daß Beans serialisierbar sein müssen. Dadurch ist ein GUI-Designer in der Lage, eine zum Designzeitpunkt konfigurierte Bean dauerhaft zu speichern und sie anderen Programmen vorkonfiguriert zur Verfügung zu stellen.

Auch die Beanbox bietet eine einfache Möglichkeit, Beans zu serialisieren und auf der Festplatte zu speichern. Dazu ist die gewünschte Bean im GUI-Designer zu markieren und der Menüpunkt "File.SerializeComponent" aufzurufen. Nun ist ein Dateiname anzugeben, unter dem die konfigurierte Bean gespeichert werden soll.

Im folgenden wollen wir annehmen, daß die Glühlampen-Bean in der Beanbox so konfiguriert wurde, daß das Licht angeschaltet ist und sie unter dem Namen "lb1.ser" persistent gespeichert wurde.

#### Einbinden serialisierter Beans

Soll eine serialisierte und damit vorkonfigurierte Bean in einem Programm verwendet werden, muß sie vor dem Einbinden deserialisiert werden. Dazu wird ein `ObjectInputStream` verwendet, der die Bean mit Hilfe eines `FileInputStream` aus ihrer Datei liest. Anschließend kann das deserialisierte Objekt durch Aufruf von `add` in gewohnter Weise in den Dialog eingebunden werden:

    001 /* Listing4405.java */
    002
    003 import java.awt.*;
    004 import java.awt.event.*;
    005 import java.io.*;
    006
    007 public class Listing4405
    008 extends Frame
    009 {
    010   public Listing4405()
    011   {
    012     super("LighBulbTest");
    013     setLayout(new FlowLayout());
    014     setBackground(Color.gray);
    015     addWindowListener(
    016       new WindowAdapter() {
    017         public void windowClosing(WindowEvent event)
    018         {
    019           System.exit(0);
    020         }
    021       }
    022     );
    023     loadLightBulb();
    024   }
    025
    026   private void loadLightBulb()
    027   {
    028     try {
    029       ObjectInputStream is = new ObjectInputStream(
    030                              new FileInputStream("lb1.ser"));
    031       LightBulb bulb = (LightBulb)is.readObject();
    032       is.close();
    033       add(bulb);
    034     } catch (ClassNotFoundException e) {
    035       System.err.println(e.toString());
    036     } catch (IOException e) {
    037       System.err.println(e.toString());
    038     }
    039   }
    040
    041   public static void main(String[] args)
    042   {
    043     Listing4405 frm = new Listing4405();
    044     frm.setLocation(100, 100);
    045     frm.pack();
    046     frm.setVisible(true);
    047   }
    048 }
| Listing4405.java

Listing 44.5: Einbinden einer serialisierten Bean

Wird das Programm gestartet, lädt es die Bean und zeigt sie mit angeschaltetem Licht:

Abbildung 44.4: Die deserialisierte Glühlampen-Bean

Titel | Inhalt | Suchen | Index | DOC | Handbuch der Java-Programmierung, 3. Auflage, Addison Wesley, Version 3.0
<< | < | > | >> | API | © 1998-2002 Guido Krüger, http://www.javabuch.de