Übersicht Struts Forms Allgemeines Was ist ein Java Bean Was ist

Übersicht Struts Forms
Dieses Tutorial gibt eine Übersicht der Form Klassen von Struts, welche Besonderheiten und
Unterschiede diese aufweisen.
Allgemeines
Autor:
Sascha Wolski
http://www.laliluna.de/tutorials.html – Tutorials für Struts, EJB, xdoclet und eclipse.
Datum:
September, 13th 2004
Software:
Struts Framework 1.2.6
PDF Download
http://www.laliluna.de/download/struts-forms-overview-de.pdf
Was ist ein Java Bean
Vorab sollte der Begriff Java Bean nochmal kurz erläutert werden. Java Beans sind nichts weiter
als Klassen die für ihre Ereignis-Verarbeitungen und Methoden bestimmte von Sun festgelegte
Namenskonversationen (Vorgaben) einhalten müssen. Sie werden schon seit Jahren bei der
Konstruktion grafischer Benutzeroberfläschen eingesetzt. Die Eigenschaften der Java Beans
werden, wie bei anderen Klassen auch, durch Attribute (Variablen) festgelegt. Nur darf bei Java
Beans keine dieser Attribute öffentlich (global) sein. Der Zugriff auf die Attribute erfolgt über
entsprechende Zugriffsmethoden. Die Java-Spezifikation sieht hier getter- und setter- Methoden
vor. Hat ein Java Bean ein Attribute name, so wird der Wert dieses Attributes mit einer Methode
setName() gesetzt und mit der Methode getName() ausgelesen.
Was ist eine ActionForm Klasse
Eine ActionForm Klasse ist ein JavaBean, dass Daten speichert, ähnlich einer Objekt-Klasse.
Diese ActionForm kann man einer Action in der struts-config.xml zu weisen. Es gibt für diese
ActionForm Klassen zwei Möglichkeiten der Nutzung.
•
Daten können gespeichert werden, mit denen man den Inhalt eines Formulars vorbelegen
möchte (Bsp.:Formular zum Editieren) oder die man in einer JSP Datei ausgegeben werden
sollen.
•
Struts schreibt nach dem Abschicken eines Formulars die Daten wieder in eine ActionForm
Im zweiten Fall muss der Entwickler häufig diese Daten validieren, ob die Daten im
entsprechenden Format sind und den richtigen Wertebereich haben, zum Beispiel ob eine
Emailadresse das richtige Format hat, ein Datum stimmt oder eine Zahl in einem Wertebereich
liegt. Das kann der Entwickler entweder per Hand in der dazugehörigen Action machen oder mit
der von der Klasse ActionForm bereitgestellten Methode validate(..). Eine weitere Möglichkeit ist
das festlegen von Regeln in einer XML Datei. Struts bietet eine Vielzahl von Validierungsregeln,
die man einem Feld in einem Formular zuordnen kann.
Varianten der ActionForm Klasse
Es existieren verschiedene Varianten der ActionForm Klasse, diese man in zwei große Bereiche,
ActionForms (Programmierung von Hand) und dynamische ActionForms (Generierung durch
Struts) unterteilt.
ActionForm (Programmierung per Hand)
Dabei erstellt der Entwickler eine Klasse die von der Klasse ActionForm abgeleitet wird.
Beispiel einer ActionForm Klasse, mit Validierung in der validate(..) Methode.
public class myActionForm extends ActionForm {
private String text = "Hello World!"
public String getText(){
return text;
}
public void setText(String text){
text = this.text;
}
public ActionErrors validate(
ActionMapping mapping,
HttpServletRequest request) {
ActionErrors actionErrors = new ActionErrors();
if(!text.equals("Hello World!"))
actionErrors.add("form", new ActionMessage("Error !!"));
}
return actionErrors;
}
Definition des Form-Beans in der struts-config.xml:
<form-beans>
<form-bean name="myForm" type="my.package.myActionForm" />
</form-beans>
Zugriff auf Form-Bean innerhalb der Action Klasse:
public class myAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
//casten der form als ActionForm
ActionForm myForm = (ActionForm) form;
//wert auslesen
System.out.println("TEXT=" + myForm.getItem());
}
return mapping.findForward("success");
}
Dynamische ActionForms (Generierung durch Struts)
Es wird bei einer dynamischen ActionForm (DynaActionForm) keine Klasse erstellt. Man definiert
das Bean und die dazugehörigen Eigenschaften in der struts-config.xml und Struts generiert die
Klasse temporär.
Definition des Form-Beans in der struts-config.xml:
<form-beans>
<form-bean name="myForm" type="org.apache.struts.action.DynaActionForm">
<form-property name="text" type="java.lang.String" initial="Hello World!"/>
</form-bean>
</form-beans>
Zugriff auf Form-Bean innerhalb der Action Klasse:
public class myAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
//casten der form als DynaActionForm
DynaActionForm myForm = (DynaActionForm) form;
//wert auslesen
System.out.println("TEXT=" + myForm.get("text"));
}
return mapping.findForward("success");
}
Validierung auf Basis von XML Regeln
Eine weitere Variante die sowohl für die dynamiche, aber auch für die normale ActionForm Klasse
exisitert, ist die Erweiterung einer XML basierenden Validierung der Eigenschaften. Man spricht
dabei von ValidatorForm und DynaValidatorForm Klassen. Die Zuordnung der XML Regeln für die
Validierung wird durch das name Attribut der dazugehörigen Action, definiert in der strutsconfig.xml, realisiert.
Hinweis:Bei allen Validator Forms muss das Validator-Plugin in der struts-config.xml geladen sein.
<plug-in className="org.apache.struts.validator.ValidatorPlugIn">
<set-property property="pathnames" value="/WEB-INF/validator-rules.xml"/>
</plug-in>
Beispiel einer nicht dynamischen ValidatorForm Klasse:
public class myValidatorForm extends ValidatorForm {
private String text = "Hello World!"
public String getText(){
return text;
}
public void setText(String text){
text = this.text;
}
}
Definition des Form-Beans in der struts-config.xml:
<form-beans>
<form-bean name="myForm" type="my.package.myValidatorForm" />
</form-beans>
Zugriff auf Form-Bean innerhalb der Action Klasse:
public class myAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
//casten der form als ValidatorForm
ValidatorForm myForm = (ValidatorForm) form;
//wert auslesen
System.out.println("TEXT=" + myForm.getItem());
}
return mapping.findForward("success");
}
Definition einer dynamischen ValidatorForm in der struts-config.xml:
<form-beans>
<form-bean name="myDynaForm"
type="org.apache.struts.validator.DynaValidatorForm">
<form-property name="item" type="java.lang.String" />
</form-bean>
</form-beans>
Beispiel für XML Validierung (validation.xml):
<form-validation>
<formset>
<form name="myDynaForm">
<field property="item"
depends="required">
<arg0 key="prompt.item"/>
</field>
</form>
</formset>
</form-validation>
Bei den ValidatorForms, ob nun dynamisch oder nicht, existiert eine weitere Variante, die eine
andere Vorgehensweise für die Zuordnung der XML Regeln zur Validierung benutzt. Dabei wird
das path Attribut der dazugehörigen Action, definiert in der struts-config.xml, genutzt und die
Regeln zur Validierung werden anhand des ausgerufenen Pfades ermittelt.
Die Klassen dazu heissen ValidatorActionForm oder DynaValidatorActionForm.
Besondere Varianten der ValidatorForm Klasse
Es existieren zwei besondere Varianten der ValidatorForm Klasse, die BeanValidatorForm (ab
Struts-Version 1.2.4) und LazyValidatorForm (ab Struts-Version 1.2.6).
Beide Klassen unterstützen wie die ValidatorForm Klasse die XML basierende Validierung von
Eigenschaften.
Die BeanValidatorKlasse wird genutzt um aus einer normalen Objektklasse (POJO) ein Bean zu
erzeugen. Dabei gibt man beim Anlegen des FormBeans in der struts-config.xml die Objektklasse
an.
Beispiel einer Objektklasse:
public class myPOJOClass {
private String text = "Hello World!"
public String getText(){
return text;
}
public void setText(String text){
text = this.text;
}
}
Definition des Form-Beans in der struts-config.xml
<form-beans>
<form-bean name="myForm" type="my.package.myPOJOClass" />
</form-beans>
Zugriff auf Form-Bean innerhalb der Action Klasse
public class myAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
//casten der form als BeanValidatorForm
BeanValidatorForm myForm = (BeanValidatorForm) form;
//wert auslesen
System.out.println("TEXT=" + myForm.get("text"));
}
return mapping.findForward("success");
}
Die LazyValidatorForm ist eine dynamische Variante der ValidatorForm, es muss also keine
Klasse erstellt werden. Definiert wird ein Bean vom Typ LazyValidatorForm in der strutsconfig.xml. Die Besonderheit dieser Klasse, es ist nicht mehr notwendig Eigenschaften (Variablen)
zu definieren. Die benötigten Eigenschaften werden von Struts ahand der übergebenen
Parameter erstellt.
Definition des Form-Beans in der struts-config.xml
<form-beans>
<form-bean name="testForm"
type="org.apache.struts.validator.LazyValidatorForm" />
</form-beans>
Ausschnitt aus JSP Datei:
<html:form action="/test">
<html:text property="text" />
<br>
<html:submit />
</html:form>
Zugriff auf Form-Bean innerhalb der Action Klasse:
public class myPOJOAction extends Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response) {
//casten der form als LazyValidatorForm
LazyValidatorFormtestForm = (LazyValidatorForm) form;
//wert auslesen
System.out.println("NAME=" + testForm.get("text"));
}
return mapping.findForward("success");
}
Übersicht der ActionForm Klassen
Form Typ
Besonderheiten
Validierung Dynamisch
ActionForm
Basis ActionForm Klasse, von dieser
erben alle Varianten von ActionForm
Klassen.
Nein
Nein
DynaActionForm
Dynamische Variante ActionForm
Klasse. Es wird keine Klasse benötigt.
Definition in struts-config.xml
Nein
Ja
ValidatorForm
XML basierende Validierung Zuordnung
der XML Regeln für Validierung anhand
des Attributes name der dazugehörigen
Action
Ja
Nein
DynaValidatorForm
Dynamische Variante der ActionForm
Klasse. Es wird keine Klasse benötigt.
Definition in struts-config.xml. XML
basierende Validierung
Ja
Ja
ValidatorActionForm
XML basierende Validierung.
Zurordnung der XML Regeln für
Validierung anhand des path Attributes
der dazugehörigen Action.
Ja
Nein
Ja
Ja
Ja
Nein
Dadurch können für das gleiche
Formbean unterschiedliche
Validierungen vorgenommen werden,
abhängig vom Action, in dem es
verwendet wird.
DynaValidatorActionForm Dynamische Variante der ActionForm
Klasse. XML basierende Validierung
Zurordnung der XML Regeln für
Validierung anhand des path Attributes
der dazugehörigen Action
Dadurch können für das gleiche
Formbean unterschiedliche
Validierungen vorgenommen werden,
abhängig vom Action, in dem es
verwendet wird.
BeanValidatorForm
XML basierende Validierung, Wird
genutzt um normale Objektklasse als
Form-Bean zu nutzen.
Form Typ
LazyValidatorForm
Besonderheiten
Dynamische Variante der ActionForm
Klasse. XML basierende Validierung, Es
ist nicht notwendig Eigenschaften zu
definieren.
Validierung Dynamisch
Ja
Ja