zum Inhalt

4 Entwickeln einer Java-"Bohne"

Speziell für die Entwicklung von Java-Beans und zum Austesten ihrer Zusammenarbeit gibt es das in Kapitel 3 erläuterte Beans Development Kit. Bevor jedoch die erste vollständig "eigene" Java-Bean in das JAR-Verzeichnis des BDK kopiert werden kann, muß sie programmiert werden!
Ganz allgemein ist es bei den ersten Gehversuchen mit neuen Umgebungen sinnvoll, die ersten Projekte "von Hand" - auf der Kommandozeile - auszuführen. Im folgenden Beispiel soll so eine "Example-Bean" entwickelt werden.
Sollten die Beispiele auf Ihrem Rechner nicht korrekt arbeiten, beachten Sie bitte die Hinweise auf der Startseite des Referats!

Die erste Version: Das Ergebnis:

// Example.java
import java.awt.*;
import java.io.Serializable;
import java.applet.*;

public class Example extends Applet implements Serializable {  

	public Example() {
		setSize(60,40);
	}

	public void paint(Graphics g) {
		g.setColor(Color.green);
		g.fillRect(20,5,20,30);
	}
}

Allgemein muß eine Bean einen parameterlosen Konstruktor besitzen und das Interface java.io.Serializable einbinden. Objekte, die dieses Interface implementieren, können ihren Status speichern und zurückladen (Persistenz). Das ist bei Beans notwendig, damit sie nach ihrer interaktiven Bearbeitung und Anpassung in der Lage sind, ihren konkreten Zustand zu sichern. Jede Bean muß auf eine externe Anforderung hin den Inhalt der gespeicherten Properties serialisieren oder aus der gespeicherten Form zurücklesen können. Die Klasse Canvas ist direkt von java.awt.Component abgeleitet und implementiert primitive Methoden (z. B. paint), um überhaupt eine Bildschirmanzeige zu erhalten.

Nachdem obiges Programm kompiliert wurde muß eine Manifest-Datei mit Informationen für das BDK erstellt werden. Wenn im BDK Komponenten aus anderen Komponenten erstellt werden entfällt dieser Schritt; das BDK erledigt dies selbständig. Die zu editierende Manifest-Datei:

// Example.lst
Manifest-Version: 1.0  
Name: Example.class
Java-Bean: True

Diese temporäre Manifest-Datei wird zum erstellen der JAR-Datei benötigt. Die erste eigene Bohne steht kurz vor ihrer Fertigstellung - das JAR kann nun erstellt und danach in das JAR-Unterverzeichnis des BDK kopiert werden:
jar cfm Example.jar Example.lst Example.class.
Nach dem Start des BDK findet sich unsere erste Komponente in der ToolBox wieder. Wird sie mit der Maus angewählt und dann mit dem Fadenkreuz in der BeanBox plaziert, wird auch das Ergebnis sichtbar - ein kleiner grüner Kasten.

Erschlagen von soviel Funktionalität ist es nun dringend notwendig das erste wesentliche Merkmal jeder Java-Komponente zu implementieren - eine Eigenschaft. Eigenschaften definieren sich aus der Verwendung eines get/set-Paares und der entsprechenden Instanz. Die Datei Example.java muß folgendermaßen erweitert werden:

private Color framecolor = Color.blue;

public Color getFrameColor() {
	return framecolor;
}

public void setFrameColor(Color newcolor) {  
	framecolor = newcolor;
	repaint();
}

Die paint-Methode muß so geändert werden:

public void paint(Graphics g) {
	g.setColor(framecolor);
	g.fillRect(0,0,60,40);
	g.setColor(getBackground());  
	g.fillRect(5,5,50,30);
}

Das Ergebnis:

Nach dem kompilieren und packen sollte die Bean jetzt einen blauen Rahmen darstellen. Die Eigenschaft framecolor kann jetzt bereits im Property-Sheet den eigenen Wünschen angepaßt werden.

Im dritten Schritt soll jetzt ein Eingriffsmöglichkeit des Endbenutzers implementiert werden. Nach betätigen einer Button-Komponente, die der Superhacker "Harry" implementiert und schon in unsere ToolBox unter dem Namen OurButton kopiert hat, soll sich die Rahmenfarbe auf eine andere Farbe ändern. Da wir nicht als Event-Quelle auftreten genügt das Abfragen eines ActionEvents. Der Quellcode der OurButton-Klasse interessiert uns nicht!!!

Example.java wird folgendermaßen erweitert:

import java.awt.event.ActionEvent;

private int remembercolor = 0;

public void changeFrameColor() {
	switch(remembercolor) {
		case 0: framecolor = Color.red;
		   remembercolor++;
		   break;
		case 1: framecolor = Color.white;
		   remembercolor++;
		   break;
		case 2: framecolor = Color.black;
		   remembercolor++;
		   break;
		case 3: framecolor = Color.green;
		   remembercolor++;
		   break;
		case 4: framecolor = Color.yellow;
		   remembercolor++;
		   break;
		default: framecolor = Color.blue;
		   remembercolor++;
		   break;
	}

	if (remembercolor > 5) remembercolor = 0;
	repaint();
}

public void changeFrameColor(ActionEvent actionEvent) {  
	changeFrameColor();
}

Das Abfangen des ActionEvents reicht aus, um unsererseits den Farbwechsel zu bewirken. Es ist nicht zulässig, die switch-Anweisung in die Methode changeFrameColor(ActionEvent actionEvent) zu schreiben!
Wird jetzt die Komponnete in die BeanBox "gedropped" kann sie mit einer anderen verbunden werden. Nun wird OurButton in der ToolBox ausgewählt und ebenfalls in der BeanBox plaziert. Die neue Button-Komponente muß angewählt werden, was an der schraffierten Umrandung erkennbar ist. Im Menü kann jetzt über Edit/Events/mouse/mouseClicked ein abzufangender Event DIESER Button-Komponente ausgewählt werden. Schließt sich das Menü ist der Mauszeiger mit dem Button durch einen "Faden" verbunden. Klickt man mit der Maus nun auf unsere Rahmen-Komponente erscheint ein Auswahlmenü aller Events dieser Komponente. Neben vielen Standardmethoden findet sich auch unsere changeFrameColor-Methode - die wir auswählen. Das BDK beginnt nun mit der Analyse und Zusammenstellung der Klassen. Danach können wir durch betätigen des Buttons die Rahmenfarbe ändern. Wird im View-Menü der Design-Mode beendet, kann die neue Komponente in ihrem späteren Erscheinungsbild, wie sie beispielsweise in einem Browser erscheint, betrachtet werden.
Wie ihnen vielleicht aufgefallen ist, besitzen manche Komponenten in der ToolBox kleine Icons links des Komponentennamens. Da wir Harry zeigen wollen das auch wir Superhacker sind, wollen wir dort ein Icon für unsere Komponente plazieren.
Für diese Eigenschaft ist das zusätzliche Interface java.beans.BeanInfo zuständig, bzw. die Klasse SimpleBeanInfo, welche wir in einer eigenen Klasse ExampleBeanInfo implementieren:

Die fertige Bean: sieht so aus:

//ExampleBeanInfo.java
import java.awt.Image;
import java.beans.SimpleBeanInfo;

public class ExampleBeanInfo extends SimpleBeanInfo {  

    public Image getIcon(int i) {
        if (i != 1) return null;
        Image image = loadImage("bspicon.gif");
        return image;
    }

    public ExampleBeanInfo() {
    }
}

Das darzustellende Icon ist im Beispiel in der Datei: bspicon.gif abgespeichert. Man beachte das sich Dateinamen von BeanInfo-Klassen immer aus dem Namen der Originalkomponente + "BeanInfo" zusammensetzen! Werden dann alle Dateien (inklusive des Grafikicons) in das JAR eingepackt, erkennt das BDK die jeweilige BeanInfo-Klasse und zeigt das Icon wie gewünscht an. Weder die ExampleBeanInfo-Klasse instanziert eine Example-Komponente noch umgekehrt. Durch die korrekte Programmierung der Methoden und Vereinbarungen kann der BDK "automatisch" die richtigen Klassen zuordnen.

Download aller JAR-Dateien.

zu Kapitel 5 Kapitelanfang zum Inhalt