Validieren von Formulardaten

Einleitung

Es existieren verschiedenste Frameworks zur Validierung von Formularen für die Sprache Java. Allen diesen Frameworks ist gemein, daß sie für spezielle Anwendungsszenarien geschaffen wurden. Es existiert zum Beispiel das Framework im Rahmen des Apache-Commons-Projektes, das für Struts weiter aufgebohrt wurde.

Für das hier diskutierte Framework wurden Anforderungen formuliert, die durch keines der bekannten Frameworks definitiv und vollständig abgedeckt wurden:

• Code der Validierung soll nicht direkt im Formular (in der Geschäfts- oder fachlichen Logik) eingebunden, sondern deklarativ spezifiziert werden
• Einfache Interfaces zur Implementierung von neuen Regeln sollen die Programmierer motivieren, neue spezifische regeln für das Framework zu implementieren
• Unterstützung mehrsprachiger Fehlermeldungen ist für den Einsatz in Client-Server-Szenarien unabdingbar
• Validierungen, die lediglich einzelne Felder prüfen, sollen ebenso verfügbar sein,
• wie Formular-basierte (Feld-übergreifende) Validierungen, die mehrere Felder in die Validierung einbeziehen
• Check der Formular-basierten Überprüfungen erst wenn alle Einzelfeld-basierten Überprüfungen fehlerfrei sind
• Hierarchisierung von Regeln: validiere Regel A nur, wenn Validierung von Regel B erfolgreich war
• Gleichberechtigte Menge von Regeln: Validiere alle Regeln, egal ob und wenn ja wie viele Validierungen bereits fehlgeschlagen sind
• Das Ergebnis der Validierung beschränkt sich nicht nur auf "wahr oder falsch" sondern ergibt (bei fehlgeschlagener Validierung) immer auch "warum ist es falsch"

Im weiteren wird auf die einzelnen Anforderungen näher eingegangen. Das Ergebnis ist ein Framework, das mit Erfolg sowohl für klassische Desktop-Anwendungen als auch für Client-Server-Anwendungen eingesetzt wird. Ein Beispiel für den Einsatz ist das JavaBeansFramework, in dem über entsprechende visuelle Signale an den Formular-Elementen in den generierten GUIs die Gründe für die nicht akzeptierten Eingaben angezeigt werden.

Trennung von Formular und Validierung

Grundlage für die Validierung sind die Datenstrukturen, die hinter den Formularen liegen. Diese Datenstrukturen können Daten unterschiedlicher Typen enthalten, wobei jedem Datum ein Name eineindeutig zugeordnet wird. In der Sprache Java entsprechen JavaBeans diesem Konzept. JavaBeans stellen also die Formulare dar, die Daten - oder im Java-Sprachgebrauch Properties - enthalten.

Definiert man JavaBeans als Mittel zum Datenaustausch zwischen einzelnen Modulen oder Schritten der Geschäftsprozesse (also ohne Logik - zur reinen Datenhaltung), kann man diese recht früh im Entwicklungsprozeß definieren und danach einfrieren.

Die Festlegung von Regeln zur Validierung kann dann im Laufe des Entwicklungsprozesses vorangetrieben werden, ohne die JavaBeans zu verändern. Zur Verknüpfung der Regeln mit den Formularen oder Beans werden die Bordmittel von Java eingesetzt, die im Namensraum java.beans.* zu finden sind.

Über die Mittel, die dort zur Verfügung stehen, kann man Metainformationen zu JavaBeans assoziieren. Hierbei ist man nicht auf einen festen Satz beschränkt, sondern kann zu jeder Property eine beliebige Menge eigener, problembezogener Metainformationen verankern. Eine mögliche Erweiterung wären hier die Regeln zur Validierung der Feldinhalte von Formularen.

Damit werden die Validierungsregeln also als Metainformationen der JavaBean definiert und können während des Entwicklungsprozesses geändert/verfeinert/ausgetauscht werden, ohne dazu den Quelltext der JavaBean ändern zu müssen.

Einfache Interfaces

Ein weiteres Ziel beim Design des Frameworks war eine möglichst unkomplizierte Schnittstelle der Regeln zu definieren, damit Entwickler wenig Einarbeitsaufwand haben und damit die Schwelle zur Benutzung des Frameworks niedrig gehalten wird.

Für Entwickler, die neue Regeln für die Validierung entwickeln wollen, besteht lediglich die Notwendigkeit, das Interface Rule zu implementieren, welches genau eine Methode enthält, die ausgefüllt werden muß.

Unterstützung mehrsprachiger Fehlermeldungen

Der hauptsächliche Unterschied bei der Validierung besteht zwischen reinen Desktop-Anwendungen und Client-Server-Lösungen darin, daß eine Desktop-Anwendung in einer Umgebung mit einer festgelegten Sprache läuft und daher die Fehlermeldungen während der Laufzeit lediglich in dieser Sprache ausgegeben werden müssen.

Bei Client-Server-Anwendungen dagegen ist es so, daß durchaus unterschiedliche Nutzer mit dem System interagieren können und diese Nutzer gegebenenfalls unterschiedliche Sprachen bevorzugen. Daher ist es hier nötig, Angaben zur bevorzugten Sprache zum Zeitpunkt der Validierung auszuwerten und jeweils dazu passende Fehlermeldungen zu generieren.

Das entstandene Framework trägt diesem Sachverhalt dadurch Rechnung, daß es Methoden zur Verfügung stellt, die es dem Entwickler neuer Regeln erlauben, mit minimalem Aufwand an die Sprache angepaßte Fehlermeldungen zu erzeugen. Dafür wird ein Validierungs-Kontext (eine Map) eingeführt, in dem unter einem Spezialschlüssel die Locale des Nutzers abgelegt ist, für den die Validierung gerade durchgeführt wird.

Einzelfeld-Validierungen

Solche Validierungen werden implementiert, indem Implementierungen des Interface Rule unter dem Spezialschlüssel Rule.KEY zu den Metadaten des betreffenden Property hinzugefügt werden.

Formular-basierte (Feld-übergreifende) Validierungen

Solche Validierungen werden über spezielle Regeln implementiert, die die JavaBean als Teil ihres Validierungskontextes erwarten und die Daten der anderen benötigten Felder aus dieser JavaBean mittels Reflection extrahieren.

Check der Formular-basierten Validierungen erst wenn alle Einzelfeld-Validierungen fehlerfrei sind

Da die Validierungen, die sich lediglich auf ein Feld beziehen, weniger aufwendig sind, als solche, die mehrere Felder einbeziehen, werden zunächst nur Regeln angewendet, die sich auf ein Feld beziehen.

Erst keine der derartigen Regeln mehr einen Verstoß anzeigt, werden die komplexeren Regeln, die mehr als ein Feld einbeziehen, getestet.

Hierarchisierung von Regeln

Die Hierarchisierung von Regeln wird angewendet, um komplexe Regeln zu dekomponieren und zu modularisieren. Zum Beispiel wäre etwa die Regel "Das Feld soll eine Integer-Zahl zwischen 3 und 9 beinhalten" in folgende Regeln zu dekomponieren:

1. Das Eingabefeld darf nicht leer sein
2. Der String im Eingabefeld darf keine für eine Integer-Zahl ungültigen Zeichen enthalten
3. Der Integer-Wert, der dem String im Eingabefeld entspricht, muß größer als 3 und kleiner als 9 sein

Diese Regeln werden in der Reihenfolge, die ihrer Nummerierung entspricht ausgeführt, wenn die Anwendung ihrer Vorgänger keinen Fehler erzeugt hat. Anderenfalls wird die Validierung an dieser Stelle unterbrochen.

Gleichberechtigte Menge von Regeln

Gleichberechtigte Regeln, die an ein und dasselbe Feld gebunden sind, werden validiert, egal ob andere Regeln bereits Fehler erzeugt haben oder nicht.

Ergebnis der Validierung

Das Ergebnis einer Validierung ist nicht nur die Aussage "es ist falsch (oder wahr)", sondern die Gründe "warum ist es falsch". Das bedeutet in der Praxis, daß das Ergebnis einer Validierung in einer Collection von Objekten besteht, deren toString()-Methode jeweils eine Fehlermeldung ergibt.

Wenn die Validierung erfolgreich war, ist diese Collection leer.

UI-Integration des Frameworks

Validierung ist natürlich nur die halbe Miete - die Ergebnisse der Validierung müssen dem Nutzer mitgeteilt werden. Parallel zur Entwicklung dieses Frameworks entstanden verschiedene Komponenten und Methoden, um die Validierung an entsprechende UI-Komponenten bzw -Methoden zu koppeln. Im folgenden sollen hier vier davon kurz mit Screenshots vorgestellt werden:

Das JavaBeansFramework

Formulardaten editieren in einer JTextPane

Beispiel in einer Webanwendung

Diese Webanwendung wurde mit dem Echo2-Framework erstellt.

Validierung in einem Textfeld

Die Dekoration, die auf EingabeFehler hinweist, ist hierbei an den Cursor gebunden.