23A » Java http://blog.davidgraesser.de code snippets and more... Tue, 08 Nov 2011 21:14:52 +0000 en hourly 1 http://wordpress.org/?v=3.2.1 Größe einer Liste in einer JSP darstellen http://blog.davidgraesser.de/2011/01/06/grose-einer-liste-in-einer-jsp-darstellen/ http://blog.davidgraesser.de/2011/01/06/grose-einer-liste-in-einer-jsp-darstellen/#comments Thu, 06 Jan 2011 09:42:35 +0000 dave http://blog.davidgraesser.de/?p=204 Wieder mal ein klassisches, simples Problem. In einer JSP kann man nicht auf die Methode size() einer java.util.List zugreifen, das die JSTL mit dem Aufruf

  1. <c:out value=“${list.size}”/>

einen Getter erwartet und folgende Fehlermeldung produziert:

The “.” operator was supplied with an index value of type “java.lang.String” to be applied to a List or array…

Die Erstellung einer einfachen Wrapperklasse behebt dieses Problem:

  1. public class ListWrapper {
  2.         private List list;
  3.  
  4.         public ListWrapper() {
  5.             this.list = new ArrayList();
  6.         }
  7.  
  8.         public int getSize() {
  9.             return list.size();
  10.         }
  11.  
  12.         public List getList() {
  13.             return list;
  14.         }
  15.     }

Die Idee zur Lösung habe ich Buch Core JSTL von David M. Geary gefunden.

Quelle

Sollte man functions-Bibliothek “fn” nutzen, kann man natürlich die Funktion
fn:length verwenden.

]]> http://blog.davidgraesser.de/2011/01/06/grose-einer-liste-in-einer-jsp-darstellen/feed/ 2 Selenium & TestNG http://blog.davidgraesser.de/2010/05/04/selenium-testng/ http://blog.davidgraesser.de/2010/05/04/selenium-testng/#comments Tue, 04 May 2010 14:45:58 +0000 dave http://blog.davidgraesser.de/?p=134 Hier eine Liste mit Problemen die ich beim ersten Einsatz vom Selenium & TestNG hatte und keine direkte Problemlösung im Netz gefunden habe.

Problem 1:
Man kann seine TestSuiten in mehrere SubSuiten unterteilen und über mehrere XML-Konfigurationen definieren.
Bsp:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <suite name=“suiten” verbose=“10″>
  3.         <suite-files>
  4.                 <suite-file path=“suiten/myTest1.xml”/>
  5.         </suite-files>
  6.         <suite-files>
  7.                 <suite-file path=“suiten/myTest2.xml”/>
  8.         </suite-files>
  9. </suite>

Leider kommt es bei diesem Setup zu einer NullPointerException

  1. [TestNG] Reporter org.testng.reporters.XMLReporter@be0e27 failed
  2. java.lang.NullPointerException
  3.         at java.util.Calendar.setTime(Unknown Source)
  4.         at java.text.SimpleDateFormat.format(Unknown Source)
  5.         at java.text.SimpleDateFormat.format(Unknown Source)
  6.         at java.text.DateFormat.format(Unknown Source)
  7.         at org.testng.reporters.XMLReporter.addDurationAttributes(XMLReporter.java:144)

Scheinbar verlangt TestNG das in jedem Suite-File mind. ein konkreter Test enthalten ist.
Mit diesem Setup hats dann funktioniert:

  1. <?xml version=“1.0″ encoding=“UTF-8″?>
  2. <suite name=“suiten” verbose=“10″>
  3.         <suite-files>
  4.                 <suite-file path=“suiten/myTest1.xml”/>
  5.         </suite-files>
  6.         <suite-files>
  7.                 <suite-file path=“suiten/myTest2.xml”/>
  8.         </suite-files>
  9.         <test name=“StartStop”>
  10.                 <classes>
  11.                         <class name=“de.test.java.FakeTest”/>
  12.                 </classes>
  13.         </test>
  14. </suite>

Problem 2:
Um den kompletten Inhalt eines HTML-Elementes auszulesen gibt es folgende Möglichkeit:

  1. String tableContent = session().getAttribute(“//form[@id='test']/div/table”);

Dabei konnte allerdings der XPath durch die SingleQuotes nicht korrekt aufgelöst werden.

  1. ERROR: Invalid xpath: XPath parse error

Mit getText hats dann geklappt:

  1. String tableContent = session().getText(“//form[@id='test']/div/table”);

Im String tableContent sind dann alle sichtbaren Inhalte der Tabelle, durch Whitespaces getrennt, enthalten.

]]> http://blog.davidgraesser.de/2010/05/04/selenium-testng/feed/ 2 JMeter und SSL-Verbindungen http://blog.davidgraesser.de/2009/01/12/jmeter-und-ssl-verbindungen/ http://blog.davidgraesser.de/2009/01/12/jmeter-und-ssl-verbindungen/#comments Mon, 12 Jan 2009 09:14:46 +0000 dave http://blog.davidgraesser.de/?p=87 Für das verteilte Testen von Anwendungen mit JMeter ergibt sich die Problematik das man bei verschlüsselten Verbindungen in den JMeter-Clients bei jedem Start das Zertifikatspasswort eingeben müsste. Um dies zum umgehen kann man einen Keystore generieren und diesen dann in den JMeter-Properties angeben.

Den Keystore erzeugt man sich mit keytool, welches mit Java ausgeliefert wird.

  1. keytool -importkeystore -deststorepass myPassword -destkeystore myKeystore -srckeystore myZertifikat.p12 -srcstoretype PKCS12 -srcstorepass myPassword
  2.  

Achtung: Das Passwort für den Keystore muss identisch sein mit dem Passwort des Zertifikates
Die Erzeugung des Keystores mit diesen Parametern funktioniert nur mit Java-6.

in den jmeter.properties müssen folgende angaben gemacht werden:

  1. # Location of the keystore
  2. javax.net.ssl.keyStore=C:\\myKeystore
  3.  
  4. #The password to your keystore
  5. javax.net.ssl.keyStorePassword=myPassword

Bei Änderungen in den jmeter.properties muss JMeter neu gestartet werden.

Die Lösung lässt sich natürlich auch für Einzelplatz-Test benutzen. Übrigens wenn man den “normalen” Weg über den SSL-Manager geht, nicht wundern das die Zertifikatspasswordabfrage nicht erscheint wenn man das Zertifikat gerade hinzugefügt hat. Die Nachfrage nach diesem Passwort kommt erst wenn man den Test startet.

]]> http://blog.davidgraesser.de/2009/01/12/jmeter-und-ssl-verbindungen/feed/ 1 Struts RadioBox-List http://blog.davidgraesser.de/2008/04/30/struts-radiobox-list/ http://blog.davidgraesser.de/2008/04/30/struts-radiobox-list/#comments Wed, 30 Apr 2008 10:29:28 +0000 dave http://blog.davidgraesser.de/?p=82 Um mit Struts eine Liste mit Radioboxen ausgeben zu können, muss man einen kleinen Kniff anwenden um den Value der Radiobox zu setzten:

  1. <nested:iterate property=“myRadioOptions”>
  2. <nested:define id=“actualRadioValue” property=“radioValue” type=“java.lang.String”/>
  3. <nested:radio value=‘<%=actualRadioValue%>’ property=“myRadioList”/>
  4. </nested:iterate>
]]> http://blog.davidgraesser.de/2008/04/30/struts-radiobox-list/feed/ 0 Dynamischer JSP-Include http://blog.davidgraesser.de/2008/04/08/dynamischer-jsp-include/ http://blog.davidgraesser.de/2008/04/08/dynamischer-jsp-include/#comments Tue, 08 Apr 2008 12:30:12 +0000 dave http://blog.davidgraesser.de/?p=78
  1. <nested:define id=‘actualLink’ property=‘formBean.variable’ type=‘String’/>
  2. <jsp:include flush=“true” page=“<%=”anmeldung/step“+actualLink+”.jsp“%>”/>
]]> http://blog.davidgraesser.de/2008/04/08/dynamischer-jsp-include/feed/ 0 HTML > DWR > JAVA > JSON > HTML http://blog.davidgraesser.de/2007/11/09/html-dwr-java-json-html/ http://blog.davidgraesser.de/2007/11/09/html-dwr-java-json-html/#comments Fri, 09 Nov 2007 17:05:28 +0000 dave http://blog.davidgraesser.de/?p=54 Um Daten in einer Java-Webanwendung dynamisch nachzuladen bietet sich das AJAX-Framework Direct Web Remoting [DWR] an. Mit diesem ist es möglich Java Methoden aus JavaScript aus aufzurufen und die Ergebnismenge zu empfangen. Da JavaScript mit den Objektstrukturen von Java nichts anfangen kann, müssen die Daten zuvor in JSON-Strings verpackt werden.

An einem praktischem Beispiel soll dies gezeigt werden. Wir haben 2 Dropdown-Boxen die in Abhängigkeit zueinander stehen. In der oberen Dropdownbox wählt man einen Zyklus (Täglich,Wöchentlich,Monatlich) aus und die unterer Dropdownbox soll ihre Inhalte entsprechend anpassen.
doubledropdown.png
Als erstes werden die benötigten Javaklassen erzeugt.
Da es sich im Optionsfelder handelt, gibt es eine Basisklasse mit dem Name OptionElement. Diese Klasse hat alle Attribute die auch das Option-Element in HTML hat. Zusätzlich kommt noch das Attribut order hinzu, welches die Reihenfolge innerhalb des Select-Elementes repräsentiert. Da bei der Serialisierung (Java->JSON), die Objektreihenfolge verworfen wird.

  1. public class OptionElement {
  2.         private int order;
  3.         private String id;
  4.         private String name;
  5.         private boolean disabled;
  6.         private boolean selected;
  7.  
  8.         public OptionElement() {
  9.             this.selected = false;
  10.             this.disabled = false;
  11.         }

von dieser Klasse erben die 2 folgenden Klassen:
Die Klasse Zyklus entspricht der 1.Dropdownbox und hat als “Kindelemente” alle zugehörigen Elemente der 2.Dropdownbox.

  1. public class Zyklus extends OptionElement {
  2.         private Collection<ZyklusDetails> zyklusDetailsList;
  3.         public Zyklus() {
  4.             super();
  5.             this.zyklusDetailsList = new ArrayList<ZyklusDetails>();
  6.         }
  7. }

Die Klasse Zyklusdetails enspricht der 2.Dropdownbox

  1. public class ZyklusDetails extends OptionElement {
  2.         public ZyklusDetails() {
  3.             super();
  4.         }
  5.     }

Nach dem eine konkrete Ausprägung der Zyklen erstellt wurde, werden diese in ein JSON-Objekt transferiert. Hierbei kommt die klassische JSON-Bibliothek zum Einsatz gekommen. Es gibt auch Alternativen, wie zum Beispiel FLEXJSON, welches “automatisch” Objektreferenzen auflöst und serialisiert. Dies muss bei dieser Bibliothek händisch gelöst werden.

Wir haben natürlich mehrere Zyklusobjekte, die in einem Array gesammelt wurden. Dieses Array wird jetzt durchlaufen und in JSON-Objekte serialisert.

  1. public JSONObject convertZyklenToJSON(Zyklen zyklen) {
  2.         try {
  3.             JSONObject zyklenJSON = new JSONObject();
  4.  
  5.             for (Zyklus z : zyklen.getZyklusList()) {
  6.                 JSONObject zyklus = new JSONObject(z);
  7.  
  8.                 for (ZyklusDetails zd : z.getZyklusDetailsList()) {
  9.                     zyklus.put(zd.getId(), new JSONObject(zd));
  10.                 }
  11.  
  12.                 zyklenJSON.put(z.getId(), zyklus);
  13.             }
  14.  
  15.             return zyklenJSON;
  16.         } catch (JSONException e) {
  17.             e.printStackTrace();
  18.         }
  19.  
  20.         return null;
  21.     }

Anschließend werden die JSON-Objekte in ein JSON-String verpackt und an die aufrufende JavaScript-Funktion zurück gesendet.

  1. public String getZyklus() {
  2.         JSONObject data = new JSONObject();
  3.         try{
  4.         data.put(“Zyklen”, convertZyklenToJSON(getZyklen()));
  5.         data.put(“Format”,  convertFormatToJSON(getFormat()));
  6.         }catch (JSONException e) {
  7.             e.printStackTrace();
  8.         }
  9.         return data.toString();
  10.     }

Zusätzlich wird an dieser Stelle noch eine weitere Funktion (convertFormatToJSON) aufgerufen. Dies soll einfach nur zeigen das x-beliebig viele JSON-Objekte in ein JSON-String gepackt werden können und diese auch später wieder leicht auf der JavaScript-Seite aufgelöst werden können.
Folgende JavaScriptFunktion empfängt den JSON-String und schreibt die Objekte, je nach Objekttyp (Zyklus oder Format) in seperate Arrays, um diese im Anschluss weiterzuverarbeiten.

  1. getZyklusData: function (data){ 
  2.         //BerichtAboAccess.getZyklus(2, function(data) {
  3.  
  4.                 zyklusDataDB = new Function(“return “ + data)(  );
  5.                                   
  6.                   for(var prop in zyklusDataDB)
  7.                 {
  8.                         for(var propDetail in zyklusDataDB[prop]){
  9.                                 var className = zyklusDataDB[prop][propDetail].class;
  10.                                 switch ((className.substring(className.lastIndexOf(‘$’)+1,className.length))){
  11.                                         case “Format”: formatData.push(zyklusDataDB[prop][propDetail]);
  12.                                                 break;
  13.                                        
  14.                                         case “Zyklus”:  zyklusData.push(zyklusDataDB[prop][propDetail]);
  15.                                                 break;
  16.                                 }
  17.                          }
  18.                         }
  19.                         formatData.sort(this.Keysort);
  20.                         this.sortZyklusArray();
  21.                         this.initialisiereZyklusChooser(); 
  22.                         this.initialisiereFormatChooser();     
  23. }

Die beiden Arrays formatData und zyklusData wurden außerhalb der Funktion, als globale Variablen angelegt.
Da bei der Serialisierung die Reihenfolge der Objekte komplett verworfen wurde, werden in der Funktion sortZyklusArray, die Elemente nach dem Attribute order sortiert. Dafür wurde die Standard Keysort-Methode überschrieben:

  1. Keysort: function  (a, b) {
  2.           if (a.order<b.order) return -1;
  3.           if (a.order>b.order) return 1;
  4.           return 0;
  5.         }

Die folgende Methode durchläuft das Zyklusarray und nutzt die überschriebende Keysort-Methode zum sortieren:

  1. sortZyklusArray: function (){
  2.                 zyklusData.sort(this.Keysort);
  3.                 for (var i = 0; i < zyklusData.length; ++i){
  4.                         var zyklusDetails = new Array();
  5.                         for(j in zyklusData[i]){
  6.                                 if(zyklusData[i][j].id  != undefined){
  7.                                         zyklusDetails.push(zyklusData[i][j]);
  8.                                 }
  9.                         }
  10.                        
  11.                         zyklusDetails.sort(this.Keysort);
  12.                        
  13.                         count = 0;
  14.                         for(k in zyklusData[i]){
  15.                                 if(zyklusData[i][k].id != undefined){
  16.                                         zyklusData[i][k] = zyklusDetails[count];
  17.                                         count++;
  18.                                 }
  19.                         }
  20.                 }                     
  21.         }

Die folgende Methode, erzeugt die Optionsfelder in den Select-Elementen und setzt dabei auch die Attribute selected oder disabled:

  1. initialisiereZyklusChooser:      function ()
  2.         {          
  3.                 var selectedZyklus = 0;
  4.                 for (var i = 0; i < zyklusData.length; ++i){
  5.                         var objOption = document.createElement(“OPTION”);
  6.             objOption.text= zyklusData[i].name;
  7.             objOption.value= zyklusData[i].id;
  8.                        if(zyklusData[i].disabled == true){
  9.                                 objOption.disabled = true;
  10.                         }
  11.                        
  12.                         if(zyklusData[i].selected == true){
  13.                                 objOption.selected = true;
  14.                                 DWRUtil.removeAllOptions(detailsChooser);
  15.                                 selectedZyklus = zyklusData[i].id;
  16.                         }      
  17.                   zyklusChooser.options.add(objOption);
  18.                   for(var j in zyklusData[i])
  19.                   {
  20.                    //Standardmäßig ist Täglich ausgewählt
  21.                    if(zyklusData[i][j].id != undefined)
  22.                    {
  23.                       if((selectedZyklus == 0 && zyklusData[i].id == “z1″) | (zyklusData[i].id == selectedZyklus))
  24.                       var objOption = document.createElement(“OPTION”);
  25.                             objOption.text= zyklusData[i][j].name;
  26.                             objOption.value= zyklusData[i][j].id;
  27.                             if(zyklusData[i][j].disabled == true){
  28.                                 objOption.disabled = true;
  29.                             }
  30.                             if(zyklusData[i][j].selected == true){
  31.                                 objOption.selected = true;
  32.                             }
  33.                             detailsChooser.options.add(objOption);                    
  34.                    }
  35.                   }
  36.                 }
  37.                 this.toogleChooser(zyklusChooser);
  38.                 this.toogleChooser(detailsChooser);
  39.         }

Wenn ein Select-Element nur ein Attribut hat, setzt die Methode toogleChooser, dieses Element auf disabled, da eh keine weiteren Elemente zur Auswahl stehen.

  1. toogleChooser: function (chooser){
  2.                 if(chooser.options.length == 1) chooser.disabled = true;
  3.                 else chooser.disabled = false;
  4.         }

Die folgende Methode wird aufgerufen, wenn das onChange-Event in der ersten Dropdownbox ausgelöst wird:

  1. onChangeZyklus: function (){
  2.                 for (var i = 0; i < zyklusData.length; ++i){                                                                                                  
  3.                   if(zyklusData[i].id == $F(zyklusChooser)){
  4.                         DWRUtil.removeAllOptions(detailsChooser);
  5.                           for(var j in zyklusData[i]){
  6.                            if(zyklusData[i][j].id != undefined)
  7.                            {
  8.                               var objOption = document.createElement(“OPTION”);
  9.                                     objOption.text= zyklusData[i][j].name;
  10.                                     objOption.value= zyklusData[i][j].id;
  11.                                     if(zyklusData[i][j].disabled == true){
  12.                                         objOption.disabled = true;
  13.                                     }
  14.                                     detailsChooser.options.add(objOption);              
  15.                            }   
  16.                           }
  17.                           this.toggleDetailsSelectStatus(“detailsChooser”);
  18.                         }
  19.                 }
  20.         }

Die Methode xxx ist nur eine Spielerei und verfärbt kurz die untere Dropdownbox, um die Veränderung zu verdeutlichen.

  1. toggleDetailsSelectStatus: function (selectField){
  2.                 new Effect.Highlight(selectField, {startcolor:‘#FEF6DC’, endcolor:‘#FFFFFF’, duration:1});     
  3.                 this.toogleChooser(detailsChooser);
  4.         }

Dazu wurde folgende Funktion aus der script.aculo.us-Bibliothek verwendet.

urls:
http://pragprog.com/titles/cppsu
http://scripteka.com/
http://prototype-graphic.xilinus.com/
http://blog.xilinus.com/2007/11/4/prototype-ui-beta-version-pwc-reloaded

]]> http://blog.davidgraesser.de/2007/11/09/html-dwr-java-json-html/feed/ 0 Struts & Spring http://blog.davidgraesser.de/2007/11/09/struts-spring/ http://blog.davidgraesser.de/2007/11/09/struts-spring/#comments Fri, 09 Nov 2007 15:34:21 +0000 dave http://blog.davidgraesser.de/?p=50 Kurzanleitung um eine Seite mit Struts und Spring zu erstellen.
Ziel ist es eine URL foo.do aufzulösen und eine JSP aufzurufen, wobei die Inhalte der JSP über eine extra Transformationsklasse populiert werden sollen. Zusätzlich soll ein URL-Parameter ausgewertet werden. Hierbei handelt es sich um eine spezifische Beschreibung einer bestehenden Ausgangskonfiguration und ist nicht allgemein anwendbar.

Die Testseite liegt in einem Unterverzeichnis des webapp/tpl-Verzeichnisses: webapp/tpl/reports/berichtsAbo.jsp

Auf einer x-beliebigen Seite wird der Link eingefügt:

  1. <html:link page=“/reports/abo.do?status=new”>Link</html:link>

In der Datei struts-action.xml wird die URL aufgelöst und eine Actionklasse zugewiesen:

  1. <bean name=“/reports/abo”
  2.             class=“packageX.ReportsAboAction”
  3.             parent=“displayOnlyAction”>
  4.       <property name=“transformationRegistry” ref=“transformationRegistry” />
  5.      </bean>

Die Klasse TransformationRegistry wird in der ReportsAboAction benötigt und wird zur Laufzeit via Dependency Injection zugeordnet. Zusätzlich erbt die Klasse von DipsplayOnlyAction.

Der Formdeskriptor ReportsAbo zur Action sieht wie folgt aus:

  1. :extends de.sci.commons.web.struts.PersistableForm
  2. emailadresse "Email-Adresse" email
  3. status "Status" opt

Daraus wird eine Formbeanklasse ReportsAboForm erzeugt, welche Getter/Setter Methoden für die Attribute bereitstellt.

In der Klasse ReportsAboAction.java wird zunächst die Form angegeben die verwendet werden und die ein Pfad zur JSP Datei der via Tiles aufgelöst wird:

  1. /**
  2. * Reports Abo Action.
  3. * @struts.action path = "/reports/abo" name = "reportsAboForm" scope = "session"
  4. * @struts.action-forward name = "show" path = "reports.abo"
  5. */

In der Datei tiles-defs.xml wird der Pfad aufgelöst und einer konkreten JSP-Datei zugewiesen:

  1. <definition name=“reports.abo” extends=“main”>
  2.                 <put name=“title” value=“Bericht abonnieren” />
  3.                 <put name=“body” value=“/tpl/reports/berichtAbo.jsp”/>
  4.         </definition>

Die Transformationsklasse ReportsAboTF soll Werte in die Formbean schreiben und lesen. In der Datei transformation.xml werden die Transformationsklassen angegeben und über eine TransformationRegistry registriert.

  1. <bean id=“reportsAboTF”
  2.     class=“transformation.ReportsAboTF”>
  3.   </bean>
  4.  
  5.   <bean id=“transformationRegistry”
  6.     class=“transformation.TransformationRegistry”>
  7.     <property name=“transformations”>
  8.       <set>
  9.         <ref local=“reportsAboTF” />
  10.       </set>
  11.     </property>
  12.   </bean>

Im Konstruktor der Transformationsklasse ReportsAboTF werden sowohl die Formbean-Klasse als auch die Domainklasse angegeben:

  1. public ReportsAboTF() {
  2.         setDomainObjectClass(ReportsAbo.class);
  3.         setFormBeanClass(ReportsAboForm.class);
  4.     }

Diese Klasse hat eine Methode populateFormBean in der die Domainobjektattribute in die Formbeanattribute geschrieben werden:

  1. public void populateFormBean(BaseForm formBean, Object domainObject,
  2.         TransformationContext context) {
  3.         ReportsAbo rAbo = (ReportsAbo) domainObject;
  4.         ReportsAboForm reportsAboForm = (ReportsAboForm) formBean;
  5.         reportsAboForm.setEmailadresse(rAbo.getEmail());
  6.     }

In der ReportsAboAction wird zunächst die passende Transformationsklasse aus der TransformationRegistry geholt

  1. protected Transformation getTransformation(HttpServletRequest request) {
  2.         return new TransformationWrapper(transformationRegistry.getTransformation(
  3.                 ReportsAbo.class, ReportsAboForm.class));
  4.     }

Über dieses Objekt kann dann die populateFormBean-Methode aufgerufen werden.
Der Ablauf in der Actionklasse ist folgender Maßen. Standardmäßig wird die excute-Mehtode aufgerufen:

  1. public ActionForward execute(ActionMapping mapping, ActionForm form,
  2.         HttpServletRequest request, HttpServletResponse response) {
  3.         ReportsAboForm reportsAboForm = (ReportsAboForm) form;
  4.  
  5.         String typeName = getParameter(request, PARAM_STATUS);
  6.  
  7.         if (typeName != null) {
  8.             try {
  9.                 Type type = Type.valueOf(typeName.toUpperCase());
  10.  
  11.                 switch (type) {
  12.                 case NEW:
  13.                     initForm(request, reportsAboForm);
  14. …

In der Methode initForm wird Formbean zurückgesetzt und ein neues Domainobjekt erzeugt:

  1. protected void initForm(HttpServletRequest request, BaseForm baseForm) {
  2.         ReportsAboForm form = (ReportsAboForm) baseForm;
  3.         form.reset();
  4.         ReportsAbo rAbo = new ReportsAbo();
  5.         form.setStatus(“NEW”);
  6.         form.setPropertyPathAccess(new EmptyPropertyPathAccess());
  7.         ActionContext.resetSessionAttributes(this, request);
  8.  
  9.         populateWithDeletion(request, form, rAbo, null);
  10.     }

In der Methode populateWithDeletion wird die populateFormBean-Methode der Transformationsklasse aufgerufen:

  1. protected void populateWithDeletion(HttpServletRequest request, BaseForm baseForm,
  2.             Object domainObject, StatePreserve statePreserve) {
  3.             Transformation tf = getTransformation(request);
  4.             tf.populateFormBean(baseForm, (IPersistentCapable) domainObject,
  5.                 new TransformationContext(request, null));
  6.         }

In der zugehörigen JSP Seite wird die Formbean in einer Variable gesetzt:

  1. <c:set var=“item” value=“${reportsAboForm}” />

Über

  1. <c:out value=“${item.emailadresse}”/>

Kann man auf den Wert zugreifen der in der Formbean gesetzt ist.

Strukturdiagramm

Links:
JSP-Tag-Reference
Gute Struts-Einführung

]]> http://blog.davidgraesser.de/2007/11/09/struts-spring/feed/ 0