Kuchen-Zutat-Beispiel mit Struts 7

  public abstract class BaseAction extends ActionSupport
  {
    private KuchenZutatWorkerLocal kuchenZutatWorker = null;

    protected KuchenZutatWorkerLocal getWorker() throws Exception
    {
      if (this.kuchenZutatWorker == null)
      {
        try
        {
          InitialContext initialContext = new InitialContext();
          this.kuchenZutatWorker = (KuchenZutatWorkerLocal) initialContext.lookup ("java:comp/env/ejb/KuchenZutatWorkerLocal");;
        }
        catch (NamingException ex)
        {
          throw new Exception("JNDI-Lookup von 'java:comp/env/ejb/KuchenZutatWorkerLocal' schlug fehl mit (" + ex.getClass().toString() + "): " + ex.getMessage(), ex);
        }
      }
      
      return this.kuchenZutatWorker;
    }
  }

<s:url var="editUrl" action="zutatedit">
  <s:param name="kuchen.id" value="kuchen.id"></s:param>
  <s:param name="id" value="id"></s:param>
</s:url>

public class ZutatEditAction extends BaseAction 
{
  ...
  public KuchenBean getKuchen()
  {
    return this.kuchen;
  }
  ...
}

  @StrutsParameter(depth = 1)
  public KuchenBean getKuchen()
  {
    return this.kuchen;
  }

    <constant name="struts.allowlist.classes" value="de.hsrm.jakartaee.knauf.kuchenzutatstruts.KuchenBean, de.hsrm.jakartaee.knauf.kuchenzutatstruts.ZutatBean"/>

• Auf der Seite "kuchenliste.jsp" wird der Button "Neuer Kuchen" geklickt, der so definiert ist:
  

  <s:form id="formkuchenneu" action="kuchenneu">
      <s:submit id="kuchenneu" value="Neuer Kuchen"></s:submit>
    </s:form>

• Die zugehörige Action "kuchenneu" in "struts.xml" is so definiert:
  

    <action name="kuchenneu" class="de.hsrm.jakartaee.knauf.kuchenzutatstruts.actions.KuchenNeuAction">
      <result>/kuchendetail.jsp</result>
    </action>

• KuchenNeuAction ist eine leere Action, die nur "success" zurückgibt.
  

    public class KuchenNeuAction extends BaseAction 
    {
      public String execute() throws Exception
      {
        return Action.SUCCESS;
      }
    }

  
  
• Die Zielseite der Action bei Erfolg ist "kuchendetail.jsp".
  Dort wird ein Eingabeformular aufgebaut.
  

    <s:form action="kuchensave">
      <s:hidden name="kuchen.id"></s:hidden>
      <s:textfield name="kuchen.name" label="Name"></s:textfield> <br/>
      <br/>
      <s:submit value="OK"></s:submit>
    </s:form>

  Dieses Formular greift auf Properties "kuchen.id" und "kuchen.name" zu, die allerdings bei einem neuen Kuchen nicht existieren. Hätten wir der KuchenNeuAction eine Methode getKuchen gegeben, so würden deren Properties "id" und "name" als Defaults in das Eingabefeld und das Hidden Field geschrieben.
  
  
• Ein Klick auf "OK" führt zur Action "kuchensave", die in "struts.xml" so definiert ist:
  

    <action name="kuchensave" class="de.hsrm.jakartaee.knauf.kuchenzutatstruts.actions.KuchenSaveAction">
        <result>/kuchenliste.jsp</result>
    </action>

  (in der Beispielanwendung steht hier noch mehr, dazu mehr im Abschnitt "Validator").
  
  
• Die Ziel-Action KuchenSaveAction wird aufgerufen beim Speichern eines neuen sowie beim Speichern eines vorhandenen Kuchens. Sie enthält eine Property "kuchen". In diese Property werden die Felder "kuchen.id" und "kuchen.name" von "kuchendetail.jsp" beim Submit geschrieben. In unserem Fall (Anlegen eines neuen Kuchens) ist die ID natürlich leer !
  

    public class KuchenSaveAction extends BaseAction 
    {
      private KuchenBean kuchen = new KuchenBean();
      
      public String execute() throws Exception
      {
        KuchenBean kuchenSave = null;
        if (this.kuchen.getId() != null)
        {
          kuchenSave = this.getWorker().findKuchenById(this.kuchen.getId() );
        }
        else
        {
          kuchenSave = new KuchenBean();
        }
        
        kuchenSave.setName(this.kuchen.getName());
        
        this.getWorker().saveKuchen(kuchenSave);
        
        return Action.SUCCESS;
      }
      
      @StrutsParameter(depth = 1)
      public KuchenBean getKuchen()
      {
        return this.kuchen;
      }
    } 

  Beim Execute wird geprüft, ob die ID der Kuchen-Instanzvariable vorhanden ist. Wenn ja, dann handelt es sich um einen vorhandenen Kuchen, ansonsten um einen neuen. Im Fall des vorhandenen Kuchens wird dieser aus der Datenbank geladen, ansonsten wird ein neuer Kuchen erzeugt. Anschließend werden die Felder der Instanzvariable "kuchen" umkopiert. Dies ist nötig, da die Felder dieser Instanzvariable zwar von Struts mit den aktuell eingegebenen Daten befüllt werden, aber falls der Kuchen abhängige Daten enthalten würde, dann würden diese wahrscheinlich nicht mitgeführt.
  Der so befüllte Kuchen wird gespeichert.
  
  
• Die Action führt zur kuchenliste.jsp (siehe Auszug aus struts.xml weiter oben).

• Ausgangspunkt ist wieder kuchenliste.jsp, in der pro Kuchen ein Bearbeiten-Formular definiert ist.
  

    <s:iterator value="#kuchenliste.kuchenListe">
    ...
      <s:form id="formkuchenedit" action="kuchenedit">
        <s:hidden name="id"></s:hidden>
        <s:submit id="kuchenedit" value="Bearbeiten"></s:submit>
      </s:form>
    ...
    </s:if>

  Im Iterator-Tag wird die Kuchenliste durchlaufen, d.h. das Hidden Field für die Kuchen-ID greift auf getId des aktuellen Kuchens zu. Struts mappt "id" automatisch auf das aktuelle Iterator-Objekt.
  
  
• Die Action "kuchenedit" ist in struts.xml so definiert:
  

    <action name="kuchenedit" class="de.hsrm.jakartaee.knauf.kuchenzutatstruts.actions.KuchenEditAction">
        <result>/kuchendetail.jsp</result>
    </action>

• KuchenEditAction definiert eine Methode "setId", in die Struts die Kuchen-ID aus dem Hidden Field "id" beim Submit schreibt:
  

      private Integer intKuchenId = null;
    
      @StrutsParameter
      public void setId(Integer int_KuchenId)
      {
        this.intKuchenId = int_KuchenId;
      } 

  Außerdem wird eine Variable "kuchen" sowie zugehöriger getter definiert, die nach dem execute die Daten des Kuchens enthalten:
  

      private KuchenBean kuchen = null;
    
      public KuchenBean getKuchen()
      {
        return this.kuchen;
      }

  execute lädt den Kuchen zur Kuchen-ID ein:
  

      public String execute() throws Exception
      {
        this.kuchen = this.getWorker().findKuchenById(this.intKuchenId);
        
        return Action.SUCCESS;
      }

• Weiter geht es auf "kuchendetail.jsp" (siehe Deklaration in struts.xml). Hier wird das aus dem letzten Kapitel bekannte Formular aufgebaut, wobei diesmal ID und Name aus den Properties der KuchenEditAction gezaubert werden: getKuchen.getId bzw. getKuchen.getName().

    <s:form action="kuchensave">
      <s:hidden name="kuchen.id"></s:hidden>
      
      <s:textfield name="kuchen.name" label="Name"></s:textfield> <br/>
      <br/>
      <s:submit value="OK"></s:submit>
    </s:form>
    
    <s:if test="kuchen.id != null">
      <table>
        ...
        <tbody>
          <s:iterator value="kuchen.zutaten">
            <tr>
              <td>
                <s:property value="id"/>
              </td>
              <td>
                <s:property value="zutatName"/>
              </td>
              <td>
                <s:property value="menge"/>
              </td>
              <td>
                <s:form id="formzutatedit" action="zutatedit">
                  <s:hidden name="kuchen.id"></s:hidden>
                  <s:hidden name="id"></s:hidden>
                  <s:submit id="zutatedit" value="Bearbeiten"></s:submit>
                </s:form>
              </td>
              <td>
                <s:form id="formzutatdelete" action="zutatdelete">
                  <s:hidden name="kuchen.id"></s:hidden>
                  <s:hidden name="id"></s:hidden>
                  <s:submit id="zutatdelete" value="Löschen"></s:submit>
                </s:form>
              </td>
            </tr>
          </s:iterator>
        </tbody>
      </table>
      ...
    </s:if> 

  Neu hier: die Zutaten werden ausgegeben (und zwar nur, wenn die Kuchen-ID nicht NULL ist, denn in diesem Fall würde es sich um einen neuen Kuchen handeln).
  Beim Aufbau der Zutatentabelle wird die Methode getKuchen().getZutaten() der Action aufgerufen.
  Beim Bearbeiten- und Löschen-Formular wird die Kuchen-ID aus getKuchen().getId() als Hidden Field mitgeführt (die Zutat bietet ja leider keine Möglichkeit, an die Kuchen-ID zu gelangen). Die Zutat-ID wird aus der aktuellen Schleifen-Zutat mittels getId() geholt. Man erkennt hoffentlich, dass es eventuell sinnvoll wäre, die ID-Felder in den Entity-Beans eindeutig zu benennen !
  Diese Hidden Fields "kuchen.id" und "id" bedingen besondere Logik im nächsten Schritt !
  
  
• Die Action "zutatedit" ist in struts.xml so definiert:
  

    <action name="zutatedit" class="de.fhw.komponentenarchitekturen.knauf.kuchenzutatstruts.actions.ZutatEditAction">
        <result>/zutatdetail.jsp</result>
    </action>

• ZutatEditAction enthält drei Felder: eine Zutat-ID, eine Zutat sowie einen Kuchen.
  

    public class ZutatEditAction extends BaseAction 
    {
      private ZutatBean zutat = null;
      
      private Integer intZutatId = null;
      
      private KuchenBean kuchen = new KuchenBean();
      
      public ZutatBean getZutat()
      {
        return this.zutat;
      }
  
      @StrutsParameter
      public void setId(Integer int_ZutatId)
      {
        this.intZutatId = int_ZutatId;
      }
  
      @StrutsParameter(depth = 1)
      public KuchenBean getKuchen()
      {
        return this.kuchen;
      }
    }

  Die Zutat wird erst beim Execute eingelesen. Beim Submit des Formulars werden setId() sowie getKuchen().setId() aufgerufen, um die Hidden Fields "kuchen.id" und "id" (ID der Zutat) zu setzen. Dies ist der Grund, warum hier ein ganzes Kuchen-Objekt nötig ist: es dient einerseits als Container für die Kuchen-ID und wird deshalb direkt bei der Deklaration erzeugt. Außerdem wird es später auf "kuchendetail.jsp" zum Befüllen der Kuchen-Felder benötigt ! Das Setzen der Kuchen-Id mit Hilfe einer Methode setKuchenId (also ohne Umweg über das Container-Objekt) ist hier nicht möglich, denn auf "kuchendetail.jsp" müsste in den zugehörigen Actions ebenfalls eine Property "getKuchenId"/"setKuchenId" verfügbar sein !
  Die Automatismen von Struts 2 beim Setzen/Auswerten von Feldern bieten zwar große Möglichkeiten, erfordern aber auch viel Benennungs-Disziplin (und man muss höllisch aufpassen).
  
  Im execute wird die Zutat-Membervariable geladen.
  

      public String execute() throws Exception
      {
        this.zutat = this.getWorker().findZutatById(this.intZutatId);
        
        return Action.SUCCESS;
      }

  Mit dem Kuchen passiert nichts.
  
  
• Weiter geht es zur Zielseite, "zutatdetail.jsp":
  

    <s:form action="zutatsave">
      <s:hidden name="kuchen.id"></s:hidden>
      <s:hidden name="zutat.id"></s:hidden>
      
      <s:textfield name="zutat.zutatName" label="Name"></s:textfield> <br/>
      <s:textfield name="zutat.menge" label="Menge"></s:textfield> <br/>
      <br/>
      <s:submit value="OK"></s:submit>
    </s:form> 

  Wichtig hier: Kuchen-ID und Zutat-ID kommen aus den Methoden getKuchen().getId() sowie getZutat().getId() der KuchenZutatEditAction.
  
  
• Die Action "zutatsave" ist in struts.xml so deklariert:
  

    <action name="zutatsave" class="de.fhw.komponentenarchitekturen.knauf.kuchenzutatstruts.actions.ZutatSaveAction">
      <result>/kuchendetail.jsp</result>
    </action>

• ZutatSaveAction deklariert zwei Membervariablen "zutat" und "kuchen":
  

    public class ZutatSaveAction extends BaseAction 
    {
      private ZutatBean zutat = new ZutatBean();
      
      private KuchenBean kuchen = new KuchenBean();
      
      @StrutsParameter(depth = 1)
      public ZutatBean getZutat()
      {
        return this.zutat;
      }
      
      @StrutsParameter(depth = 1)
      public KuchenBean getKuchen()
      {
        return this.kuchen;
      }
    } 

  Beim Submit des Formulars wird die aktuelle Kuchen-ID aus dem Hidden Field in getKuchen().setId() geschrieben, die Zutat-ID in getZutat().setId(). Die Felder der Zutat (ZutatName und Menge) werden in getZutat().setZutatName() und getZutat().setMenge() gepackt.
  
  execute sieht so aus:
  

      public String execute() throws Exception
      {
        ...
        
        ZutatBean zutatSave = null;
        if (this.zutat.getId() != null)
        {
          zutatSave = this.getWorker().findZutatById(this.zutat.getId() );
        }
        else
        {
          zutatSave = new ZutatBean();
        }
        
        zutatSave.setZutatName(this.zutat.getZutatName());
        zutatSave.setMenge(this.zutat.getMenge());
        
        this.kuchen = this.getWorker().findKuchenById(this.kuchen.getId());
        zutatSave.setKuchen(this.kuchen);
        
        this.getWorker().saveZutat(zutatSave);
        
        this.kuchen = this.getWorker().findKuchenById(this.kuchen.getId());
        
        return Action.SUCCESS;
      }

  Die Zutat wird anhand der ID in der aktuellen Zutat geladen, und die Felder der Zutat-Membervariablen werden übernommen. Anschließend wird der Kuchen anhand von kuchen.getId() geladen. Zutat und Kuchen werden verknüpft (das geschieht hier immer, auch beim Bearbeiten von vorhandenen Zutaten), danach wird die Zutat gespeichert.
  Nach dem Ende der Action geht der Workflow zu "kuchendetail.jsp", dort wird intensiv auf die Property "kuchen" zugegriffen, unter anderem zum Aufbau der Zutatenliste. Aus diesem Grund muss der Kuchen nach dem Speichern der Zutaten neu geladen werden !
  
  
• Als Ergebnis der Action geht es zurück auf "kuchendetail.jsp". Dort werden die Daten des Kuchens aus ZutatSaveAction.getKuchen() geholt. Man sieht, das es drei Wege gibt, auf "kuchendetail.jsp" zu gelangen: von KuchenNeuAction, von KuchenSaveAction und von ZutatSaveAction. In allen drei Fällen wird eine Property "kuchen" abgerufen, die in allen drei Actions vorhanden sein sollte. In KuchenNeuAction fehlt diese Property, weil es dort sowieso nur leere Felder zu holen gibt.
  

<a href="kuchenedit.action?id=${kuchen.id}">Zum Kuchen</a>

<s:url id="editUrl"action="kuchenedit">
  <s:param name="id" value="kuchen.id"></s:param>
</s:url>
<s:a href="%{editUrl}">Zum Kuchen</s:a> <br />

  <?xml version="1.0" encoding="ISO-8859-1" ?>
  <%@ page session="false" language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  <html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
    <title>Test für Struts</title>
  </head>
  <body>

  <constant name="struts.i18n.encoding" value="ISO-8859-1"></constant>