JavaBeans

Java-Beans sind Sun`s Realisierung des Komponentenmodells für die »Java Plattform«. Java-Beans zeichnen sich dadurch aus, daß sie in einem hohem Maß wiederverwendbar und zu 100% plattformunabhängig sind.

Aus solchen Software-Komponenten können schnell und sicher leistungsfähige Programme und Applets erstellt werden.In Kombination mit IDEs (Integrierte Entwicklungsumgebungen) können Java-Beans ohne Source-Code analysiert und verwendet werden. Beans geben Auskünfte über Properties, Events und Methoden.

Über  Customize-Dialoge des jeweiligen Beans kann ein Bean an individuelle Bedürfnisse angepaßt werden. Die Properties des Beans können dann abgespeichert werden und in die Zielanwendung eingefügt werden.
Der Softwareaufwand zum Erstellen eigener Beans besteht im simpelsten Fall darin, fest­gelegte Namenskonventionen für die Zugriffsmethoden zu verwenden.

Properties

Properties sind diskrete Attribute eines Java-Beans, das sein Verhalten und Erscheinungsbild steuert. Nach außen wird eine Property je nach Typ von ein bis drei Klassenmethoden repräsentiert. Diese Methoden müssen  nach ganz bestimmten Namenskonventionen benannt werden. Soll z.B. eine Property lesbar und schreibbar sein, so sind folgende Methoden nötig:

<Typ> get<Property-Name>()
void  set<Property-Name>( <Typ> )

Wobei <Property-Name> und <Typ> jeweils den Namen und den Datentyp der Property bezeichnen. Bei Index-Properties werden vier Methoden benötigt:

<Typ>   getter( index )
<Typ>[] getter()
void    setter(<Typ>[])
void    setter( index, <Typ> )


Diese Art der Properties ist aber eher selten. Neben den normalen Properties gibt es noch zwei spezielle Arten:

  • Bound-Properties: Sie unterstützen den sogenannten »change notification service«, d. h. registrierte Methoden werden bei einer Änderung des jeweiligen Zustandes davon unterrichtet.
  • Constrained-Properties: Diese Art ist den bound-Properties ähnlich, sie können aber eine Änderung in einen bestimmten Wert verhindern. Dies geschieht über das Werfen einer PropertieVetoException.

 

BeanInfo-Klassen

Diese Klassen geben allgemeine Auskünfte über das Bean. Informationen wie: Methodennamen, Properties, Events und vieles mehr sind über diese Helper-Klasse in Erfahrung zu bringen. Eine IDE z.B. kann über die BeanInfo-Klassen ein Bean analysieren und auf besondere Eigenschaften eingehen.

Eine BeanInfo-Klasse muß, ähnlich wie bei den Properties, eine ganz bestimmte Namens­konvention einhalten:

<Name des Bean>BeanInfo

Dies ist wichtig, weil der Introspector (s. u.) sonst die Bean-Klassen nicht zu den Info-Klassen binden kann.

Eine Besonderheit bei diesen Klassen ist, daß sie nicht unbedingt selbst erstellt werden müssen. Sie können vom Introspector automatisch zur Laufzeit generiert werden. Jedoch wird man sie in der Praxis selbst erstellen, weil darüber zentrale Eigenschaften der Beans einstellbar sind.

 

Introspector-Interface

Der Introspector ist die zentrale Anlaufstelle, um Informationen über Beans zu erhalten. Er sucht zuerst im CLASSPATH nach der zugehörigen Infoklasse. Findet er keine ent­sprechende Klasse, so generiert er eine eigene Klasse. Dies wird über die Java Reflection- API möglich.
Es ist auch möglich eine unvollständige BeanInfo-Klasse zu ergänzen. Soll z.B. nur das Icon eines Beans definiert werden, kann der Introspector die fehlenden Informationen selbständig ergänzen.

 

Bean-Anpassungen (Customization)

In einer IDE sollen Properties über Property-Editor Dialoge eingestellt und abgespeichert werden können. Über den PropertyEditorManager können eigene und vordefinierte Editoren bezogen werden. Üblicherweise wird eine IDE die Editoren für bestimmte Property-Typen anfordern und einen Dialog erstellen, in dem die Editoren in einer Tabelle angeordnet sind.

Interessant ist dabei die Möglichkeit, eigene, spezialisierte Editoren für bestimmte Datentypen zu registrieren; dies geschieht über den PropertyEditorManager. Die IDE benutzt dann die neuen, registrierten Editoren, somit kann Einfluß auf die integrierte Entwicklungsumgebung genommen werden.

Sollen eigene Property-Editoren zum Einsatz kommen, so müssen eigene GUI-Elemente erstellt und registriert werden. Diese Klassen müssen nach einer bestimmten Namenskon­vention benannt werden:

Property-Typ: <Typ-Name>

Editor-Klasse: <Typ-Name>Editor

Die Klassen werden nun über folgenden Methodenaufruf registriert:

PropertyEditorManager.registerEditor(<Typ-Name>, <Typ-Name>Editor)

Die flexibelste Art der Bean-Anpassung ist die Erstellung von eigenen Customize-Dialogen. Dabei kann individuell auf besondere Begebenheiten der Beans eingegangen werden. Ist ein Customize-Dialog gut entworfen, so kann er auch für den Endeinsatz benutzt werden. Z.B. ein Datenbank-Bean stellt einen Customize-Dialog für das Anmelden einer Datenbank zur Verfügung. Dieser Dialog kann dann nicht nur zur Design-Zeit benutzt werden, sondern auch im realen Einsatz.

Ein eigener Customize-Dialog muß das Interface java.beans.Customizer implementieren. In der jeweiligen BeanInfo-Klasse muß die folgende Methode überschrieben werden:

public BeanDescriptor getBeanDescriptor()

Weitere Informationen sind der JavaBeans API Specification zu entnehmen.

 

Komponentenmodell