Skip to content

13. Beispiel 10 – Konvertierung und Validierung von reellen Zahlen

Die neue Anwendung ermöglicht die Eingabe von reellen Zahlen:

  • in [1] ist das Eingabeformular
  • in [2] die zurückgegebene Antwort

Die Anwendung funktioniert ähnlich wie bei der Eingabe von Ganzzahlen, daher werden wir nur auf die Punkte eingehen, die sich unterscheiden.

13.1. Das NetBeans-Projekt

Das NetBeans-Projekt sieht wie folgt aus:

  • in [1], die Anwendungsansichten
  • [Accueil.jsp]: die Startseite
  • [FormDouble.jsp]: das Eingabeformular
  • [ConfirmationDouble.jsp]: die Bestätigungsseite
  • in [2], die Meldungsdatei [messages.properties] und die Hauptkonfigurationsdatei von Struts
  • in [3]:
  • [FormDouble.java]: die Aktion, die das Formular anzeigt und verarbeitet
  • [FormDouble-validation.xml]: die Validierungsregeln für die [FormDouble]-Aktion. Diese Datei delegiert diese Validierungen mithilfe der soeben besprochenen Methode an das Modell.
  • [FormDoubleModel]: das Modell für die [FormDouble]-Aktion
  • [FormDoubleModel-validation.xml]: die Validierungsregeln des Modells
  • [FormDoubleModel.properties]: die Meldungsdatei des Modells
  • [example.xml]: sekundäre Struts-Konfigurationsdatei

13.2. Projektkonfiguration

Das Projekt wird in erster Linie durch die folgende [example.xml]-Datei konfiguriert:


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
        "http://struts.apache.org/dtds/struts-2.0.dtd">
 
<struts>
  <package name="example" namespace="/example" extends="struts-default">
    <action name="Accueil">
      <result name="success">/example/Accueil.jsp</result>
    </action>
    <action name="FormDouble" class="example.FormDouble">
      <result name="input">/example/FormDouble.jsp</result>
      <result name="cancel" type="redirect">/example/Accueil.jsp</result>
      <result name="success">/example/ConfirmationFormDouble.jsp</result>
    </action>
  </package>
</struts>

Es ähnelt dem für die Eingabe von Ganzzahlen beschriebenen Verfahren.

13.3. Meldungsdateien

Die Datei [messages.properties] sieht wie folgt aus:


Accueil.titre=Accueil
Accueil.message=Struts 2 - Conversions et validations
Accueil.FormDouble=Saisie de nombres r\u00e9els
Form.titre=Conversions et validations
FormDouble.message=Struts 2 - Conversion et validation de nombres r\u00e9els
FormDouble.conseil=Tapez les nombres r\u00e9els avec une virgule comme 10,7
Form.submitText=Valider
Form.cancelText=Annuler
Form.clearModel=Raz mod\u00e8le
Confirmation.titre=Confirmation
Confirmation.message=Confirmation des valeurs saisies
Confirmation.champ=champ
Confirmation.valeur=valeur
Confirmation.lien=Formulaire de test
xwork.default.invalid.fieldvalue=Valeur invalide pour le champ "{0}".

Die Datei [FormDoubleModel.properties] sieht wie folgt aus:


double.format={0,number}
double1.prompt=1-Nombre r\u00E9el
double1.error=Tapez un nombre r\u00E9el
double2.prompt=2-Nombre r\u00E9el
double2.error=Tapez un nombre r\u00E9el
double3.prompt=3-Nombre r\u00E9el >=2.64
double3.error=Tapez un nombre r\u00E9el >=2.64
double4.prompt=4-Nombre r\u00E9el <8.32
double4.error=Tapez un nombre r\u00E9el <8.32
double5.prompt=5-Nombre r\u00E9el dans l''intervalle [2.64,8.32[
double5.error=Tapez un nombre r\u00E9el dans l''intervalle [2.64,8.32[
double6.prompt=6-Nombre r\u00E9el dans l''intervalle [2.64,8.32]
double6.error=Tapez un nombre r\u00E9el dans l''intervalle [2.64,8.32]

Zeile 1 spielt eine wichtige Rolle. Wir werden später darauf zurückkommen.

13.4. Das Eingabeformular

Die Ansicht [FormDouble.jsp] sieht wie folgt aus:


<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
    <title><s:text name="Form.titre"/></title>
    <s:head/>
  </head>
 
  <body background="<s:url value="/ressources/standard.jpg"/>">
    <h2><s:text name="FormDouble.message"/></h2>
    <h4><s:text name="FormDouble.conseil"/></h4>
    <s:form name="formulaire" action="FormDouble">
      <s:textfield name="double1" key="double1.prompt"/>
      <s:textfield name="double2" key="double2.prompt" value="%{#parameters['double2']!=null ? #parameters['double2'] : double2==null ? '' :getText('double.format',{double2})}"/>
      <s:textfield name="double3" key="double3.prompt" value="%{#parameters['double3']!=null ? #parameters['double3'] : double3==null ? '' :getText('double.format',{double3})}"/>
      <s:textfield name="double4" key="double4.prompt" value="%{#parameters['double4']!=null ? #parameters['double4'] : double4==null ? '' :getText('double.format',{double4})}"/>
      <s:textfield name="double5" key="double5.prompt" value="%{#parameters['double5']!=null ? #parameters['double5'] : double5==null ? '' :getText('double.format',{double5})}"/>
      <s:textfield name="double6" key="double6.prompt"/>
      <s:submit key="Form.submitText" method="execute"/>
    </s:form>
    <br/>
    <s:url id="url" action="FormDouble" method="cancel"/>
    <s:a href="%{url}"><s:text name="Form.cancelText"/></s:a>
    <br/>
    <s:url id="url" action="FormDouble" method="clearModel"/>
    <s:a href="%{url}"><s:text name="Form.clearModel"/></s:a>
  </body>
</html>

Die Zeilen 13 bis 18 sind die sechs Eingabefelder für reelle Zahlen. Die Felder double2 bis double5 haben ein komplexes Wertattribut. Normalerweise sollten die sechs Eingabefelder wie folgt aussehen:


      <s:textfield name="double1" key="double1.prompt"/>
      <s:textfield name="double2" key="double2.prompt"/>
      <s:textfield name="double3" key="double3.prompt"/>
      <s:textfield name="double4" key="double4.prompt"/>
      <s:textfield name="double5" key="double5.prompt"/>
<s:textfield name="double6" key="double6.prompt"/>

Um bestimmte Probleme zu beheben, die während des Testens aufgetreten sind, mussten wir die Dinge etwas komplexer gestalten. Vorerst kann der Leser diese Komplexität ignorieren. Wir werden sie später erläutern.

13.5. Die Bestätigungsansicht

Die Bestätigungsansicht [ConfirmationFormDouble.jsp] sieht wie folgt aus:

Image

Der Code lautet wie folgt:


<%@ page contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
    <title><s:text name="Confirmation.titre"/></title>
    <s:head/>
  </head>
 
  <body background="<s:url value="/ressources/standard.jpg"/>">
    <h2><s:text name="Confirmation.message"/></h2>
    <table border="1">
      <tr>
        <th><s:text name="Confirmation.champ"/></th>
        <th><s:text name="Confirmation.valeur"/></th>
      </tr>
      <tr>
        <td><s:text name="double1.prompt"/></td>
        <td><s:text name="double1"/></td>
      </tr>
      <tr>
        <td><s:text name="double2.prompt"/></td>
        <td>
          <s:text name="double.format">
            <s:param value="double2"/>
          </s:text>
        </td>
      </tr>
      <tr>
        <td><s:text name="double3.prompt"/></td>
        <td>
          <s:text name="double.format">
            <s:param value="double3"/>
          </s:text>
        </td>
      </tr>
      <tr>
        <td><s:text name="double4.prompt"/></td>
        <td>
          <s:text name="double.format">
            <s:param value="double4"/>
          </s:text>
        </td>
      </tr>
      <tr>
        <td><s:text name="double5.prompt"/></td>
        <td>
          <s:text name="double.format">
            <s:param value="double5"/>
          </s:text>
        </td>
      </tr>
      <tr>
        <td><s:text name="double6.prompt"/></td>
        <td><s:text name="double6"/></td>
      </tr>
    </table>
    <br/>
    <s:url id="url" action="FormDouble!input"/>
    <s:a href="%{url}"><s:text name="Confirmation.lien"/></s:a>
  </body>
</html>

Die Seite [ConfirmationFormDouble.jsp] zeigt lediglich das [FormDoubleModel] an. Die Zeilen 47–49 zeigen, wie eine reelle Zahl dargestellt wird. Wir möchten, dass diese Anzeige die Ländereinstellung der Anwendung berücksichtigt. Je nach Ländereinstellung wird eine reelle Zahl in Frankreich (10,7) anders dargestellt als im Vereinigten Königreich (10.7). Um dies zu erreichen, verwenden wir das <s:text>-Tag, das wir zuvor für die Internationalisierung der Anwendung genutzt hatten. Dieses Tag wird somit auch für die Lokalisierung verwendet.

Hier wird der Meldungsschlüssel double.format verwendet. Dieser Schlüssel befindet sich in der Datei [FormDoubleModel.properties]:


double.format={0,number}

Der mit dem Schlüssel verknüpfte Wert ist hier keine Meldung, sondern ein Anzeigeformat:

  • 0 ist ein Parameter, der den anzuzeigenden Wert darstellt. Hier ist dies das Feld „double5“ des Modells.
  • number steht für das numerische Format. Es wird an jedes Land angepasst. Ohne dieses Format wird die Zahl 10,7 unabhängig vom Land immer als 10,7 angezeigt.

Das Tag


         <s:text name="double.format">
            <s:param value="double5"/>
</s:text>

Zeigt die Meldung {0, number} an, wobei der Parameter double5 (Zeile 2) den Parameter 0 im Format ersetzt. Somit wird der Wert double5 im lokalisierten Zahlenformat angezeigt.

13.6. Die Vorlage [FormDoubleModel]

Die Felder double1 bis double6 aus dem Formular [FormDouble.jsp] werden in die folgende Vorlage [FormDoubleModel] eingefügt:


package example;
 
public class FormDoubleModel {
 
  // constructor without parameters
  public FormDoubleModel() {
  }
  // fields
  private String double1;
  private Double double2;
  private Double double3;
  private Double double4;
  private Double double5;
  private String double6;
 
  // raz model
  public void clearModel() {
    double1 = null;
    double2 = null;
    double3 = null;
    double4 = null;
    double5 = null;
    double6 = null;
  }
 
  // getters and setters
   ...
}
  • Die Felder double1 und double6 sind vom Typ String
  • die anderen Felder sind vom Typ Double

13.7. Modellvalidierung

Die Modellvalidierung wird durch zwei Dateien gesteuert: [FormDouble-validation.xml] und [FormDoubleModel-validation.xml].

Die Datei [FormDouble-validation.xml] delegiert Validierungen an [FormDoubleModel-validation.xml]:


<!--
<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//
EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
-->
<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//
EN" "http://localhost:8084/exemple-10/example/xwork-validator-1.0.2.dtd">
 
<validators>
  <field name="model" >
    <field-validator type="visitor">
      <param name="appendPrefix">false</param>
      <message/>
    </field-validator>
  </field>
</validators>

Wir sind dieser Datei bereits begegnet.

Die Datei [FormDoubleModel-validation.xml] enthält die folgenden Validierungsregeln:


<!--
<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//
EN" "http://www.opensymphony.com/xwork/xwork-validator-1.0.2.dtd">
-->
 
<!DOCTYPE validators PUBLIC "-//OpenSymphony Group//XWork Validator 1.0.2//
EN" "http://localhost:8084/exemple-10/example/xwork-validator-1.0.2.dtd">
 
 
<validators>
 
  <field name="double1" >
    <field-validator type="requiredstring" short-circuit="true">
      <message key="double1.error"/>
    </field-validator>
    <field-validator type="regex" short-circuit="true">
      <param name="expression">^[+|-]*\s*\d+(,\d+)*$</param>
      <param name="trim">true</param>
      <message key="double1.error"/>
    </field-validator>
  </field>
 
  <field name="double2" >
    <field-validator type="required" short-circuit="true">
      <message key="double2.error"/>
    </field-validator>
    <field-validator type="conversion" short-circuit="true">
      <message key="double2.error"/>
    </field-validator>
  </field>
 
  <field name="double3" >
    <field-validator type="required" short-circuit="true">
      <message key="double3.error"/>
    </field-validator>
    <field-validator type="conversion" short-circuit="true">
      <message key="double3.error"/>
    </field-validator>
    <field-validator type="double" short-circuit="true">
      <param name="minInclusive">2.64</param>
      <message key="double3.error"/>
    </field-validator>
  </field>
 
  <field name="double4" >
    <field-validator type="required" short-circuit="true">
      <message key="double4.error"/>
    </field-validator>
    <field-validator type="conversion" short-circuit="true">
      <message key="double4.error"/>
    </field-validator>
    <field-validator type="double" short-circuit="true">
      <param name="maxExclusive">8.32</param>
      <message key="double4.error"/>
    </field-validator>
  </field>
 
  <field name="double5" >
    <field-validator type="required" short-circuit="true">
      <message key="double5.error"/>
    </field-validator>
    <field-validator type="conversion" short-circuit="true">
      <message key="double5.error"/>
    </field-validator>
    <field-validator type="double" short-circuit="true">
      <param name="minInclusive">2.64</param>
      <param name="maxExclusive">8.32</param>
      <message key="double5.error"/>
    </field-validator>
  </field>
 
  <field name="double6" >
    <field-validator type="requiredstring" short-circuit="true">
      <message key="double6.error"/>
    </field-validator>
    <field-validator type="regex" short-circuit="true">
      <param name="expression">^[+|-]*\s*\d+(,\d+)*$</param>
      <param name="trim">true</param>
      <message key="double6.error"/>
    </field-validator>
  </field>
</validators>
  • Die Regel in den Zeilen 12–21 überprüft, ob das Eingabefeld „double1“ einem regulären Ausdruck entspricht, der eine reelle Zahl darstellt.
  • Die Regel in den Zeilen 23–30 überprüft, ob das Eingabefeld „double2“ in eine reelle Zahl mit doppelter Genauigkeit konvertiert werden kann.
  • Die Regel in den Zeilen 32–43 überprüft, ob das Eingabefeld `double3` in eine doppelt genaue reelle Zahl größer oder gleich 2,64 konvertiert werden kann. Beachten Sie, dass die angelsächsische Notation für reelle Zahlen verwendet werden muss.
  • Die Regel in den Zeilen 45–56 überprüft, ob das Eingabefeld „double4“ in eine reelle Zahl mit doppelter Genauigkeit < 8,32 konvertiert werden kann.
  • Die Regel in den Zeilen 58–70 überprüft, ob das Eingabefeld `double5` in eine doppeltgenaue reelle Zahl im Intervall [2,64, 8,32[ konvertiert werden kann.
  • Die Regel in den Zeilen 72–80 überprüft, ob das Feld „double6“ dem Muster eines regulären Ausdrucks entspricht, der eine reelle Zahl darstellt.

Sobald die Datei [FormDoubleModel-validation.xml] vom Validierungs-Interceptor verarbeitet wurde, führt dieser die validate-Methode der [FormDouble]-Aktion aus, sofern diese vorhanden ist. Wir werden sie zusammen mit der gesamten Aktion vorstellen.

13.8. Die [FormDouble]-Aktion

Die [FormDouble]-Aktion lautet wie folgt:


package example;
 
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
import java.util.Map;
import org.apache.struts2.interceptor.SessionAware;
import org.apache.struts2.interceptor.validation.SkipValidation;
 
public class FormDouble extends ActionSupport implements ModelDriven, SessionAware {
 
  // constructor without parameters
  public FormDouble() {
  }
 
  // action model
  public Object getModel() {
    if (session.get("model") == null) {
      session.put("model", new FormDoubleModel());
    }
    return session.get("model");
  }

  @SkipValidation
  public String clearModel() {
    // close to the model
    ((FormDoubleModel) getModel()).clearModel();
    // result
    return INPUT;
  }
 
  public String cancel() {
    // cleaning the model
    ((FormDoubleModel) getModel()).clearModel();
    // result
    return "cancel";
  }
  // SessionAware
  Map<String, Object> session;
 
  public void setSession(Map<String, Object> session) {
    this.session = session;
  }
 
  // validation
  @Override
  public void validate() {
    // valid double6 entry?
    if (getFieldErrors().get("double6") == null) {
      // replace the comma with a period in the double6 string
      String strDouble6 = (((FormDoubleModel) getModel()).getDouble6()).replace(',', '.');
      // String --> double
      double double6 = Double.parseDouble(strDouble6);
      // check
      if (double6 < 2.64 || double6 > 8.32) {
        addFieldError("double6", getText("double6.error"));
      }
    }
  }
}

Die Aktion [FormDouble] basiert auf demselben Modell wie die Aktion [FormInt]. Wir werden nur auf die Methode „validate“ eingehen. Beachten Sie, dass die Methode „validate“ ausgeführt wird, nachdem die Validierungsdatei [FormDoubleModel-validation.xml] verarbeitet wurde und bevor die Methode „execute“ aufgerufen wird.

  • Zeile 48: Wenn im Feld „double6“ bereits Fehler vorhanden sind, werden keine weiteren Maßnahmen ergriffen.
  • Zeile 50: Wir haben eine Zeichenkette in der Form 45.67 erhalten. Diese wurde im Feld „double6“ des Modells gespeichert. Wir ersetzen das Komma durch einen Punkt, um 45.67 zu erhalten.
  • Zeile 52: Die Zeichenfolge 45.67 wird in eine Gleitkommazahl mit doppelter Genauigkeit umgewandelt. Dies sollte funktionieren, da die Zeichenfolge im Feld „double6“ dem Format einer reellen Zahl entspricht.
  • Zeile 54: Wir prüfen, ob die resultierende Double-Zahl im Intervall [2,64; 8,32] liegt.
  • Zeile 55: Ist dies nicht der Fall, wird die Fehlermeldung des Schlüssels „double6.error“ an das Feld „double6“ angehängt. Diese Meldung befindet sich in der Datei [FormDoubleModel.properties]. Sie wird angezeigt, wenn das Formular mit dem Fehler erneut angezeigt wird.

13.9. Abschließende Details

Nun zurück zur Komplexität der Eingabefelder im Formular [FormDouble.jsp]. Wir konzentrieren uns auf das Feld „double2“. Die Argumentation gilt auch für die Felder „double3“ bis „double5“, die ein Double-Modell haben. Für die Felder „double1“ und „double6“, die ein String-Modell haben, gibt es kein Problem.

Das Eingabefeld „double2“ sieht wie folgt aus:


<s:textfield name="double2" key="double2.prompt" value="%{#parameters['double2']!=null ? #parameters['double2'] : double2==null ? '' :getText('double.format',{double2})}"/>

Beginnen wir mit dem einfachsten Tag:


<s:textfield name="double2" key="double2.prompt"/>

und schauen wir mal, was passiert:

  • In [1] überprüfen wir die korrekte double2-Zahl. Auf dem Screenshot ist es nicht ganz deutlich zu erkennen, aber wir haben die Zahl mit einem Dezimalpunkt eingegeben.
  • In [2] die Bestätigungsansicht. Die double2-Eingabe hat die Validierungsprüfungen bestanden. Die Zahl wird mit einem Dezimalpunkt angezeigt.
  • In [3] kehren wir zum Formular zurück
  • in [4], das Formular. Was auf dem Screenshot nicht deutlich zu sehen ist: Die double2-Zahl, die ursprünglich 4,32 betrug, lautet nun 4,32 mit einem Dezimalpunkt.
  • In [5] senden wir das Formular erneut ab, ohne etwas zu ändern
  • In [6] wird ein Fehler im Feld „double2“ gemeldet.

Das Problem stellt sich wie folgt dar:

  • Zunächst wurde in [1] die Eingabezeichenfolge „4,32“ erfolgreich in die Gleitkommazahl 4,32 umgewandelt. Das bedeutet, dass die Konvertierung von String zu Double erfolgreich war und dass Struts in diesem Zusammenhang die Ländereinstellung berücksichtigt – in diesem Fall Frankreich.
  • Das neue Formular [4] zeigt im Feld „double2“ die reelle Zahl 4,32 an. Da die Anzeige nicht lokalisiert wurde, wird standardmäßig das angelsächsische Format verwendet, d. h. mit einem Dezimalpunkt. Bei der Konvertierung von Double nach String berücksichtigt Struts also die Ländereinstellung nicht mehr; andernfalls hätte es 4,32 mit einem Komma angezeigt.

Das ist, gelinde gesagt, inkonsistent. Aber egal, wir werden die Anzeige der Zahl 4,32 lokalisieren. Der Input-Tag sieht dann wie folgt aus:


<s:textfield name="double2" key="double2.prompt" value="%{getText('double.format',{double2})}"/>

Das Attribut „value“ gibt den Wert an, der im Feld „double2“ angezeigt werden soll. Dabei handelt es sich um einen OGNL-Ausdruck. Erinnern Sie sich an die Definition des Schlüssels „double.format“ in der Datei [FormDoubleModel.properties]:


double.format={0,number}

Die Methode getText('key') ruft die mit einem Schlüssel verknüpfte Meldung ab. Diese Meldung wird in der Datei nachgeschlagen, die der aktuellen Ländereinstellung entspricht. Wenn die Ländereinstellung also „es“ (Spanien) wäre, wäre der Schlüssel „double.format“ in der Datei [FormDoubleModel_es.properties] nachgeschlagen worden.

Die Methode getText('key', {param0, param1, ...}) ruft eine parametrisierte Meldung ab. Die Meldung

{0, number}

ist eine durch Parameter 0 parametrisierte Meldung. Dies ist ein Positionsparameter. Die Methode getText('double.format', {double2}) weist dem Parameter 0 die Zahl double2 zu. Letztendlich fordern wir den Wert von double2 im lokalisierten numerischen Format an. In Frankreich wird die Zahl 4,56 als Zeichenfolge „4,56“ lokalisiert.

Nach dieser Änderung führen wir die Tests erneut durch.

Sobald das Formular zum ersten Mal angezeigt wird, tritt in [1] eine Anomalie auf. Kehren wir zum Tag zurück:


<s:textfield name="double2" key="double2.prompt" value="%{getText('double.format',{double2})}"/>

Bei der ersten Anzeige ist der Wert des double2-Modells null, also ein nicht-numerischer Wert. Wir ändern das Tag wie folgt:


<s:textfield name="double2" key="double2.prompt" value="%{double2==null ? '' : getText('double.format',{double2})}"/>

Diesmal prüfen wir, ob double2==null ist. Ist dies der Fall, zeigen wir eine leere Zeichenfolge an.

Nachdem diese Änderung vorgenommen wurde, setzen wir die Tests fort:

Die Screenshots [1] bis [4] zeigen, dass das Problem, das wir zu lösen versuchten, behoben wurde:

  • In [1] geben wir 4,67 ein
  • in [2] wurde diese Zahl akzeptiert
  • in [3] wird sie erneut als 4,67 mit Dezimalpunkt angezeigt, was durch [4] bestätigt wird.

Leider sind die Probleme damit noch nicht behoben. Betrachten wir die folgende Zahlenfolge:

  • In [5] wird ein Zeichen hinzugefügt, um „double2“ ungültig zu machen
  • In [6] haben die Validierungsprüfungen ihre Aufgabe erfüllt und der Fehler wird gemeldet. Die in [6] angezeigte Zeichenfolge ist jedoch nicht die fehlerhafte Zeichenfolge, sondern der aktuelle Wert des double2-Modells. Der eingegebene Wert ist verloren gegangen.

Beim Wechsel von [5] zu [6] wird die Anfrage nicht abgeschlossen. Sie wird vom Validierungs-Interceptor gestoppt. In [6] haben wir den Wert des double2-Modells angezeigt, das aufgrund dieser Unterbrechung keinen neuen Wert erhalten hat. Daher wird der vorherige Wert angezeigt, während eigentlich die eingegebene Zeichenfolge hätte angezeigt werden sollen. Auf die Parameter einer Anfrage kann über die Notation #parameters['param'] zugegriffen werden. Wir aktualisieren das Eingabefeld „double2“ wie folgt:


      <s:textfield name="double2" key="double2.prompt" value="%{#parameters['double2']!=null ? #parameters['double2'] : double2==null ? '' : getText('double.format',{double2})}"/>

Der angezeigte Wert des Feldes „double2“ wird wie folgt berechnet: Wenn der Parameter „double2“ vorhanden ist, wird er angezeigt; andernfalls wird die Vorlage „double2“ angezeigt. Der Leser ist eingeladen, zu testen, ob diese neue Version des Tags die aufgetretenen Probleme behebt.

13.10. Fazit

Es ist überraschend, dass die Eingabe von reellen Zahlen mit Gültigkeitsprüfungen so kompliziert ist... Vielleicht habe ich etwas in der Dokumentation übersehen?

https://stahe.github.io
Dieses Tutorial, verfasst von Serge Tahé, wird der Öffentlichkeit unter den Bedingungen der Creative Commons Namensnennung – Nicht kommerziell – ShareAlike 3.0 Unported.