JFace Data Binding

JFace Data Binding stellt eine allgemeinen Mechanismus bereit, um beliebige Werte aneinander zu binden. Diesen Mechanismus kann man in RCP-Anwendungen verwenden, um Modellobjekte mit den entsprechenden GUI-Elementen zu verknüpfen. Hat man eine Eigenschaft eines Modellobjektes z.B. an ein Textfeld gebunden, synchronisiert JFace Data Binding diese beiden Werte automatisch. Verändert man den Text im Textfeld, wird auch die Eigenschaft des Modellobjektes gesetzt und umgekehrt. Dabei anfallende Aufgaben wie Konvertierung, Validierung und Beachtung von Thread-Zugriffsregeln (SWT-Steuerelemente dürfen bspw. nur aus dem UI-Thread verändert werden) können dabei mit erledigt werden.

Observables

Ein Observable ist eine Abstraktion für Objekte, die sich beobachten lassen, d.h. bei Veränderungen ein Ereignis auslösen. Solche Observables werden vor allem mittels bereitgestellter Factory-Klassen erzeugt. Bei der Beobachtung von Java-Objekten hat man die Wahl zwischen BeansObservables und PojoObservables (Plain Old Java Object). Ein Bean meint hier ein Objekt, welches PropertyChangeSupport gemäß der Java Bean Spezifikation unterstützt und von außen beobachtet werden kann, z.B.:

public class Person {

    private PropertyChangeSupport changes = new PropertyChangeSupport(this);

    private String name;
    private String vorname;

    public String getName() { return name; }
    public String getVorname() { return name; }

    public void setName(String name) {
        changes.firePropertyChange("name", this.name, this.name = name);
    }

    public void setVorname(String vorname) {
        changes.firePropertyChange("vorname", this.vorname, this.vorname = vorname);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        changes.addPropertyChangeListener(listener);
    }

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        changes.removePropertyChangeListener(listener);
    }

}

Für eine Eigenschaft eines solchen Objektes kann mittels BeansObservables ein Observable erzeugt werden:

IObservableValue nameObservable = BeansObservables.observeValue(person, "name");

Wird PropertyChangeSupport nicht implementiert, kann ein PojoObservable verwendet werden. Bedingung dabei ist jedoch, dass das Objekt ausschließlich durch JFace Data Binding manipuliert wird:

IObservableValue nameObservable = PojoObservables.observeValue(person, "name");

Eigenschaften von SWT-Steuerelementen können mit SWTObservables beobachtet werden:

Text name = new Text(parent, SWT.BORDER);
IObservableValue nameTextObservable = SWTObservables.observeText(nameText, SWT.Modify);

Binding

Mit einem Binding werden zwei Observables miteinander verbunden und sind fortan automatisch synchronisiert:

Für die Erzeugung und Verwaltung von Bindings ist der DataBindingContext verantwortlich:

Die Observables aus dem obigen Beispiel könnten folgendermaßen gebunden werden:

DataBindingContext context = new DataBindingContext();
context.bindValue(nameText, nameTextObservable);
context.bindValue(vornameText, vornameTextObservable);

Dabei ist die Reihenfolge der Observable-Parameter zu beachten. Das erste Observable ist das Target, das zweite das Model. Initial synchronisiert JFace Data Binding den Wert vom Model zum Target, der initiale Zustand des Targets wird also verworfen.

Update-Strategien

Über eine UpdateValueStrategy können die beiden Richtungen eines Bindings beeinflusst werden. Diese können bei der Erzeugung des Bindings angegeben werden:

public final Binding bindValue(IObservableValue targetObservableValue,
    IObservableValue modelObservableValue);

public final Binding bindValue(IObservableValue targetObservableValue,
    IObservableValue modelObservableValue,
    UpdateValueStrategy targetToModel, UpdateValueStrategy modelToTarget);

Dabei kann eine updatePolicy spezifiziert werden, die den Zeitpunkt der Aktualisierung des Zielobjektes bestimmt:

• POLICY_NEVER: Modell wird nicht beobachtet und es erfolgt keine Aktualisierung des Zielobjektes.
• POLICY_ON_REQUEST: Aktualisierung erfolgt nur manuell durch Aufruf von updateModelToTarget oder updateTargetToModel auf dem Binding bzw. updateModels oder updateTargets auf dem DataBindingContext
• POLICY_CONVERT: Konvertierung von Werten erfolgt immer, Aktualisierung der Objekte jedoch nur gemäß POLICY_ON_REQUEST
• POLICY_UPDATE: Konvertierung, Validierung und Aktualisierung des Zielobjektes erfolgt bei jeder Änderung des Modellobjektes.

Beispiel: Um die Bearbeitung ein Feldes für die Bearbeitung im GUI zu sperren, würde man den Weg von Zielobjekt (Textfeld) zum Modellobjekt mit UpdateValueStrategy.POLICY_NEVER versehen:

context.bindValue(dateText, dateProperty,
    new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER), null);

Konvertierung

Die Werte der gebundenen Observables können auf dem Weg von Model zu Target und Target zu Model konvertiert werden. Dazu ist der UpdateValueStrategy mit setConverter ein IConverter-Objekt zu setzen. Dies ist insbesondere notwendig, wenn die gebundenen Werte nicht den gleichen Typ haben und daher eine manuelle Typkonvertierung erfolgen muss. Für simple Konvertierungen wie String <-> int verwendet JFace Data Binding automatisch einen passenden Converter.

Die Konvertierung eines Date mit einem SimpleDateFormat kann folgendermaßen realisiert werden:

UpdateValueStrategy targetToModel = new UpdateValueStrategy();
modelToTarget.setConverter(new IConverter() {
    
    public Object getFromType() {
        return String.class;
    }

    public Object getToType() {
        return Date.class;
    }
                
    public Object convert(Object fromObject) {
        return SimpleDateFormat.getDateInstance().parse(String.valueOf(fromObject));
    }
});

context.bindValue(dateText, dateProperty,
    targetToModel, new UpdateValueStrategy(UpdateValueStrategy.POLICY_NEVER));

Validierung

Über die UpdateValueStrategy kann auch ein Validator für die Wege zwischen Modell und Zielobjekt festgelegt werden. Die Validierung kann dabei zu drei verschiedenen Zeitpunkten erfolgen:

• setAfterGetValidator: Der unkonvertierte Wert aus dem Quellobjekt wird validiert.
• setAfterConvertValidator: Der konvertierte Wert wird direkt nach der Konvertierung validiert.
• setBeforeSetValidator: Der konvertierte Wert wird validiert, bevor er dem Zielobjekt gesetzt wird. Hier sollte vor allem komplexere Validierungslogik platziert werden, die bei einem einfachen afterConvert Validierungsfehler nicht ausgeführt werden soll.

Die Rückmeldung der Validator-Klasse erfolgt über Status-Objekte, die mit ValidationStatus erzeugt werden können:

updateValueStrategy.setAfterGetValidator(new IValidator() {

    public IStatus validate(Object value) {
        if (String.valueOf(value).length() > 10)
            return ValidationStatus.error("Maximal 10 Zeichen!");
        else
            return ValidationStatus.ok();
    }
    
});

Eine Validierungsregel kann sich auch über mehrere Felder erstrecken. Dazu verwendet man einen MultiValidator, der bei der Validierung mehrere Observables berücksichtigt und den DataBindingContext um das Validierungsergebnis ergänzt:

MultiValidator datesInOrder = new MultiValidator() {

    @Override
    protected IStatus validate() {
        Date startDate = (Date) startDateObservable.getValue();
        Date endDate = (Date) endDateObservable.getValue();
        return (endDate.after(startDate)) ? ValidationStatus.ok() : ValidationStatus
                .error("End date needs to be after start date.");
    }
};

context.addValidationStatusProvider(datesInOrder);

Wichtig ist dabei, dass die Abhängigkeiten des Validators (d.h. welche Änderungen eine Neu-Validierung notwendig machen) automatisch durch die Beobachtung der Zugriffe auf die Observables in der validate-Methode ermittelt werden. Daher sollte das Holen dieser Observables nicht von Bedingungen abhängig sein, die sich zur Lebenszeit des Validators ändern können.

Umfangreichere Beispiele zur feldübergreifenden Validierung finden sich in Snippet021MultiFieldValidation.

Realms

Unter Umständen muss der Zugriff auf die beobachteten Objekte oder die Logik zur Validierung in einem bestimmten Thread erfolgen. JFace Data Binding bildet diese Notwendigkeit über Realms ab. Ein Realm definiert einen Kontext, aus dem heraus ein Zugriff auf Objekte erfolgen soll.

Sie können z.B. beim Erzeugen von Observables einen solchen Realm angeben:

BeansObservables.observeValue(realm, bean, propertyName)

Über die angegebene Realm-Implementierung könnten Sie den Zugriff auf das Bean in einem bestimmten Kontext ausführen lassen. Wird kein Realm angegeben, wird der Default-Realm verwendet. Der Default-Realm kann explizit spezifiert werden, indem das Binding in einem Realm.runWithDefault()-Block durchgeführt wird:

Realm.runWithDefault(defaultRealm, new Runnable() {

    public void run() {
        DataBindingContext context = new DataBindingContext();
        // binding logic
    }
}

Eine RCP-Anwendung wird immer mit dem SWT-Realm als Default-Realm ausgeführt, alle Data Binding Zugriffe erfolgen daher standardmäßig auf dem UI-Thread.

Viewer binden

Mit der Klasse ViewerSupport können JFace Viewer an Listen gebunden werden. Dabei wird sowohl die Liste selbst beobachtet (das Hinzufügen oder Entfernen von Elementen führt zur Aktualisierung der Tabellenansicht) als auch die Objekt-Attribute selbst:

IObservableList list = new WritableList(someList, SomeObject.class);
ViewerSupport.bind(someTableViewer, list,
        BeanProperties.values(new String[] { "name", "street", "country.name" }));

Um die Selektion eines Viewers zu beobachten, stehen in der Klasse ViewersObservables Methoden zur Verfügung, mit dem entsprechende Observables erzeugt werden können:

IObservableValue selection = ViewersObservables.observeSingleSelection(someViewer);

Mehr Beispiele zum Binden von Viewern finden Sie hier:

• Snippet017TableViewerWithDerivedColumns
• Snippet032TableViewerColumnEditing
• Snippet02Stocks

JFace Data Binding Snippets

In dem Projekt org.eclipse.jface.examples.databinding finden sich viele Beispiel-Snippets zur korrekten Verwendung von JFace Data Binding. Sie können das Projekt mit folgenden Schritten aus dem Eclipse CVS-Repository auschecken:

• Wechseln Sie in die CVS Repository Exploring-Perspektive.
• Legen Sie ein neues Repository pserver:anonymous@dev.eclipse.org:/cvsroot/eclipse an.
• Checken Sie aus HEAD das Projekt org.eclipse.jface.examples.databinding in den lokalen Workspace aus.