Skip to content

4. Die View und ihr Template

Bisher haben die Actions ihre Antworten selbst erzeugt: Text, JSON und einige als Zeichenkette geschriebene HTML-Tags. In einer MVC-Anwendung ist dies die Aufgabe einer View: einer Datei, die die HTML-Seite beschreibt, mit Platzhaltern für die Daten, die ihr die Action übergibt – das Modell der View. [Spring MVC] stellt selbst keine View-Sprache bereit: Es kann mit mehreren View-Engines ([Thymeleaf], [FreeMarker], [Mustache], [JSP] ...) arbeiten. Dieser Kurs verwendet [Thymeleaf], die zusammen mit [Spring MVC] am weitesten verbreitete View-Engine, die [Spring Boot] selbstständig konfigurieren kann.

Eine [Thymeleaf]-View ist eine gewöhnliche [.html]-Datei: eine gültige HTML-Datei, die unverändert in einem Browser geöffnet werden kann. Daten werden über zusätzliche Attribute mit dem Präfix [th:] ([th:text], [th:if], [th:each] ...) eingefügt, die [Thymeleaf] auf dem Server ausführt und anschließend aus der Seite entfernt. [Thymeleaf] bezeichnet dies als natürliche Templates ([natural templates]): Ein Grafikdesigner kann an der View arbeiten, ohne die Anwendung zu starten, und der Entwickler fügt ihr die Attribute [th:] hinzu. Das unterscheidet sich von [Razor], der View-Engine von [ASP.NET Core MVC], die HTML und [C#]-Code kombiniert, dem das Zeichen [@] vorangestellt ist.

4.1. Beispiel 13: Eine erste View

Um [Thymeleaf] zu verwenden, genügt es, in der Datei [pom.xml] des Beispiels eine Abhängigkeit hinzuzufügen:

1
2
3
4
5
6
7
  <dependencies>
    <!-- die Thymeleaf-Views -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
  </dependencies>
  • Zeilen 3–6: der [spring-boot-starter-thymeleaf] Starter. Ein Starter ist eine „Alles-in-einem“-Abhängigkeit: Er liefert [Thymeleaf], dessen Integration mit [Spring] (die Bibliothek [thymeleaf-spring6]) und die automatische Konfiguration von [Spring Boot], die sie mit [Spring MVC] verbindet. Mehr ist nicht zu schreiben: keine Version (sie wird vom übergeordneten Projekt [spring-boot-starter-parent] festgelegt), keine Konfigurationsklasse.

Das Modell der View ist eine einfache Klasse. Die Datei [models/PageModel.java]:

1
2
3
4
5
package example13.models;

// das Modell der View: die Daten, die die Action an die View übergibt
public record PageModel(String title, String message, String time) {
}
  • Zeile 4: Ein [Java]-Record (siehe Beispiel 03) ist eine Klasse, deren Felder einmalig vom Konstruktor festgelegt werden: hier drei Zeichenketten [title], [message] und [time]. Der Compiler erzeugt automatisch den Konstruktor und die Zugriffsmethoden, die die Felder für uns lesen. Beachten Sie: Diese Zugriffsmethoden sind nach dem Feld benannt ([title()]), nicht [getTitle()] wie in einer als [JavaBean] bezeichneten Klasse (siehe Beispiel 08). Das ist eine knappe Schreibweise für eine Klasse, die lediglich Daten transportiert.

Die Datei [controllers/ViewsController.java]:

package example13.controllers;

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.servlet.ModelAndView;

import example13.models.PageModel;

// @Controller: die Actions geben den NAMEN einer View zurück
@Controller
public class ViewsController {

    private static final DateTimeFormatter TIME = DateTimeFormatter.ofPattern("HH:mm:ss");

    // Model: das Modell der View, ein von der Action gefülltes Dictionary;
    // der zurückgegebene String ist der Name der View: templates/views/index.html
    @GetMapping("/")
    public String index(Model model) {
        PageModel pageModel = new PageModel(
                "My first view",
                "This page was built by Thymeleaf, on the server.",
                LocalTime.now().format(TIME));
        model.addAttribute("model", pageModel);
        return "views/index";
    }

    // ModelAndView: die View, ihr Modell und gegebenenfalls der Antwortcode in einem einzigen Objekt
    @GetMapping("/hello/{name}")
    public ModelAndView hello(@PathVariable String name) {
        if (name.equals("unknown")) {
            return new ModelAndView("views/unknown", Map.of("name", name), HttpStatus.NOT_FOUND);
        }
        PageModel pageModel = new PageModel(
                "Hello " + name,
                "This time, the action built a ModelAndView object.",
                LocalTime.now().format(TIME));
        return new ModelAndView("views/index", Map.of("model", pageModel));
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeile 17: Die Annotation [@Controller] ersetzt die Annotation [@RestController] der vorherigen Beispiele. Mit [@RestController] ist das, was eine Action zurückgibt, die Antwort (Text, JSON). Mit [@Controller] gibt eine Action, die eine Zeichenkette zurückgibt, den Namen einer View zurück: Die View erzeugt dann die Antwort;
  • Zeile 25: Die Action erhält einen Parameter vom Typ [Model], bereitgestellt von [Spring MVC]. Das ist das Modell der View: ein Dictionary, in dem jeder Eintrag (ein Attribut) einen Namen mit einem Objekt verknüpft;
  • Zeilen 26–30: Die Action erzeugt ein [PageModel]-Objekt (einen Titel, eine Meldung, die aktuelle Uhrzeit) und legt es unter dem Namen [model] im Modell ab. Die View ruft es unter diesem Namen ab;
  • Zeile 31: Die Action gibt den Namen der View zurück, [views/index]. Sie erzeugt die Antwort nicht mehr selbst, sondern verweist auf eine View und hat deren Daten vorbereitet;
  • Zeile 36: Die Action [hello] gibt ein Objekt [ModelAndView] zurück, das den Namen der View und ihr Modell in einem einzigen Objekt vereint. Das ist eine weitere Möglichkeit, eine Action zu schreiben, die eine View verwendet;
  • Zeile 38: Hängt die View von der Anfrage ab, wählt die Action die View aus. Hier zeigt der Name [unknown] die View [views/unknown] an, mit dem Statuscode 404: Das dritte Argument des Konstruktors von [ModelAndView] ist der Antwortcode. Das Modell dieser View enthält eine einfache Zeichenkette: den angeforderten Namen. [Map.of(...)] erzeugt ein schreibgeschütztes Dictionary;
  • Zeile 44: Die beiden Actions teilen sich dieselbe View, [views/index], mit unterschiedlichen Modellen.

Wo sucht [Spring MVC] nach der View [views/index]? Es übergibt den Namen der View an einen View-Resolver ([ViewResolver]), der ihn in eine konkrete View umwandelt. Der von [Spring Boot] für [Thymeleaf] ([ThymeleafViewResolver]) konfigurierte Resolver fügt ein Präfix, [classpath:/templates/], und ein Suffix, [.html], hinzu: Die View [views/index] ist die Datei [templates/views/index.html] im Classpath – das heißt in den Ordnern und Archiven, in denen die virtuelle [Java]-Maschine nach den Klassen und Ressourcen der Anwendung sucht. Der Ordner [src/main/resources] des Projekts gehört dazu: Sein Inhalt wird von [Maven] zusammen mit den kompilierten Klassen nach [target/classes] kopiert. Diese beiden Werte lassen sich in [application.properties] ändern (Eigenschaften [spring.thymeleaf.prefix] und [spring.thymeleaf.suffix]). Anders als bei [ASP.NET Core MVC] gibt es keine Konvention, die den Namen der View aus den Namen von Controller und Action ableitet: Die Action gibt stets den Pfad zur View an, relativ zum Ordner [templates]. Die Projektdateien:

13-first-view/
├── src/
│   └── main/
│       ├── java/
│       │   └── example13/
│       │       ├── controllers/
│       │       │   └── ViewsController.java
│       │       ├── models/
│       │       │   └── PageModel.java
│       │       └── Example13Application.java
│       └── resources/
│           ├── templates/
│           │   └── views/
│           │       ├── index.html
│           │       └── unknown.html
│           └── application.properties
└── pom.xml

Die Datei [templates/views/index.html]:

<!doctype html>
<!--/* xmlns:th: deklariert den Namespace der Attribute th:... (nützlich für Editoren) */-->
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <title th:text="${model.title}">Page title</title>
</head>
<body>
  <h1 th:text="${model.title}">Page title</h1>
  <p th:text="${model.message}">A message.</p>
  <p>Page built at <span th:text="${model.time}">12:00:00</span>.</p>
</body>
</html>

Lassen Sie uns diesen Code kommentieren:

  • Zeile 2: Ein [Thymeleaf]-Kommentar wird als [<!--/* ... */-->] geschrieben. Das ist ein HTML-Kommentar, dessen Inhalt von [/*] und [*/] eingeschlossen wird: [Thymeleaf] entfernt ihn aus der gerenderten Seite, während ein gewöhnlicher HTML-Kommentar ([<!-- -->]) an den Browser gesendet würde;
  • Zeile 3: Das Attribut [xmlns:th] deklariert den Namensraum für die Attribute [th:]. Es ist ausschließlich für Code-Editoren gedacht (Autovervollständigung, Validierung): [Thymeleaf] verarbeitet die Attribute [th:] auch ohne es und entfernt es aus der erzeugten Seite;
  • Zeile 6: Das Attribut [th:text] ersetzt den Inhalt des Tags durch den Wert des Ausdrucks. [${model.title}] ist ein Variablenausdruck: [model] ist das von der Action gesetzte Attribut des Modells, und [.title] ruft dessen Zugriffsmethode auf, [title()]. Der im Tag stehende Text „Page Title“ ist nur ein Beispiel, das angezeigt wird, wenn die Datei direkt in einem Browser geöffnet wird; er verschwindet aus der erzeugten Seite;
  • Zeilen 9–11: Dasselbe Prinzip gilt für Titel, Meldung und Uhrzeit. Um einen Wert mitten in einen Text einzufügen, umgeben Sie ihn mit einem [<span>]-Tag, das das Attribut [th:text] trägt.

[${...}]-Ausdrücke werden in der [Spring]-Ausdruckssprache geschrieben, [SpEL] ([Spring Expression Language]). [model.title] ruft die Methode [getTitle()] einer [JavaBean] oder die Methode [title()] eines Records auf: In beiden Fällen wird derselbe Code geschrieben.

Eine [Thymeleaf]-View wird nicht mit der Anwendung kompiliert: Sie wird beim Aufruf der Seite gelesen und interpretiert. Ein Fehler in einer View wird daher nicht zur Kompilierzeit gemeldet, sondern erst bei der Anzeige der Seite. Wenn Sie [${model.titl}] in die View schreiben, schlägt die Anfrage fehl (Statuscode 500), und die Serverkonsole zeigt Folgendes an: [Property or field 'titl' cannot be found on object of type 'example13.models.PageModel']. Ebenso verursacht ein View-Name, der keiner Datei entspricht, den Fehler [Error resolving template [views/missing], template might not exist or might not be accessible by any of the configured Template Resolvers]. Das Ergebnis unter http://localhost:5000/:

Image

Der Quelltext der vom Browser empfangenen Seite enthält keine Spur von [Thymeleaf] mehr:

curl http://localhost:5000/
<!doctype html>

<html lang="en">
<head>
  <meta charset="utf-8">
  <title>My first view</title>
</head>
<body>
  <h1>My first view</h1>
  <p>This page was built by Thymeleaf, on the server.</p>
  <p>Page built at <span>18:53:46</span>.</p>
</body>
</html>

Beachten Sie Folgendes:

  • Die Attribute [th:text] sind verschwunden, ersetzt durch die Werte des Modells, ebenso das Attribut [xmlns:th];
  • der [Thymeleaf]-Kommentar ist verschwunden, hinterlässt aber eine Leerzeile;
  • Akzentuierte Zeichen, falls vorhanden (diese englische Seite hat keine), werden unverändert geschrieben ([é], [è] ...): [Thymeleaf] maskiert nur Zeichen, die in HTML eine Bedeutung haben ([<], [>], [&], ["], [']). [Razor] kodiert akzentuierte Zeichen dagegen standardmäßig ([&#xE8;] für [è]), was im Kurs zu [ASP.NET Core MVC] eine Änderung einer Einstellung erzwingt; hier gibt es eine solche Anforderung nicht.

Die URL http://localhost:5000/hello/martin zeigt dieselbe View mit einem anderen Modell an:

Image

Hätte der Text einen Apostroph enthalten, würde der HTML-Code dieser Seite ihn als [&#39;] darstellen: Dies ist eines der Zeichen, die von [th:text] maskiert werden. Die URL http://localhost:5000/hello/unknown zeigt eine andere View:

curl -i http://localhost:5000/hello/unknown
HTTP/1.1 404
Content-Type: text/html;charset=UTF-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>

  <h1>Nobody is called [unknown] here.</h1>
</body>
</html>

Die Antwort hat tatsächlich den vom Objekt [ModelAndView] gesetzten Statuscode 404 ([Tomcat] sendet nur den Code, ohne seine Bezeichnung [Not Found]). Die Datei [templates/views/unknown.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <title>Unknown</title>
</head>
<body>
  <!--/* |...|: ein Text, in dem die Ausdrücke ${...} ersetzt werden */-->
  <h1 th:text="|Nobody is called [${name}] here.|">Nobody is called [xx] here.</h1>
</body>
</html>
  • Zeile 9: Ein von zwei senkrechten Strichen eingeschlossener Text, [|...|], ist eine literale Substitution: Die darin enthaltenen Ausdrücke [${...}] werden durch ihre Werte ersetzt. Das ist lesbarer als eine Folge von [<span>]. [${name}] ist das Attribut [name] des Modells, eine einfache Zeichenkette.

4.2. Beispiel 14: Die Sprache Thymeleaf

Eine [Thymeleaf]-View enthält keinerlei [Java]-Code: Alles läuft über die Attribute [th:] und die darin enthaltenen Ausdrücke. Dennoch bietet sie Bedingungen, Schleifen, lokale Variablen und Methodenaufrufe. Diese Mächtigkeit erfordert Disziplin: Die View muss ein reines Darstellungselement bleiben; Berechnungen und Entscheidungen gehören in die Action und die Services. Beispiel 14 gibt einen Überblick über die Syntax. Das Modell, Datei [models/BasicsModel.java]:

package example14.models;

import java.math.BigDecimal;
import java.util.List;

public record BasicsModel(
        String title,
        String name,
        String nickname,
        String html,
        boolean loggedIn,
        String currency,
        List<Product> products,
        List<Product> cart,
        Address address) {

    public record Product(String name, BigDecimal price, boolean inStock) {
    }

    public record Address(String street, String city) {
    }
}
  • Zeilen 6–15: Das Modell ist ein Record: einige Zeichenketten, ein Boolean, zwei Listen von Produkten und eine Adresse;
  • Zeilen 17–21: Zwei im ersten verschachtelte Records: [BasicsModel.Product] und [BasicsModel.Address]. Ein Preis ist ein [BigDecimal]; dieser [Java]-Typ repräsentiert exakte Dezimalzahlen (ein [double] kann [0.1] nicht exakt darstellen).

Die Datei [controllers/BasicsController.java]:

package example14.controllers;

import java.math.BigDecimal;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

import example14.models.BasicsModel;
import example14.models.BasicsModel.Address;
import example14.models.BasicsModel.Product;

@Controller
public class BasicsController {

    @GetMapping("/")
    public String index(Model model) {
        BasicsModel basicsModel = new BasicsModel(
                "Thymeleaf basics",
                "Martin",
                null,
                "<b>this is HTML</b>",
                true,
                "€",
                List.of(
                        new Product("Keyboard", new BigDecimal("25"), true),
                        new Product("Mouse", new BigDecimal("12.5"), false),
                        new Product("Screen", new BigDecimal("149"), true)),
                List.of(),
                new Address("12 rue des Lilas", "Angers"));
        model.addAttribute("model", basicsModel);
        return "basics/index";
    }
}
  • Zeilen 19–31: Die Action befüllt das Modell: einige Zeichenketten, ein Boolean, eine Liste mit drei Produkten, ein leerer Warenkorb und eine Adresse. Der Spitzname (Zeile 22) wird absichtlich auf [null] gesetzt. [List.of(...)] erzeugt eine schreibgeschützte Liste; [List.of()] erzeugt eine leere Liste.

Die View, Datei [templates/basics/index.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
  <meta charset="utf-8">
  <title th:text="${model.title}">Title</title>
</head>
<!--/* th:with: lokale Variablen, im Tag und seinen Nachfahren verwendbar */-->
<body th:with="total=${#aggregates.sum(model.products.![price])}, count=${#lists.size(model.products)}">
  <h1 th:text="${model.title}">Title</h1>
  <!--/* 1. einen Wert des Modells anzeigen; null zeigt nichts an. Dieses Thymeleaf
         Kommentar erscheint nicht in der erzeugten Seite */-->
  <p>1. Name: <span th:text="${model.name}">name</span> - nickname: [<span th:text="${model.nickname}">nickname</span>]</p>
  <!--/* 2. th:text maskiert HTML, th:utext fügt es unverändert ein */-->
  <p>2a. <span th:text="${model.html}">html</span></p>
  <p>2b. <span th:utext="${model.html}">html</span></p>
  <!--/* 3. eine Bedingung: th:if zeigt das Tag an, wenn die Bedingung wahr ist, th:unless, wenn sie falsch ist */-->
  <p th:if="${model.loggedIn}">3. You are logged in.</p>
  <p th:unless="${model.loggedIn}">3. You are not logged in.</p>
  <!--/* 4. eine Schleife: das Tag mit th:each wird wiederholt; stat: der Zustand der Schleife */-->
  <p>4. Our products:</p>
  <ul>
    <li th:each="product, stat : ${model.products}">no. [[${stat.index}]]: [[${product.name}]], [[${product.price}]] [[${model.currency}]]
      <span th:text="${product.inStock} ? '(in stock)' : '(sold out)'">(in stock)</span>
      <th:block th:if="${stat.first}">- the first one</th:block>
      <th:block th:if="${stat.last}">- the last one, seen by [[${model.name}]]</th:block>
    </li>
  </ul>
  <!--/* 5. die leere Liste */-->
  <p>5. Your cart:
    <th:block th:if="${#lists.isEmpty(model.cart)}">it is empty.</th:block>
    <span th:each="p : ${model.cart}" th:text="${p.name}">product</span>
  </p>
  <!--/* 6. berechnete Ausdrücke, die th:with-Variablen und ein Hilfsobjekt (#numbers) */-->
  <p th:text="|6. ${count} products, for a total of ${total} ${model.currency}; average price: ${#numbers.formatDecimal(total.doubleValue() / count, 1, 2)} ${model.currency}|">6.</p>
  <p>7. Address: [[${model.address.street}]], [[${#strings.toUpperCase(model.address.city)}]]</p>
  <p>8. An email address: contact@example.com</p>
</body>
</html>

Lassen Sie uns diesen Code kommentieren:

  • Zeile 8: Das Attribut [th:with] deklariert lokale Variablen, die innerhalb des Tags, das es enthält, und in allen seinen untergeordneten Tags verwendet werden können – hier [total] und [count] – im gesamten Body der Seite. [model.products.![price]] ist eine Projektion von [SpEL]: die Liste der Produktpreise. [#aggregates] und [#lists] sind Hilfsobjekte von [Thymeleaf] (sie beginnen mit [#]): [#aggregates.sum] berechnet die Summe einer Liste von Zahlen; [#lists.size] zählt die Elemente einer Liste;
  • Zeilen 10–11: ein [Thymeleaf]-Kommentar, der in der erzeugten Seite nicht enthalten ist;
  • Zeile 12: Ein Wert [null] ([${model.nickname}]) zeigt nichts an, ohne Fehler;
  • Zeilen 14–15: [th:text] maskiert die Sonderzeichen in HTML ([<] wird zu [&lt;] ...): Der Text wird unverändert angezeigt. [th:utext] ([unescaped text]) fügt ihn ohne Maskierung ein: Er wird als HTML interpretiert. [th:utext] wird nur für HTML verwendet, das von der Anwendung erzeugt wurde, niemals für Daten, die ein Benutzer eingegeben hat: Der Benutzer könnte HTML oder sogar [JavaScript] in die Seite einschleusen (ein Angriff, bekannt als [XSS], [cross-site scripting]);
  • Zeilen 17–18: eine Bedingung. [th:if] behält das Tag (und seinen Inhalt), wenn der Ausdruck wahr ist, und entfernt es andernfalls; [th:unless] tut das Gegenteil. Es gibt kein [th:else]: Man schreibt die gegenteilige Bedingung;
  • Zeile 22: eine Schleife. Das Attribut [th:each] wiederholt das Tag, das es enthält – hier [<li>] –, einmal für jedes Element der Liste. [product] ist das aktuelle Element; [stat], das optional ist, ist der Iterationszähler: [stat.index] (beginnend bei 0), [stat.count] (beginnend bei 1), [stat.size], [stat.first], [stat.last], [stat.even], [stat.odd]. Im Text des Tags ist [[[${product.name}]]] ein Inline-Ausdruck: Er fügt den Wert ein, maskiert wie bei [th:text], ohne das Tag [<span>] (die Form [[(...)]] fügt wie [th:utext] ohne Maskierung ein);
  • Zeile 23: der Bedingungsoperator [condition ? value1 : value2]. Literale Zeichenketten werden zwischen einfachen Anführungszeichen geschrieben;
  • Zeilen 24–25: [th:block] ist ein für [Thymeleaf] spezifisches Tag: Es dient nur dazu, die Attribute [th:] zu tragen, und verschwindet aus der erzeugten Seite, sodass nur sein Inhalt übrig bleibt. [stat.first] und [stat.last] prüfen die Position in der Schleife;
  • Zeilen 30–31: der Fall einer leeren Liste. [#lists.isEmpty] prüft, ob die Liste leer ist; eine Schleife [th:each] über eine leere Liste erzeugt nichts;
  • Zeile 34: eine literale Substitution [|...|] , die die Variablen aus [th:with] verwendet, und zwei Methodenaufrufe: [total.doubleValue()] wandelt [BigDecimal] in [double] um, und [#numbers.formatDecimal(value, 1, 2)] formatiert eine Zahl mit mindestens einer Stelle vor dem Dezimaltrennzeichen und genau zwei danach;
  • Zeile 35: ein Zugriff auf [model.address.street] und das Hilfsobjekt [#strings], das Operationen auf Zeichenketten bündelt ([toUpperCase], [isEmpty], [contains], [startsWith] ...);
  • Zeile 36: [Thymeleaf] verarbeitet nur die Attribute [th:] und die Inline-Ausdrücke [[[...]]]; der restliche Text wird unverändert kopiert. Das Zeichen [@] hat hier keine besondere Bedeutung.

Das Ergebnis unter http://localhost:5000/:

Image

Der erzeugte HTML-Code:

curl http://localhost:5000/
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Thymeleaf basics</title>
</head>

<body>
  <h1>Thymeleaf basics</h1>

  <p>1. Name: <span>Martin</span> - nickname: [<span></span>]</p>

  <p>2a. <span>&lt;b&gt;this is HTML&lt;/b&gt;</span></p>
  <p>2b. <span><b>this is HTML</b></span></p>

  <p>3. You are logged in.</p>


  <p>4. Our products:</p>
  <ul>
    <li>no. 0: Keyboard, 25 €
      <span>(in stock)</span>
      - the first one

    </li>
    <li>no. 1: Mouse, 12.5 €
      <span>(sold out)</span>


    </li>
    <li>no. 2: Screen, 149 €
      <span>(in stock)</span>

      - the last one, seen by Martin
    </li>
  </ul>

  <p>5. Your cart:
    it is empty.

  </p>

  <p>6. 3 products, for a total of 186.5 €; average price: 62.17 €</p>
  <p>7. Address: 12 rue des Lilas, ANGERS</p>
  <p>8. An email address: contact@example.com</p>
</body>
</html>

Beachten Sie Folgendes:

  • Die Tags [th:block], die [Thymeleaf]-Kommentare und die von [th:if] / [th:unless] entfernten Tags hinterlassen Leerzeilen, die keinen Einfluss auf die Anzeige haben;
  • Der Durchschnittspreis ist [62.17] bei [curl] und [62,17] im Browser. [#numbers.formatDecimal] verwendet die Sprache der Anfrage. Standardmäßig liest [Spring MVC] sie aus dem vom Browser gesendeten HTTP-Header [Accept-Language]: Ein auf Französisch eingestellter Browser sendet [Accept-Language: fr-FR] und erhält ein Komma; [curl] sendet diesen Header nicht, und die Sprache ist dann die des Systems, auf dem der Server läuft (hier Englisch; auf einem auf Französisch eingestellten Rechner würde [curl] ebenfalls ein Komma erhalten). Beispiel 16 und das Kapitel „Internationalisierung“ behandeln diesen Mechanismus;
  • die Preise selbst ([12.5]) werden von der Methode [toString] von [BigDecimal] erzeugt, die sprachunabhängig ist. Beispiel 16 formatiert sie.

Zum Abschluss dieses Beispiels hier die fünf Arten von Ausdrücken in [Thymeleaf], die in den Beispielen dieses und des nächsten Kapitels verwendet werden:

Ausdruck
Rolle
Beispiel
[${...}]
Variablenausdruck ([SpEL]): ein Attribut des Modells, eine Eigenschaft, ein Methodenaufruf, eine Bean ([${@name...}]), ein Hilfsobjekt ([${#strings...}])
13, 14, 16
[*{...}]
Auswahlausdruck: eine Eigenschaft des Objekts, das durch das Attribut [th:object] bezeichnet wird
18, 19, 21
[#{...}]
Nachricht: Text aus der Datei [messages.properties], in der Sprache der Anfrage
Nächstes Kapitel
[@{...}]
Link: eine URL mit ihren Variablen und Parametern
16, 21
[~{...}]
Fragment: ein einzufügender Abschnitt einer Seite
15 bis 21

Es gibt zahlreiche Hilfsobjekte: [#strings], [#numbers], [#lists], [#aggregates], [#dates] (Datumsangaben vom Typ [java.util.Date]), [#temporals] (Datumsangaben aus [java.time]: [LocalDate], [LocalDateTime] ...), [#locale] (die Sprache der Anfrage), [#ids], und [#fields] (Formulare, Beispiele 18 und 19) ... Die Dokumentation von [Thymeleaf] (https://www.thymeleaf.org) beschreibt sie alle.

4.3. Beispiel 15: Template, Fragmente, statische Dateien

Die Seiten einer Website teilen sich ein gemeinsames Template (Kopfbereich, Navigationsleiste, Fußbereich). Bei [Thymeleaf] sind die wiederverwendbaren Seitenbestandteile Fragmente; und das Template selbst ist ein Fragment, in das jede Seite ihren Inhalt einfügt. Schließlich benötigen die Seiten statische Dateien (Stylesheets, Bilder, Skripte), die unverändert ausgeliefert werden, ohne über einen Controller zu laufen. Die Dateien des Beispiels:

15-layout/
├── src/
│   └── main/
│       ├── java/
│       │   └── example15/
│       │       ├── config/
│       │       │   ├── CommonModel.java
│       │       │   └── WebConfig.java
│       │       ├── controllers/
│       │       │   └── PagesController.java
│       │       └── Example15Application.java
│       └── resources/
│           ├── static/
│           │   └── css/
│           │       └── styles.css
│           ├── templates/
│           │   ├── fragments/
│           │   │   ├── card.html
│           │   │   └── navbar.html
│           │   ├── pages/
│           │   │   ├── home.html
│           │   │   ├── raw.html
│           │   │   └── team.html
│           │   └── layout.html
│           └── application.properties
└── pom.xml

4.3.1. Die statischen Dateien

[Spring Boot] liefert die Dateien aus dem Ressourcenordner [static] automatisch ohne Controller aus: Die Datei [src/main/resources/static/css/styles.css] wird unter der URL [/css/styles.css] bereitgestellt. Entspricht keine Datei der URL und behandelt keine Action sie, lautet die Antwort 404. Prüfen wir das:

curl -i http://localhost:5000/css/styles.css
HTTP/1.1 200
Last-Modified: Fri, 25 Sep 2026 16:02:53 GMT
Accept-Ranges: bytes
Content-Type: text/css
Content-Length: 430

/* einige Einstellungen zusätzlich zu Bootstrap */
body {
  background-color: #f5f7fa;
}

/* der Footer des Layouts */
.footer {
  margin-top: 2rem;
  font-size: 0.85rem;
  color: #6c757d;
}

/* die Fehlermeldungen am Seitenende, auf hellrosa Hintergrund */
.error-area {
  margin-top: 1.5rem;
  padding: 0.75rem 1rem;
  background-color: #fdecef;
  border: 1px solid #f5c2c7;
  border-radius: 0.375rem;
  color: #842029;
}

Der Header [Last-Modified] liefert das Änderungsdatum der Datei: Der Browser sendet dieses Datum zurück, damit die Datei nur dann erneut übertragen wird, wenn sie sich geändert hat.

Das CSS-[Bootstrap]-Framework ist allen Beispielen gemeinsam: Es wird nur einmal gespeichert, im Ordner [examples/common/bootstrap], außerhalb der Ressourcen der Beispiele. Sie müssen daher [Spring MVC] mitteilen, wo es zu finden ist. Die Datei [config/WebConfig.java]:

package example15.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

// die Konfiguration von Spring MVC, ergänzt
@Configuration
public class WebConfig implements WebMvcConfigurer {

    // Bootstrap, von den Beispielen gemeinsam genutzt: der Ordner examples/common/bootstrap
    // wird unter der URL /bootstrap/... bereitgestellt
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/bootstrap/**")
                // "file:": ein Ordner auf der Festplatte, relativ zum aktuellen Ordner. Zwei
                // Versuche: Start aus dem Ordner des Beispiels oder aus [examples]
                .addResourceLocations("file:../common/bootstrap/", "file:common/bootstrap/");
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeile 8: eine Konfigurationsklasse (siehe Beispiel 06);
  • Zeile 9: Das Interface [WebMvcConfigurer] erlaubt uns, die Konfiguration zu ergänzen, die [Spring MVC] von [Spring Boot] erhalten hat, ohne sie zu ersetzen: Wir überschreiben nur die Methoden, die uns interessieren (alle anderen haben eine leere Standardimplementierung);
  • Zeilen 14–19: Die Methode [addResourceHandlers] deklariert Verzeichnisse für statische Dateien. Die Dateien der URL, die mit [/bootstrap/] beginnen (Zeile 15; [**] steht für eine beliebige Folge von Verzeichnissen und Dateien), werden aus dem Verzeichnis [common/bootstrap] ausgeliefert;
  • Zeile 18: Das Präfix [file:] bezeichnet einen Ordner auf der Festplatte (nicht im Classpath). Der Pfad ist relativ zum aktuellen Verzeichnis – dem, aus dem die Anwendung gestartet wurde: [../common/bootstrap/] bei Start aus dem Verzeichnis des Beispiels, [common/bootstrap/] bei Start aus dem Verzeichnis [examples]. Beide Orte werden der Reihe nach geprüft. So wird [examples/common/bootstrap/css/bootstrap.min.css] unter der URL [/bootstrap/css/bootstrap.min.css] ausgeliefert. Die Fallstudie hingegen legt [Bootstrap] in ihrem eigenen Ordner ab, [static].

Alle folgenden Beispiele verwenden diese Datei: [WebConfig.java].

4.3.2. Das Template

Die Datei [templates/layout.html]:

<!doctype html>
<!--/* das Layout der Seiten: ein Fragment mit zwei Parametern, dem Titel der
       Seite und ihrem Inhalt (selbst ein Fragment, von der Seite geliefert) */-->
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(title, content)">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title th:text="|${title} - My site|">My site</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3">
    <!--/* Einfügen des Fragments [navbar] aus der Datei fragments/navbar.html */-->
    <nav th:replace="~{fragments/navbar :: navbar}"></nav>
    <!--/* der von der Action angeforderte Seiteninhalt wird hier eingefügt */-->
    <main th:replace="${content}"></main>
    <!--/* path: dem Modell aller Views hinzugefügt (siehe config/CommonModel.java) */-->
    <footer class="footer" th:text="|Page [${path}] - © ${#dates.year(#dates.createNow())}|">footer</footer>
  </div>
</body>
</html>

Lassen Sie uns diesen Code aufschlüsseln:

  • Zeile 4: Das Attribut [th:fragment] macht das Tag [<html>] – und damit die gesamte Seite – zu einem Fragment namens [page], das zwei Parameter erwartet: [title] und [content]. Die Seiten der Anwendung rufen dieses Fragment auf und übergeben ihm ihren Titel und ihren Inhalt;
  • Zeile 8: Der Parameter [title] wird als Attribut des Modells verwendet;
  • Zeilen 9–10: die Stylesheets, die als statische Dateien ausgeliefert werden;
  • Zeile 15: Das Attribut [th:replace] ersetzt das Tag, das es enthält (hier [<nav>]), durch ein Fragment. [~{fragments/navbar :: navbar}] ist ein Fragmentausdruck: das Fragment [navbar] aus der Datei [templates/fragments/navbar.html] (links von [::] der View-Name, rechts der Fragmentname);
  • Zeile 17: die Stelle, an der der Inhalt der Seite eingefügt wird, den der Parameter [content] erhält; dieser Parameter ist selbst ein Fragment, das [th:replace] anstelle des Tags [<main>] einfügt;
  • Zeile 19: [path] ist der Pfad der angeforderten Seite. Das ist kein Fragmentparameter: Es ist ein Attribut, das dem Modell aller Views von einer Klasse hinzugefügt wird, auf die wir später eingehen. [#dates.createNow()] ist das aktuelle Datum, und [#dates.year] extrahiert daraus das Jahr.

Es gibt ein zweites Einfügeattribut, [th:insert], das das Fragment innerhalb des Host-Tags einfügt, statt es zu ersetzen. Bei einem Fragment [<span th:fragment="f">...</span>] erzeugt [<div th:replace="~{:: f}"></div>] das Ergebnis [<span>...</span>], und [<div th:insert="~{:: f}"></div>] erzeugt [<div><span>...</span></div>] ([~{:: f}] ohne View-Namen verweist auf ein Fragment der aktuellen View). Die Beispiele dieses Kurses verwenden [th:replace].

Die Datei [templates/fragments/navbar.html]:

1
2
3
4
5
6
7
8
9
<!--/* eine Fragmentdatei: jedes th:fragment-Tag ist ein wiederverwendbarer Seitenteil */-->
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3" th:fragment="navbar">
  <span class="navbar-brand">My site</span>
  <div class="navbar-nav">
    <a class="nav-link" href="/">Home</a>
    <a class="nav-link" href="/team">Team</a>
    <a class="nav-link" href="/raw">Page without layout</a>
  </div>
</nav>
  • Zeile 2: Eine Fragmentdatei ist keine vollständige Seite; sie enthält ein oder mehrere Tags mit dem Attribut [th:fragment]. Dieses Fragment hat keine Parameter. Beachten Sie, dass die Datei den Namensraum [xmlns:th] nicht deklariert; das ist nicht notwendig.

Die Datei [templates/fragments/card.html]:

1
2
3
4
5
6
7
<!--/* eine Bootstrap-"Card"; ihre zwei Parameter: ein Name und eine Rolle */-->
<div class="card" th:fragment="card(name, role)">
  <div class="card-body">
    <h5 class="card-title" th:text="${name}">Name</h5>
    <p class="card-text" th:text="${role}">Role</p>
  </div>
</div>
  • Zeile 2: Das Fragment [card] hat zwei Parameter, einen Namen und eine Funktion;
  • Zeilen 4–5: Die Parameter werden als Attribute des Modells verwendet.

4.3.3. Die Seiten

Die Datei [controllers/PagesController.java]:

package example15.controllers;

import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class PagesController {

    // ein Mitglied des Teams
    public record Member(String name, String role) {
    }

    @GetMapping("/")
    public String home() {
        return "pages/home";
    }

    @GetMapping("/team")
    public String team(Model model) {
        List<Member> members = List.of(
                new Member("Marie Pélissier", "Director"),
                new Member("Jacques Bromard", "Developer"),
                new Member("Philippe Jandot", "Graphic designer"));
        model.addAttribute("members", members);
        return "pages/team";
    }

    @GetMapping("/raw")
    public String raw() {
        return "pages/raw";
    }
}
  • Zeilen 13–14: der Typ der Teammitglieder, ein im Controller deklarierter Record ([PagesController.Member]);
  • Zeilen 17–19: Die Action [home] hat kein Modell; sie benötigt den Parameter [Model] nicht;
  • Zeilen 22–28: Die Action [team] übergibt eine Liste von Mitgliedern.

Die Datei [templates/pages/home.html]:

<!doctype html>
<!--/* die gesamte Seite wird durch das Fragment [page] des Layouts ERSETZT, dem wir
       den Titel und das Fragment [main] dieser Seite übergeben (~{::main}) */-->
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('Home', ~{::main})}">
<body>
<main>
  <h1>Welcome</h1>
  <p>This page only contains its own content: the header, the navigation
    bar and the footer come from the <code>layout.html</code> layout.</p>
  <!--/* das Fragment [card], mit zwei an Ort und Stelle geschriebenen Parametern */-->
  <div th:replace="~{fragments/card :: card('A fragment', 'inserted with parameters written on the spot')}"></div>
</main>
</body>
</html>

Lassen Sie uns diesen Code aufschlüsseln:

  • Zeile 4: Das Attribut [th:replace] des Tags [<html>] ersetzt die gesamte Seite durch das Fragment [page] aus dem Template [layout.html]. Es übergibt ihm zwei Parameter: den Titel, eine in einfache Anführungszeichen gesetzte literale Zeichenkette, und den Inhalt, [~{::main}]. Dieser Fragmentausdruck ohne View-Namen verweist auf ein Tag der aktuellen View: hier das Tag [<main>] (Zeilen 6–12). Das Template wird so erzeugt, wobei das Tag der Seite sein eigenes Tag ersetzt, [<main>];
  • Zeile 11: der Aufruf des Fragments [card] mit zwei fest vorgegebenen Parametern.

Alles in der Seite, was nicht im Tag [<main>] steht (zum Beispiel das Tag [<body>]), verschwindet: Nur das an das Template übergebene Fragment zählt. Die Tags [<html>] und [<body>] sind ausschließlich vorhanden, damit die Datei eine gültige HTML-Seite bleibt, die in einem Browser geöffnet werden kann.

Die Datei [templates/pages/team.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('Our team', ~{::main})}">
<body>
<main>
  <h1>Our team</h1>
  <div class="row g-3">
    <div class="col-md-4" th:each="member : ${members}">
      <!--/* das Fragment erhält den Namen und die Rolle des aktuellen Mitglieds */-->
      <div th:replace="~{fragments/card :: card(${member.name}, ${member.role})}"></div>
    </div>
  </div>
</main>
</body>
</html>
  • Zeile 7: Das Tag [<div class="col-md-4">] wird für jedes Mitglied wiederholt;
  • Zeile 9: Dem Fragment werden Name und Funktion des aktuellen Mitglieds übergeben: Das mit [th:replace] versehene Tag ist in das mit [th:each] versehene Tag geschachtelt, in dem die Variable [member] definiert ist.

Die Datei [templates/pages/raw.html]:

<!doctype html>
<!--/* diese View verwendet das Layout nicht: sie ist eine vollständige Seite */-->
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Raw page</title>
</head>
<body>
  <p>This page does not use the layout: no Bootstrap, no navigation bar.</p>
  <p><a href="/">Back to home</a></p>
</body>
</html>
  • Zeilen 3–11: Diese View ruft das Template nicht auf; sie ist eine vollständige Seite ohne Attribute [th:]. [Thymeleaf] kopiert sie unverändert (bis auf den Kommentar in Zeile 2). Eine View ist nicht verpflichtet, das Template zu verwenden.

Der HTML-Code der Seite http://localhost:5000/team zeigt das Ergebnis des Zusammenbaus:

curl http://localhost:5000/team
<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Our team - My site</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3">

    <nav class="navbar navbar-expand bg-light rounded mb-3 px-3">
  <span class="navbar-brand">My site</span>
  <div class="navbar-nav">
    <a class="nav-link" href="/">Home</a>
    <a class="nav-link" href="/team">Team</a>
    <a class="nav-link" href="/raw">Page without layout</a>
  </div>
</nav>

    <main>
  <h1>Our team</h1>
  <div class="row g-3">
    <div class="col-md-4">

      <div class="card">
  <div class="card-body">
    <h5 class="card-title">Marie Pélissier</h5>
    <p class="card-text">Director</p>
  </div>
</div>
    </div>
    <div class="col-md-4">

      <div class="card">
  <div class="card-body">
    <h5 class="card-title">Jacques Bromard</h5>
    <p class="card-text">Developer</p>
  </div>
</div>
    </div>
    <div class="col-md-4">

      <div class="card">
  <div class="card-body">
    <h5 class="card-title">Philippe Jandot</h5>
    <p class="card-text">Graphic designer</p>
  </div>
</div>
    </div>
  </div>
</main>

    <footer class="footer">Page [/team] - © 2026</footer>
  </div>
</body>
</html>

Der Titel, die Navigationsleiste, drei Karten und der Fußbereich wurden aus vier Dateien zusammengesetzt: [layout.html], [navbar.html], [team.html] und [card.html].

4.3.4. Ein allen Views gemeinsames Attribut

Der Fußbereich des Templates zeigt den Pfad der angeforderten Seite an, [path]. Mit [Razor] hat eine View direkten Zugriff auf die aktuelle Anfrage. Eine [Thymeleaf] -View konnte dies bis Version 3.0 ebenfalls, mithilfe des Objekts [#request]: Man hätte [${#request.requestURI}] geschrieben. Seit Version 3.1 ist das nicht mehr möglich. Eine View, die [#request] verwendet, verursacht einen 500-Fehler, und die Konsole zeigt an:

java.lang.IllegalArgumentException: The 'request','session','servletContext' and 'response' expression utility objects are no longer available by default for template expressions and their use is not recommended. In cases where they are really needed, they should be manually added as context variables.

Die Objekte [#request], [#session], [#servletContext], und [#response] wurden entfernt: Sie erlaubten es einer View, jeden Parameter der Anfrage zu lesen, was Injektionen Tür und Tor öffnete, und sie verbanden [Thymeleaf] mit der API der Servlets. Der Ausdruck [${#ctx.request.requestURI}] funktioniert ebenfalls nicht: [#ctx.request] ist gleich [null]. Die Fehlermeldung nennt die Lösung: Fügen Sie das, was die View benötigt, dem Modell hinzu. Damit dies für alle Views gilt, ohne dass jede Action es tun muss, erstellen wir die Datei [config/CommonModel.java]:

package example15.config;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ModelAttribute;

import jakarta.servlet.http.HttpServletRequest;

// @ControllerAdvice: diese Klasse ergänzt ALLE Controller der Anwendung
@ControllerAdvice
public class CommonModel {

    // @ModelAttribute: vor jeder Action ausgeführt, fügt diese Methode dem
    // Modell aller Views das Attribut [path] hinzu, den Pfad der angeforderten Seite
    @ModelAttribute("path")
    public String path(HttpServletRequest request) {
        return request.getRequestURI();
    }
}

Lassen Sie uns diesen Code kommentieren:

  • Zeile 9: Die Annotation [@ControllerAdvice] bezeichnet eine Klasse, die alle Controller der Anwendung erweitert. Was sie deklariert, gilt für jeden von ihnen, als wäre es in jedem einzelnen geschrieben;
  • Zeile 14: Eine mit [@ModelAttribute("path")] annotierte Methode wird vor jeder Action ausgeführt; ihr Rückgabewert wird dem Modell unter dem Namen [path] hinzugefügt. In einem Controller geschrieben, gilt sie für die Actions dieses Controllers (siehe Beispiel 18); in einer Klasse mit [@ControllerAdvice] geschrieben, gilt sie für alle Actions der Anwendung;
  • Zeilen 15–16: Die Methode kann dieselben Parameter wie eine Action entgegennehmen: hier die aktuelle Anfrage, [HttpServletRequest] (siehe Beispiel 05). [getRequestURI()] liefert den angeforderten Pfad ohne die Parameter.

Die Fallstudie verwendet dasselbe Verfahren (ihre Datei [web/CommonModel.java]), um allen ihren Views den Pfad, die Sprache und den angemeldeten Benutzer bereitzustellen.

Die resultierenden Seiten unter der URL http://localhost:5000/, http://localhost:5000/team und http://localhost:5000/raw:

Image

Image

Image

Das Template, die Fragmente und das gemeinsame Attribut [path] entsprechen genau dem, was die Fallstudie verwendet: ein [layout.html]-Template sowie Fragmente für die Navigationsleiste, die Meldungen und die Bestätigungsfenster.

4.4. Beispiel 16: Helper

Eine View benötigt oft kleine Formatierungsfunktionen: ein Datum oder einen Preis formatieren, einen Text großschreiben, das HTML für ein Badge erzeugen ... Diese werden als Helper bezeichnet. Mit [Thymeleaf] sind dies Methoden von [Spring]-Beans, die innerhalb eines Ausdrucks oder eines Fragments aufgerufen werden. [Thymeleaf] erlaubt es außerdem, eigene Attribute zu erstellen, die in einem Dialekt zusammengefasst werden.

4.4.1. Eine von den Views aufgerufene Bean

Die Datei [helpers/Formats.java]:

package example16.helpers;

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Currency;
import java.util.Locale;

import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Component;

// @Component("formats"): eine Bean namens [formats], die die Views
// mit ${@formats.money(...)} aufrufen
@Component("formats")
public class Formats {

    // "keyboard" -> "KEYBOARD"; Locale.ROOT: das Ergebnis hängt nicht von der Sprache ab
    public String uppercase(String text) {
        return text == null ? "" : text.toUpperCase(Locale.ROOT);
    }

    // ein Betrag in einer Währung, im Format der Sprache der Anfrage
    public String money(BigDecimal amount, String currency) {
        // die Sprache der aktuellen Anfrage, vom LocaleResolver festgelegt (siehe WebConfig)
        Locale language = LocaleContextHolder.getLocale();
        NumberFormat format = NumberFormat.getCurrencyInstance(language);
        format.setCurrency(Currency.getInstance(currency));
        return format.format(amount);
    }

    // dasselbe, in Euro
    public String money(BigDecimal amount) {
        return money(amount, "EUR");
    }

    // ein Datum in ausgeschriebener Form, in der Sprache der Anfrage: "Friday, September 25, 2026"
    public String date(LocalDate day) {
        return day.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).withLocale(LocaleContextHolder.getLocale()));
    }
}

Kommentieren wir diesen Code:

  • Zeile 16: Die Annotation [@Component] macht die Klasse zu einer Bean: [Spring] findet sie beim Start (genau wie die Controller), erzeugt eine Instanz davon und hält sie vor. ["formats"] ist der Name der Bean: Unter diesem Namen rufen die Views sie auf;
  • Zeilen 20–22: Großschreibung. [Locale.ROOT] macht das Ergebnis unabhängig von der Sprache des Benutzers;
  • Zeilen 25–31: ein Betrag in einer Währung, formatiert gemäß der Sprache der Anfrage. [LocaleContextHolder.getLocale()] (Zeile 27) liefert diese Sprache, ein [Locale]-Objekt, das von [Spring MVC] zu Beginn jeder Anfrage gesetzt wird. [NumberFormat.getCurrencyInstance] liefert das Währungsformat für diese Sprache: Dezimaltrennzeichen, Tausendertrennzeichen und Position des Währungssymbols; [setCurrency] wählt die Währung aus, die über ihren internationalen Code identifiziert wird ([EUR], [USD]);
  • Zeilen 34–36: eine überladene Methode: gleicher Name, andere Parameter. Wird keine Währung angegeben, gilt standardmäßig der Euro;
  • Zeilen 39–41: ein ausgeschriebenes Datum ([FormatStyle.FULL]) in der Sprache der Anfrage.

Die Seite [templates/pages/products.html] ruft diese Methoden auf:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('Products', ~{::main})}">
<body>
<main>
  <h1>Products</h1>
  <table class="table table-sm w-auto">
    <thead><tr><th>Product</th><th>Price</th><th>Price in dollars</th><th>Stock</th></tr></thead>
    <tbody>
      <tr th:each="product : ${products}">
        <td th:text="${@formats.uppercase(product.name)}">KEYBOARD</td>
        <td th:text="${@formats.money(product.price)}">€25.00</td>
        <td th:text="${@formats.money(product.price, 'USD')}">$25.00</td>
        <!--/* das Fragment [badge] erzeugt das HTML des Badges */-->
        <td><span th:replace="~{fragments/badge :: badge(${product.stock})}">badge</span></td>
      </tr>
    </tbody>
  </table>
</main>
</body>
</html>
  • Zeilen 10–12: In einem Ausdruck [${...}] verweist die Schreibweise [@formats] auf die Bean mit dem Namen [formats]: [${@formats.money(product.price)}] ruft ihre Methode [money] auf. Der Rückgabewert der Methode wird von [th:text] eingefügt und daher maskiert;
  • Zeile 14: Das Badge wird von einem Fragment erzeugt, das weiter unten beschrieben wird.

Die Datei [templates/fragments/badge.html]:

1
2
3
4
5
<!--/* ein Bootstrap-Badge: grün, wenn das Produkt auf Lager ist, sonst rot.
       Ein Fragment ist die Thymeleaf-Methode, ein wiederverwendbares HTML-Stück zu bauen */-->
<span class="badge" th:fragment="badge(stock)"
      th:classappend="${stock > 0} ? 'text-bg-success' : 'text-bg-danger'"
      th:text="${stock > 0} ? |${stock} in stock| : 'sold out'">12 in stock</span>
  • Zeile 3: Ein Helper, der HTML erzeugt, ist bei [Thymeleaf] ein Fragment: in diesem Fall ein [<span>]-Tag, das den Lagerbestand des Produkts als Parameter erhält;
  • Zeile 4: Das Attribut [th:classappend] fügt den vorhandenen Klassen des Tags ([badge]) eine CSS-Klasse hinzu: grün ([text-bg-success]), wenn das Produkt auf Lager ist, andernfalls rot;
  • Zeile 5: der Text des Badges, maskiert durch [th:text]. Anders als ein Helper, der HTML in einem String erzeugen würde, muss sich ein Fragment nicht um das Maskieren kümmern: [th:text] übernimmt das.

Der Controller, Datei [controllers/PagesController.java]:

package example16.controllers;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.List;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class PagesController {

    public record Product(String name, BigDecimal price, int stock) {
    }

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("today", LocalDate.now());
        return "pages/home";
    }

    @GetMapping("/products")
    public String products(Model model) {
        model.addAttribute("products", List.of(
                new Product("keyboard", new BigDecimal("25"), 12),
                new Product("mouse", new BigDecimal("12.5"), 0),
                new Product("screen", new BigDecimal("1149.9"), 3)));
        return "pages/products";
    }
}
  • Zeile 19: Die Startseite erhält das heutige Datum, ein [LocalDate] (ein Datum ohne Uhrzeit);
  • Zeilen 25–28: die Produktliste.

Die Datei [templates/pages/home.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page('Home', ~{::main})}">
<body>
<main>
  <h1>Home</h1>
  <!--/* @formats: die Bean namens [formats]; wir rufen ihre Methode date auf */-->
  <p th:text="|Today is ${@formats.date(today)}.|">Today is...</p>
  <!--/* #locale: die Sprache der Anfrage */-->
  <p>Formatting language: <span th:text="${#locale}">en_US</span>
    (<a href="/?lang=fr">in French</a>, <a href="/">in English</a>)</p>
</main>
</body>
</html>
  • Zeile 7: der Aufruf der Methode [date] der Bean [formats] in einer literalen Substitution;
  • Zeile 9: das Hilfsobjekt [#locale] ist die Sprache der Anfrage.

4.4.2. Die Sprache der Anfrage

Was bestimmt die Sprache der Anfrage? Eine Bean von [Spring MVC], der Sprachresolver ([LocaleResolver]). Der Resolver, den [Spring Boot] standardmäßig installiert, [AcceptHeaderLocaleResolver], liest den vom Browser gesendeten Header [Accept-Language]: Das war die Ursache für die unterschiedlichen Ergebnisse bei Browser und [curl] in Beispiel 14. Damit sich beide Sprachen leicht testen lassen, ersetzt Beispiel 16 ihn durch einen Resolver, der den Parameter [lang] aus der URL liest. Die Datei [config/WebConfig.java]:

package example16.config;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import example16.helpers.ActiveDialect;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

// die Konfiguration von Spring MVC, ergänzt
@Configuration
public class WebConfig implements WebMvcConfigurer {

    // Bootstrap, von den Beispielen gemeinsam genutzt: der Ordner examples/common/bootstrap
    // wird unter der URL /bootstrap/... bereitgestellt
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/bootstrap/**")
                // "file:": ein Ordner auf der Festplatte, relativ zum aktuellen Ordner. Zwei
                // Versuche: Start aus dem Ordner des Beispiels oder aus [examples]
                .addResourceLocations("file:../common/bootstrap/", "file:common/bootstrap/");
    }

    // unser Thymeleaf-Dialekt (das Attribut ex:active), der der View-Engine hinzugefügt wird
    @Bean
    public ActiveDialect activeDialect() {
        return new ActiveDialect();
    }

    // die Formatierungssprache jeder Anfrage: der URL-Parameter ?lang=fr,
    // sonst Englisch. Die Bean muss [localeResolver] heißen: unter diesem
    // Namen sucht Spring MVC sie.
    @Bean
    public LocaleResolver localeResolver() {
        return new LanguageParameterResolver();
    }

    // ein LocaleResolver legt die Sprache (Locale) jeder Anfrage fest; Spring speichert sie
    // im LocaleContextHolder, wo die Views und die Helfer sie wiederfinden
    static class LanguageParameterResolver implements LocaleResolver {

        @Override
        public Locale resolveLocale(HttpServletRequest request) {
            return "fr".equals(request.getParameter("lang")) ? Locale.FRANCE : Locale.US;
        }

        @Override
        public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
            throw new UnsupportedOperationException("the language is set by the URL");
        }
    }
}

Kommentieren wir diesen Code:

  • Zeilen 21–27: die Dateien von [Bootstrap] wie in Beispiel 15;
  • Zeilen 30–33: unser [Thymeleaf]-Dialekt, der weiter unten beschrieben wird, als Bean deklariert. [Spring Boot] fügt alle Beans, die Dialekte sind, automatisch der [Thymeleaf]-Engine hinzu;
  • Zeilen 38–41: unser Sprachresolver. Die Bean muss den Namen [localeResolver] tragen: Unter diesem Namen sucht [Spring MVC] sie. Eine Methode mit dem Namen [@Bean] liefert den Namen der Bean: [localeResolver()]. Mit der Deklaration dieser Bean ersetzen wir diejenige von [Spring Boot];
  • Zeilen 45–56: Der Resolver ist eine verschachtelte Klasse, die das Interface [LocaleResolver] implementiert;
  • Zeilen 48–50: Die Methode [resolveLocale] wird zu Beginn jeder Anfrage aufgerufen: Sie liefert Französisch ([Locale.FRANCE]), wenn die URL [lang=fr] enthält; andernfalls liefert sie amerikanisches Englisch ([Locale.US]). [Spring MVC] speichert diese Sprache in [LocaleContextHolder], wo sie von der Bean [formats] und den Hilfsobjekten von [Thymeleaf] abgerufen wird;
  • Zeilen 53–55: Die Methode [setLocale] würde es ermöglichen, die Sprache zu ändern (indem man sie beispielsweise in einem Cookie speichert). Hier stammt die Sprache aus der URL: Die Methode verweigert die Arbeit, indem sie eine Exception auslöst.

Das ist eine einfache Möglichkeit zum Testen; das nächste Kapitel behandelt das Thema gründlicher.

4.4.3. Ein Thymeleaf-Dialekt

Die Navigationsleiste hebt den Link der aktuellen Seite hervor (CSS-Klasse [active] von [Bootstrap]). Die Datei [templates/fragments/navbar.html] zeigt drei Möglichkeiten, Links zu schreiben:

<!--/* xmlns:ex: der Namespace unseres Dialekts (nur für Editoren nützlich) */-->
<nav class="navbar navbar-expand bg-light rounded mb-3 px-3" th:fragment="navbar"
     xmlns:th="http://www.thymeleaf.org" xmlns:ex="http://example16">
  <span class="navbar-brand">Helpers</span>
  <div class="navbar-nav">
    <!--/* 1. eine in der View geschriebene Bedingung (path: siehe config/CommonModel.java) */-->
    <a class="nav-link" th:classappend="${path == '/'} ? 'active'" href="/">Home</a>
    <!--/* 2. unser Dialekt: das Attribut ex:active="..." */-->
    <a class="nav-link" href="/products" ex:active="/products">Products</a>
    <!--/* 3. ein Link-Ausdruck @{...}: Spring baut die URL mit ihren Parametern */-->
    <a class="nav-link" th:href="@{/products(lang=fr)}">Produits (fr)</a>
  </div>
</nav>

Gehen wir diesen Code durch:

  • Zeile 3: Der Namespace [xmlns:ex] ist wie [xmlns:th] nur für Editoren gedacht;
  • Zeile 7: die erste Möglichkeit, den Link der aktuellen Seite hervorzuheben: eine in der View geschriebene Bedingung, die das Attribut [path] verwendet, das von der Klasse [CommonModel] bereitgestellt wird (identisch mit der aus Beispiel 15). Ohne „else“-Zweig erzeugt der Bedingungsoperator nichts, wenn die Bedingung falsch ist, und [th:classappend] fügt daher keine Klasse hinzu. Diese Methode wird in der Fallstudie verwendet;
  • Zeile 9: die zweite, knappere Möglichkeit: ein Attribut „home“, [ex:active], das von unserem Dialekt bereitgestellt wird;
  • Zeile 11: ein Link-Ausdruck [@{...}]. [Spring] erzeugt die URL: Die Klammern enthalten Parameter, die an die URL angehängt werden ([?lang=fr]). In Beispiel 21 sehen wir, dass sie auch dazu dienen, Pfadvariablen zu füllen. Ein Link-Ausdruck fügt bei Bedarf außerdem den Basispfad der Anwendung hinzu, wenn die Anwendung nicht im Stammverzeichnis des Servers installiert ist.

Ein Dialekt ist eine Menge von Attributen (oder Tags), die ein Präfix gemeinsam haben: Die Attribute [th:] gehören zum Standarddialekt von [Thymeleaf]. Jedes Attribut wird von einem Prozessor verarbeitet. Die Datei [helpers/ActiveDialect.java]:

package example16.helpers;

import java.util.Set;

import org.thymeleaf.dialect.AbstractProcessorDialect;
import org.thymeleaf.processor.IProcessor;
import org.thymeleaf.standard.StandardDialect;

// ein Thymeleaf-DIALEKT: eine Menge "selbstgebauter" Attribute, alle mit dem Präfix
// [ex:] (ex:active="..."). Als Bean deklariert (siehe WebConfig), wird er von Spring Boot
// automatisch der Thymeleaf-Engine hinzugefügt.
public class ActiveDialect extends AbstractProcessorDialect {

    public ActiveDialect() {
        // Name des Dialekts, Präfix seiner Attribute, Rangfolge (die der th:-Attribute)
        super("Active", "ex", StandardDialect.PROCESSOR_PRECEDENCE);
    }

    // die "Prozessoren" des Dialekts: ein einziger, für das Attribut ex:active
    @Override
    public Set<IProcessor> getProcessors(String prefix) {
        return Set.of(new ActiveProcessor(prefix));
    }
}
  • Zeile 12: Ein Dialekt, der nur Prozessoren bereitstellt, wird von der Klasse [AbstractProcessorDialect] abgeleitet;
  • Zeile 16: der Name des Dialekts, das Präfix seiner Attribute ([ex]) und seine Priorität: dieselbe wie die der Attribute [th:];
  • Zeilen 21–23: die Prozessoren des Dialekts: nur einer, nämlich der des Attributs [ex:active]. [Set.of(...)] erzeugt eine unveränderliche Menge.

Die Datei [helpers/ActiveProcessor.java]:

package example16.helpers;

import org.thymeleaf.context.ITemplateContext;
import org.thymeleaf.context.IWebContext;
import org.thymeleaf.engine.AttributeName;
import org.thymeleaf.model.IProcessableElementTag;
import org.thymeleaf.processor.element.AbstractAttributeTagProcessor;
import org.thymeleaf.processor.element.IElementTagStructureHandler;
import org.thymeleaf.templatemode.TemplateMode;

// der Prozessor des Attributs ex:active: <a href="/products" ex:active="/products">
// erhält die Klasse "active", wenn die aktuelle Seite unter diesem Pfad liegt
public class ActiveProcessor extends AbstractAttributeTagProcessor {

    public ActiveProcessor(String prefix) {
        // HTML; nur <a>-Tags; Attribut [ex:active]; Rangfolge; true: das
        // Attribut ex:active wird aus der erzeugten Seite entfernt
        super(TemplateMode.HTML, prefix, "a", false, "active", true, 1000, true);
    }

    // aufgerufen für jedes <a>-Tag, das das Attribut ex:active trägt
    @Override
    protected void doProcess(ITemplateContext context, IProcessableElementTag tag,
            AttributeName attributeName, String value, IElementTagStructureHandler structure) {
        // der Pfad der Seite, aus der aktuellen Anfrage gelesen
        String path = context instanceof IWebContext web ? web.getExchange().getRequest().getRequestPath() : "";
        boolean isActive = value.equals("/") ? path.equals("/") : path.startsWith(value);
        if (isActive) {
            // wir fügen dem class-Attribut des Tags die Klasse "active" hinzu
            String classes = tag.getAttributeValue("class");
            structure.setAttribute("class", classes == null ? "active" : classes + " active");
        }
    }
}

Kommentieren wir diesen Code:

  • Zeile 13: ein Attributprozessor, der von der Klasse [AbstractAttributeTagProcessor] abgeleitet ist;
  • Zeile 18: Sein Konstruktor beschreibt, was er verarbeitet: den HTML-Modus, das Dialektpräfix, ausschließlich [<a>]-Tags, das Attribut [active] (mit Präfix: [ex:active]), eine Priorität und [true]: Das Attribut [ex:active] wird aus der erzeugten Seite entfernt;
  • Zeilen 23–24: Die Methode [doProcess] wird für jedes [<a>]-Tag aufgerufen, das das Attribut [ex:active] besitzt. Sie erhält den View-Kontext, das Tag und den Attributwert; das Objekt [structure] ermöglicht es, das Tag zu ändern;
  • Zeile 26: Der Prozessor ist [Java]-Code und kein View-Ausdruck: Er darf die aktuelle Anfrage lesen. Wenn die View für eine Webanfrage gerendert wird, ist der Kontext ein [IWebContext], der Zugriff auf den Austausch (die Anfrage und ihre Antwort) bietet; [getRequestPath()] liefert den angeforderten Pfad. Der Ausdruck [context instanceof IWebContext web] prüft den Typ des Kontexts und speichert ihn gegebenenfalls in der Variablen [web];
  • Zeilen 27–32: Beginnt der Seitenpfad mit dem Attributwert, wird die Klasse [active] zum Attribut [class] des Tags hinzugefügt.

Der HTML-Code der Navigationsleiste unter der URL [/products]:

    <nav class="navbar navbar-expand bg-light rounded mb-3 px-3" xmlns:ex="http://example16">
  <span class="navbar-brand">Helpers</span>
  <div class="navbar-nav">

    <a class="nav-link" href="/">Home</a>

    <a class="nav-link active" href="/products">Products</a>

    <a class="nav-link" href="/products?lang=fr">Produits (fr)</a>
  </div>
</nav>

Dem Link „Products“ wurde die Klasse [active] zugewiesen, und das Attribut [ex:active] wurde entfernt. Der Link-Ausdruck hat [/products?lang=fr] erzeugt. Beachten Sie, dass [Thymeleaf] das Attribut [xmlns:th] entfernt hat, nicht aber das Attribut [xmlns:ex]: Letzteres kennt es nicht. Es hätte weggelassen werden können, da es nur von Editoren verwendet wird.

Das Template [layout.html] ist das aus Beispiel 15, jedoch ohne Fußzeile (und die Seitentitel enden mit [- Helpers] statt mit [- My site]). Die resultierenden Seiten, zunächst auf Englisch (http://localhost:5000/, http://localhost:5000/products) und dann auf Französisch (http://localhost:5000/products?lang=fr):

Image

Image

Image

Die Preise ändern ihr Format je nach Sprache: [1 149,90 €] auf Französisch, [€1,149.90] auf Englisch. Auf Französisch wird der Dollar als [$US] geschrieben, um ihn von anderen Währungen (kanadisch, australisch usw.) zu unterscheiden. Der HTML-Code der Tabelle auf Französisch ([/products?lang=fr]):

    <tbody>
      <tr>
        <td>KEYBOARD</td>
        <td>25,00 €</td>
        <td>25,00 $US</td>

        <td><span class="badge text-bg-success">12 in stock</span></td>
      </tr>
      <tr>
        <td>MOUSE</td>
        <td>12,50 €</td>
        <td>12,50 $US</td>

        <td><span class="badge text-bg-danger">sold out</span></td>
      </tr>
      <tr>
        <td>SCREEN</td>
        <td>1 149,90 €</td>
        <td>1 149,90 $US</td>

        <td><span class="badge text-bg-success">3 in stock</span></td>
      </tr>
    </tbody>

und auf Englisch ([/products]), wo der Dollar einfach als [$] geschrieben wird:

    <tbody>
      <tr>
        <td>KEYBOARD</td>
        <td>€25.00</td>
        <td>$25.00</td>

        <td><span class="badge text-bg-success">12 in stock</span></td>
      </tr>
      <tr>
        <td>MOUSE</td>
        <td>€12.50</td>
        <td>$12.50</td>

        <td><span class="badge text-bg-danger">sold out</span></td>
      </tr>
      <tr>
        <td>SCREEN</td>
        <td>€1,149.90</td>
        <td>$1,149.90</td>

        <td><span class="badge text-bg-success">3 in stock</span></td>
      </tr>
    </tbody>

Nur die Beträge haben sich geändert: Der Text der Badges ist fest im Fragment codiert (das nächste Kapitel übersetzt die Texte).

4.5. Beispiel 17: Ein GET-Formular

Ein HTML-Formular, das per GET-Methode gesendet wird, legt seine Felder in der URL ab. Das ist die geeignete Methode für eine Suche: Sie ändert nichts, und die resultierende URL kann als Lesezeichen gespeichert oder geteilt werden. Die Fallstudie verwendet sie, um einen Arzt und ein Datum auszuwählen.

Die Dateien [models/Book.java] and [models/SearchModel.java] :

1
2
3
4
package example17.models;

public record Book(String title, String author, String genre) {
}
1
2
3
4
5
6
7
package example17.models;

import java.util.List;

// das View-Modell: die Eingabe (um sie erneut anzuzeigen), die Genres, die Ergebnisse
public record SearchModel(String keyword, String genre, List<String> genres, List<Book> results) {
}
  • Zeile 6: Das View-Template enthält die eingegebenen Werte ([keyword], [genre]), damit das Formular sie erneut anzeigen kann, zusammen mit der Liste der Genres und den Ergebnissen.

Die Datei [controllers/BooksController.java]:

package example17.controllers;

import java.util.List;
import java.util.Locale;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

import example17.models.Book;
import example17.models.SearchModel;

@Controller
public class BooksController {

    private static final List<Book> BOOKS = List.of(
            new Book("Le Rouge et le Noir", "Stendhal", "novel"),
            new Book("Les Fleurs du mal", "Baudelaire", "poetry"),
            new Book("Madame Bovary", "Flaubert", "novel"),
            new Book("Alcools", "Apollinaire", "poetry"),
            new Book("Le Cid", "Corneille", "drama"));

    private static final List<String> GENRES = List.of("novel", "poetry", "drama");

    // GET / und GET /search?keyword=...&genre=...: das Formular UND seine Ergebnisse
    @GetMapping({ "/", "/search" })
    public String search(@RequestParam(required = false) String keyword,
            @RequestParam(required = false) String genre, Model model) {
        String word = keyword == null ? "" : keyword.trim().toLowerCase(Locale.ROOT);
        List<Book> results = BOOKS.stream()
                .filter(b -> word.isEmpty() || b.title().toLowerCase(Locale.ROOT).contains(word)
                        || b.author().toLowerCase(Locale.ROOT).contains(word))
                .filter(b -> genre == null || genre.isEmpty() || b.genre().equals(genre))
                .toList();
        model.addAttribute("model", new SearchModel(keyword == null ? "" : keyword,
                genre == null ? "" : genre, GENRES, results));
        return "books/search";
    }
}

Gehen wir diesen Code durch:

  • Zeilen 17–24: die Bücher und Genres im Speicher;
  • Zeile 27: Eine einzelne Action kann mehreren Pfaden entsprechen; sie verarbeitet sowohl [GET /] als auch [GET /search];
  • Zeilen 28–29: Die Parameter [keyword] und [genre] werden an die gleichnamigen Parameter der URL gebunden (siehe Beispiel 07). [required = false] macht sie optional: Beim ersten Aufruf wurde das Formular noch nicht gesendet, und ihre Werte sind [null];
  • Zeilen 31–35: Filterung mithilfe eines Streams ([stream]) [Java] (siehe Beispiel 06): [stream()] durchläuft die Liste; jeder [filter] behält nur die Bücher, die eine Bedingung erfüllen; und [toList()] sammelt die ausgewählten Bücher in einer neuen Liste. Die Bedingungen sind Lambda-Ausdrücke: [b -> ...] ist eine anonyme Funktion, die ein Buch [b] entgegennimmt und einen Booleschen Wert zurückgibt. Ein leeres Schlüsselwort oder ein leeres Genre filtert nichts;
  • Zeilen 36–37: das View-Template. Hier werden die [null]-Werte durch leere Strings ersetzt.

Das Template [templates/layout.html] ist vereinfacht: ein einziger Parameter – der Seiteninhalt – und ein fester Titel:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Books</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3">
    <main th:replace="${content}"></main>
  </div>
</body>
</html>
  • Zeile 2: Das Fragment [page] hat nun nur noch einen Parameter, [content];
  • Zeile 5: Der Titel ist für alle Seiten gleich.

Die Datei [templates/books/search.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3">Book search</h1>
  <!--/* method="get": die Felder werden in der URL gesendet (?keyword=...&genre=...) */-->
  <form method="get" action="/search" class="row g-2 align-items-end mb-3">
    <div class="col-auto">
      <label class="form-label" for="keyword">Title or author</label>
      <!--/* th:value: das Feld zeigt erneut an, was eingegeben wurde */-->
      <input class="form-control" id="keyword" name="keyword" th:value="${model.keyword}">
    </div>
    <div class="col-auto">
      <label class="form-label" for="genre">Genre</label>
      <select class="form-select" id="genre" name="genre">
        <option value="">(all)</option>
        <!--/* th:selected: ein boolesches Attribut, das geschrieben wird, wenn die Bedingung wahr ist, sonst entfällt */-->
        <option th:each="genre : ${model.genres}" th:value="${genre}" th:text="${genre}"
                th:selected="${genre == model.genre}">novel</option>
      </select>
    </div>
    <div class="col-auto">
      <button class="btn btn-primary" type="submit">Search</button>
    </div>
  </form>
  <p th:text="|${#lists.size(model.results)} book(s) found.|">0 book(s) found.</p>
  <ul>
    <li th:each="book : ${model.results}"><i th:text="${book.title}">Title</i>, [[${book.author}]] ([[${book.genre}]])</li>
  </ul>
</main>
</body>
</html>

Gehen wir diesen Code durch:

  • Zeile 2: Die Seite übergibt ihren einzigen Parameter – das [<main>]-Tag – an das Template;
  • Zeile 7: [method="get"] und [action="/search"]: Das Absenden des Formulars ist eine [GET /search?keyword=...&genre=...]-Anfrage. Die Parameternamen sind das Attribut [name] jedes Feldes;
  • Zeile 11: Das Attribut [th:value] setzt das Attribut [value] des Feldes: Es stellt den eingegebenen Wert wieder her. Allgemein berechnet [th:xxx] den Wert der HTML-Attribute [xxx]: [th:value], [th:href], [th:action], [th:class] ...
  • Zeilen 18–19: eine Option pro Genre. Innerhalb desselben Tags wird [th:each] zuerst verarbeitet, danach [th:value] und [th:text], die die Schleifenvariable verwenden. [th:selected] ist ein Boolesches Attribut: Ist der Ausdruck wahr, schreibt [Thymeleaf] [selected="selected"]; ist er falsch, schreibt es das Attribut gar nicht. Genau das verlangt HTML; bei diesem Attribut genügt allein das Vorhandensein des Attributs [selected], um die Option auszuwählen. Dasselbe gilt für [th:checked], [th:disabled], [th:required], [th:readonly] ...;
  • Zeile 26: die Anzahl der Ergebnisse;
  • Zeile 28: die Liste der Ergebnisse mit einem [<i>]-Tag und zwei Inline-Ausdrücken.

Der HTML-Code der Dropdown-Liste nach einer Suche wie [poetry]:

1
2
3
4
5
6
7
8
9
      <select class="form-select" id="genre" name="genre">
        <option value="">(all)</option>

        <option value="novel">novel</option>

        <option value="poetry" selected="selected">poetry</option>

        <option value="drama">drama</option>
      </select>

Bei der ersten Anzeige (http://localhost:5000/) und dann nach einer Suche:

Image

Image

Die Adressleiste zeigt die gesendeten Parameter. Hier enthalten sie nur einfache Buchstaben; Sonderzeichen würden dort codiert (ein Akzent-[é] wird beispielsweise zu [%C3%A9]): Das ist die URL-Codierung, die [Spring MVC] decodiert, bevor die Parameter verkettet werden.

4.6. Beispiel 18: Formularfelder

Beispiel 18 kombiniert alle Arten von HTML-Feldern: Text, Passwort, Datum, Optionsfelder, Kontrollkästchen, Dropdown-Liste, Mehrfachauswahlliste, Textfeld und verstecktes Feld. Es zeigt, wie der Server sie empfängt und wie die View sie anzeigt. Außerdem führt es das Attribut [th:field] ein, das ein Formularfeld mit einer Eigenschaft eines Modellobjekts verbindet.

Die Datei [services/ListsService.java]:

package example18.services;

import java.util.List;

import org.springframework.stereotype.Service;

// die vom Formular angebotenen Listen. In einer echten Anwendung würden sie
// aus einer Datenbank stammen: wir würden sie EINMAL beim Start lesen,
// da sie für alle Benutzer gleich sind.
// @Service: eine Bean (Singleton), von Spring wie die Controller gefunden
@Service
public class ListsService {

    public record Country(String code, String name) {
    }

    public List<String> getTitles() {
        return List.of("Mr", "Mme", "Melle");
    }

    public List<Country> getCountries() {
        return List.of(new Country("fr", "France"), new Country("be", "Belgium"), new Country("ch", "Switzerland"),
                new Country("ca", "Canada"));
    }

    public List<String> getHobbies() {
        return List.of("reading", "music", "sport", "cinema");
    }

    public List<String> getLanguages() {
        return List.of("French", "English", "Spanish", "German");
    }
}
  • Zeile 11: Die Annotation [@Service] macht die Klasse zu einer Bean, genau wie [@Component] (Beispiel 16): [Spring] findet sie beim Start und erzeugt eine einzige Instanz davon, einen Singleton (siehe Beispiel 06), der in Controller injiziert werden kann. [@Service] unterscheidet sich von [@Component] nur in der Absicht, die es ausdrückt: Die Klasse ist ein Service. Die vom Formular bereitgestellten Listen sind für alle Benutzer gleich: Ein Singleton ist der natürliche Ort, um sie zu speichern;
  • Zeilen 14–15: ein Land – ein Code und ein Name;
  • Zeilen 17–32: die Listen, zurückgegeben von den Methoden [getXxx()]. Für eine View sind dies die Eigenschaften [titles], [countries], [hobbies] und [languages] der Bean: [${lists.titles}] ruft [getTitles()] auf.

Die Datei [models/Input.java]:

package example18.models;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

import org.springframework.format.annotation.DateTimeFormat;

// was der Benutzer eingegeben hat: das Model Binding füllt jedes Feld
// mit dem Parameter gleichen Namens (die Listen erhalten alle angekreuzten Werte)
public class Input {

    private String name;
    private String password;
    private String comment;
    private String title;
    private List<String> hobbies = new ArrayList<>();
    private String country;
    private List<String> languages = new ArrayList<>();
    // ein Feld <input type="date"> sendet das Datum im ISO-Format: yyyy-mm-dd
    @DateTimeFormat(iso = DateTimeFormat.ISO.DATE)
    private LocalDate birthDate;
    private String token;

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public String getComment() { return comment; }
    public void setComment(String comment) { this.comment = comment; }

    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }

    public List<String> getHobbies() { return hobbies; }
    public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }

    public String getCountry() { return country; }
    public void setCountry(String country) { this.country = country; }

    public List<String> getLanguages() { return languages; }
    public void setLanguages(List<String> languages) { this.languages = languages; }

    public LocalDate getBirthDate() { return birthDate; }
    public void setBirthDate(LocalDate birthDate) { this.birthDate = birthDate; }

    public String getToken() { return token; }
    public void setToken(String token) { this.token = token; }
}

Kommentieren wir diesen Code:

  • Zeilen 13–23: Die Eingabe ist eine Klasse im Stil einer [JavaBean] (private Felder, ein parameterloser Konstruktor und Accessoren [getXxx] und [setXxx]), kein Record: Das Model Binding erzeugt sie leer und befüllt dann jede Eigenschaft mit dem gleichnamigen Parameter über ihren Setter [setXxx];
  • Zeilen 17 und 19: Die Kontrollkästchen und die Mehrfachauswahlliste sind Listen: Sie erhalten alle gesendeten Werte (siehe Beispiel 10). Sie werden mit einer leeren Liste initialisiert, niemals mit [null];
  • Zeilen 21–22: Ein Feld [<input type="date">] sendet das Datum im Format [ISO 8601] [yyyy-mm-dd]. Die Annotation [@DateTimeFormat(iso = DateTimeFormat.ISO.DATE)] gibt dieses Format an [Spring] weiter, das es in beide Richtungen verwendet: um den empfangenen Text in [LocalDate] umzuwandeln und um das Datum im Feld wieder auszugeben.

Die Datei [controllers/FormController.java]:

package example18.controllers;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import example18.models.Input;
import example18.services.ListsService;
import jakarta.servlet.http.HttpServletRequest;

@Controller
@RequestMapping("/form")
public class FormController {

    private final ListsService lists;

    public FormController(ListsService lists) {
        this.lists = lists;
    }

    // @ModelAttribute auf einer Methode: vor JEDER Action dieses
    // Controllers ausgeführt, fügt sie dem Modell das Attribut [lists] hinzu
    @ModelAttribute("lists")
    public ListsService lists() {
        return lists;
    }

    // GET: das Formular, mit Anfangswerten
    @GetMapping("")
    public String display(Model model) {
        Input initial = new Input();
        initial.setTitle("Mme");
        initial.setCountry("fr");
        initial.setLanguages(List.of("French"));
        initial.setToken("A7X2");
        model.addAttribute("input", initial);
        return "form/form";
    }

    // POST: das Model Binding füllt [input], dem Modell unter dem Namen
    // "input" hinzugefügt (der Name seiner Klasse, erster Buchstabe klein); wir zeigen es erneut an
    @PostMapping("")
    public String process(@ModelAttribute Input input, HttpServletRequest request, Model model) {
        // was der Browser tatsächlich gesendet hat, Parameter für Parameter
        Map<String, String[]> parameters = request.getParameterMap();
        String received = parameters.entrySet().stream()
                .map(p -> p.getKey() + " = [" + String.join(", ", p.getValue()) + "]")
                .collect(Collectors.joining("\n"));
        model.addAttribute("received", received);
        return "form/form";
    }
}

Gehen wir diesen Code durch:

  • Zeilen 22–26: Der Listen-Service wird über den Konstruktor injiziert (siehe Beispiel 06);
  • Zeilen 30–33: Eine Methode, die mit [@ModelAttribute("lists")] annotiert und in einem Controller deklariert ist, wird vor jeder Action dieses Controllers ausgeführt: Beide Actions finden das Attribut [lists] in ihrem Modell vor, ohne es dort hinzufügen zu müssen (siehe [CommonModel], Beispiel 15, für alle Actions der Anwendung);
  • Zeilen 36–45: [GET /form] zeigt das Formular mit Anfangswerten an. Das Objekt wird im Modell unter dem Namen [input] gespeichert;
  • Zeile 50: [POST /form] empfängt die Benutzereingabe. Die Annotation [@ModelAttribute], angewendet auf einen Parameter, weist das Model Binding an, das Objekt aus den Anfrageparametern zu erzeugen (das ist das Standardverhalten für einen Parameter eines Klassentyps; siehe Beispiel 08) und es im View-Modell zu speichern. Ohne expliziten Namen entspricht der Attributname dem Klassennamen mit kleinem Anfangsbuchstaben: [input]. Das Formular wird mit den empfangenen Werten erneut angezeigt;
  • Zeilen 52–56: [getParameterMap()] bietet ebenfalls Zugriff auf die Parameter so, wie sie gesendet wurden: ein Dictionary, in dem jeder Wert ein Array von Strings ist (ein Parameter kann mehrfach vorkommen). Es wird in Text umgewandelt, eine Zeile pro Parameter, und im Template unter dem Namen [received] gespeichert. [Collectors.joining("\n")] verkettet die Zeilen, getrennt durch einen Zeilenumbruch.

Das Template [templates/layout.html] ist das aus Beispiel 17 (nur der Titel ändert sich). Die Datei [templates/form/form.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3">A complete form</h1>
  <!--/* th:object: das Objekt des Formulars; *{...} bezeichnet ein Feld dieses Objekts */-->
  <form method="post" action="/form" th:object="${input}" style="max-width: 40rem">
    <!--/* verstecktes Feld: wird mit dem Formular gesendet, ist aber unsichtbar */-->
    <input type="hidden" th:field="*{token}">

    <div class="mb-2">
      <span class="form-label me-3">Title</span>
      <!--/* Radio-Buttons: gleicher [name], es wird ein einziger Wert gesendet */-->
      <div class="form-check form-check-inline" th:each="title : ${lists.titles}">
        <input class="form-check-input" type="radio" th:field="*{title}" th:value="${title}">
        <!--/* #ids.prev: die id, die th:field dem vorhergehenden Feld gegeben hat */-->
        <label class="form-check-label" th:for="${#ids.prev('title')}" th:text="${title}">Mr</label>
      </div>
    </div>

    <div class="row g-2 mb-2">
      <div class="col">
        <label class="form-label" for="name">Name</label>
        <!--/* th:field erzeugt die Attribute id, name und value */-->
        <input class="form-control" type="text" th:field="*{name}">
      </div>
      <div class="col">
        <label class="form-label" for="password">Password</label>
        <!--/* ein Passwort wird NIEMALS in der Seite zurückgesendet: kein th:field */-->
        <input class="form-control" type="password" id="password" name="password">
      </div>
      <div class="col">
        <label class="form-label" for="birthDate">Date of birth</label>
        <!--/* ein Datumsfeld tauscht seine Werte im Format yyyy-mm-dd aus */-->
        <input class="form-control" type="date" th:field="*{birthDate}">
      </div>
    </div>

    <div class="mb-2">
      <span class="form-label me-3">Hobbies</span>
      <!--/* Checkboxen: gleicher [name], mehrere mögliche Werte */-->
      <div class="form-check form-check-inline" th:each="hobby : ${lists.hobbies}">
        <input class="form-check-input" type="checkbox" th:field="*{hobbies}" th:value="${hobby}">
        <label class="form-check-label" th:for="${#ids.prev('hobbies')}" th:text="${hobby}">reading</label>
      </div>
    </div>

    <div class="row g-2 mb-2">
      <div class="col">
        <label class="form-label" for="country">Country</label>
        <select class="form-select" th:field="*{country}">
          <option th:each="c : ${lists.countries}" th:value="${c.code}" th:text="${c.name}">France</option>
        </select>
      </div>
      <div class="col">
        <label class="form-label" for="languages">Spoken languages</label>
        <!--/* Mehrfachauswahlliste: mehrere mögliche Werte */-->
        <select class="form-select" th:field="*{languages}" multiple size="4">
          <option th:each="language : ${lists.languages}" th:value="${language}" th:text="${language}">French</option>
        </select>
      </div>
    </div>

    <div class="mb-2">
      <label class="form-label" for="comment">Comment</label>
      <!--/* ein Textbereich: der Wert steht ZWISCHEN den Tags */-->
      <textarea class="form-control" th:field="*{comment}" rows="2"></textarea>
    </div>

    <button class="btn btn-primary" type="submit">Send</button>
  </form>

  <th:block th:if="${received != null}">
    <h2 class="h5 mt-3">What the server received</h2>
    <pre class="bg-light p-2 border" th:text="${received}">name = [...]</pre>
  </th:block>
</main>
</body>
</html>

Gehen wir diesen Code durch:

  • Zeile 7: Das Attribut [th:object] legt das Formularobjekt fest: das Attribut [input] des Templates. Innerhalb des Tags verweist ein Auswahlausdruck [*{name}] auf die Eigenschaft [name] dieses Objekts: Das entspricht [${input.name}];
  • Zeile 9: Das Attribut [th:field="*{token}"] verbindet das Feld mit der Eigenschaft [token]: Es schreibt die Attribute [id] und [name] (den Namen der Eigenschaft) sowie das Attribut [value] (ihren Wert). Ein verstecktes Feld wird mit dem Formular gesendet, aber nicht angezeigt. Es dient dazu, Informationen von einer Seite zur nächsten weiterzugeben (in der Fallstudie enthält es zum Beispiel die Version eines Datensatzes). Achtung: Der Benutzer kann es ändern;
  • Zeilen 14–18: Optionsfelder haben denselben [name]; nur eines kann ausgewählt werden, und nur ein Wert wird gesendet. Bei einem Optionsfeld schreibt [th:field] den Wert der Eigenschaft nicht in [value] ([th:value] liefert den Wert des Optionsfeldes): Es wählt das Optionsfeld aus, wenn sein Wert mit der Eigenschaft übereinstimmt. Da alle Optionsfelder denselben Namen haben, vergibt [th:field] an sie nummerierte [id]-Werte: [title1], [title2] ... Das Hilfsobjekt [#ids.prev('title')] (Zeile 17) setzt den Wert des letzten Feldes [title] auf die angegebene [id], für das Attribut [for] seines Labels;
  • Zeile 25: ein Textfeld: [th:field] schreibt [id="name"], [name="name"] und den Wert. Das Label in Zeile 23 kann daher [for="name"] fest codieren;
  • Zeile 30: Ein Passwort wird niemals auf einer Seite zurückgegeben: Das Feld verwendet [th:field] nicht und hat kein Attribut [value];
  • Zeile 35: ein Datumsfeld. Der Browser zeigt das Datum in seinem eigenen Format an, sendet und empfängt aber immer [yyyy-mm-dd]; [th:field] schreibt das Datum dank der Annotation [@DateTimeFormat] in diesem Format;
  • Zeilen 42–45: Kontrollkästchen mit demselben [name]: Jedes angekreuzte Kästchen sendet seinen Wert, sodass der Parameter mehrfach vorkommt. [th:field] kreuzt das Kästchen an, wenn sein Wert in der Liste [hobbies] enthalten ist;
  • Zeilen 51–53: eine Dropdown-Liste. [th:field] am [<select>]-Tag wählt die Option aus, deren Wert der Eigenschaft [country] entspricht;
  • Zeilen 58–60: Das Attribut [multiple] erlaubt die Auswahl mehrerer Optionen: [th:field] wählt alle Optionen aus, die zur Liste [languages] gehören;
  • Zeile 67: Der Wert eines Textbereichs steht zwischen seinen Tags und nicht in einem Attribut [value]: [th:field] weiß das;
  • Zeilen 73–76: was der Server empfangen hat, nur nach dem Absenden angezeigt, innerhalb eines [<pre>]-Tags, das Zeilenumbrüche beibehält.

Hier ein Auszug aus dem HTML-Code, den diese [th:field]-Attribute erzeugen (das versteckte Feld, das zweite Optionsfeld, die ersten beiden Kontrollkästchen, die Dropdown-Liste):

    <input type="hidden" id="token" name="token" value="A7X2">
...
      <div class="form-check form-check-inline">
        <input class="form-check-input" type="radio" value="Mme" id="title2" name="title" checked="checked">

        <label class="form-check-label" for="title2">Mme</label>
      </div>
...
      <div class="form-check form-check-inline">
        <input class="form-check-input" type="checkbox" value="reading" id="hobbies1" name="hobbies"><input type="hidden" name="_hobbies" value="on"/>
        <label class="form-check-label" for="hobbies1">reading</label>
      </div>

      <div class="form-check form-check-inline">
        <input class="form-check-input" type="checkbox" value="music" id="hobbies2" name="hobbies"><input type="hidden" name="_hobbies" value="on"/>
        <label class="form-check-label" for="hobbies2">music</label>
      </div>
...
        <input type="hidden" name="_languages" value="1"/><select class="form-select" multiple size="4" id="languages" name="languages">
          <option value="French" selected="selected">French</option>

Beachten Sie die versteckten Felder, die wir nicht geschrieben haben: [_hobbies] nach jedem Kontrollkästchen, [_languages] vor der Dropdown-Liste. Sie lösen ein Problem von HTML: Ein nicht angekreuztes Kontrollkästchen wird überhaupt nicht gesendet. Wenn der Benutzer alle Kontrollkästchen abwählt, fehlt der Parameter [hobbies] in der Anfrage, und das Model Binding würde die Eigenschaft [hobbies] nicht aktualisieren, die ihren vorherigen Wert behielte. Die Markierung [_hobbies] hingegen wird immer gesendet: Wenn [Spring] sie ohne den Parameter [hobbies] vorfindet, leert es die Liste (oder setzt einen Booleschen Wert auf [false]). Hier ist die Eingabe ein neues Objekt, dessen Liste bereits leer ist, sodass der Unterschied nicht auffällt; er spielt eine Rolle, wenn das Formularobjekt zuvor befüllt wurde (zum Beispiel in einer Session gespeichert; siehe das Kapitel „Datenbereiche“).

Das anfängliche Formular (http://localhost:5000/form) und danach nach dem Absenden:

Image

Image

Beachten Sie Folgendes:

  • Das Textfeld zeigte „[Hello <b>whole</b> world]“ genau so an, wie es eingegeben wurde: „[th:field]“ maskiert den Wert, und die eingegebenen Tags werden nicht interpretiert;
  • Das Passwort wurde empfangen, wird aber nicht angezeigt;
  • Der Browser hat die Markierungen [_hobbies] (eine pro Kontrollkästchen) und [_languages] gesendet.

Mit [curl] sehen wir den Unterschied, wenn ein Kontrollkästchen angekreuzt ist:

curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport" http://localhost:5000/form
1
2
3
4
    <pre class="bg-light p-2 border">token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport]</pre>

und bei zwei angekreuzten Kästchen:

curl -d "token=A7X2&title=Mr&name=Martin&hobbies=sport&hobbies=music" http://localhost:5000/form
1
2
3
4
    <pre class="bg-light p-2 border">token = [A7X2]
title = [Mr]
name = [Martin]
hobbies = [sport, music]</pre>

(es wird nur das [<pre>]-Tag der Seite wiedergegeben). Die Option [-d] von [curl] sendet eine POST-Anfrage mit diesem Body und dem Header [Content-Type: application/x-www-form-urlencoded] eines HTML-Formulars.

4.7. Beispiel 19: Formularvalidierung

Ein ungültiges Formular muss erneut angezeigt werden, mit den eingegebenen Werten und einer Meldung unter jedem fehlerhaften Feld. Beispiel 19 wendet die Technik aus Beispiel 09 an (Validierung durch die Action mithilfe des Parameters [BindingResult]) auf ein Registrierungsformular und zeigt, wie [Thymeleaf] Fehler anzeigt.

Die Validierung erfordert eine zusätzliche Abhängigkeit. Die Datei [pom.xml]:

  <dependencies>
    <!-- die Thymeleaf-Views -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-thymeleaf</artifactId>
    </dependency>
    <!-- Validierung (Bean Validation, Hibernate Validator) -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-validation</artifactId>
    </dependency>
  </dependencies>
  • Zeilen 7–11: der Validierungs-Starter: die API [Bean Validation] (die Annotationen [@NotBlank], [@Size] ...) und ihre Implementierung [Hibernate Validator] (siehe Beispiel 08).

Die Datei [models/RegistrationModel.java]:

package example19.models;

import java.util.Objects;

import jakarta.validation.constraints.AssertTrue;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;

// die Formularfelder und ihre Constraints
public class RegistrationModel {

    @NotBlank(message = "The name is required.")
    @Size(max = 20, message = "The name must not exceed 20 characters.")
    private String name;

    @NotBlank(message = "The email address is required.")
    @Email(message = "Invalid email address.")
    private String email;

    // alles, was aus einem Formular kommt, ist ein String: "42" -> 42
    @NotNull(message = "The age is required.")
    @Min(value = 18, message = "The age must be between 18 and 120 years.")
    @Max(value = 120, message = "The age must be between 18 and 120 years.")
    private Integer age;

    @NotBlank(message = "The password is required.")
    @Size(min = 6, message = "The password must have at least 6 characters.")
    private String password;

    private String confirmation;

    // eine Regel über ZWEI Felder: eine boolesche Methode, von
    // @AssertTrue validiert. Für Bean Validation ist es die Property [confirmationValid].
    @AssertTrue(message = "The confirmation does not match the password.")
    public boolean isConfirmationValid() {
        return Objects.equals(password, confirmation);
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }

    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public String getConfirmation() { return confirmation; }
    public void setConfirmation(String confirmation) { this.confirmation = confirmation; }
}

Kommentieren wir diesen Code:

  • Zeilen 16–18: Der Name ist erforderlich ([@NotBlank] weist [null], einen leeren String und einen nur aus Leerzeichen bestehenden String zurück) und auf 20 Zeichen begrenzt;
  • Zeilen 20–22: [@Email] validiert das Format einer E-Mail-Adresse;
  • Zeilen 25–28: Das Alter wird in eine Ganzzahl umgewandelt und dann validiert. Der Typ [Integer] (nicht [int]) erlaubt den Wert [null]: Ein fehlendes Alter bleibt [null], und [@NotNull] beanstandet dies;
  • Zeilen 30–32: mindestens 6 Zeichen. [@Size] validiert keinen Wert [null]: Das ist die Aufgabe von [@NotBlank];
  • Zeilen 38–41: Die Regel „Die Bestätigung stimmt mit dem Passwort überein“ betrifft zwei Felder. [Bean Validation] hat hierfür keine vordefinierte Annotation; die einfachste Lösung ist eine Boolesche Methode, die den Vergleich durchführt und mit [@AssertTrue] annotiert ist: Die Einschränkung ist verletzt, wenn die Methode [false] zurückgibt. Für [Bean Validation] dient eine Methode mit dem Namen [isXxx()] als Accessor einer Booleschen Eigenschaft: Jeder Fehler wird daher der Eigenschaft [confirmationValid] zugeordnet. [Objects.equals] vergleicht zwei Objekte, ebenso wie zwei Werte [null].

Die Datei [controllers/RegistrationController.java]:

package example19.controllers;

import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import example19.models.RegistrationModel;
import jakarta.validation.Valid;

@Controller
@RequestMapping("/register")
public class RegistrationController {

    // @InitBinder: konfiguriert das Model Binding der Actions dieses Controllers.
    // StringTrimmerEditor(true): von jedem empfangenen String werden überflüssige
    // Leerzeichen entfernt, und ein leerer String wird zu null
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
    }

    // ?html5=true: wir lassen den Browser das Formular vor dem Senden validieren
    @GetMapping("")
    public String display(@RequestParam(defaultValue = "false") boolean html5, Model model) {
        model.addAttribute("registration", new RegistrationModel());
        model.addAttribute("html5", html5);
        return "registration/registration";
    }

    // @ModelAttribute("registration"): der Name des Objekts im Modell der View
    @PostMapping("")
    public String register(@Valid @ModelAttribute("registration") RegistrationModel input, BindingResult result,
            @RequestParam(defaultValue = "false") boolean html5, Model model) {
        if (result.hasErrors()) {
            // wir zeigen das Formular ERNEUT an: eingegebene Werte (außer den Passwörtern)
            // und unter jedem ungültigen Feld eine Meldung (siehe fragments/field.html)
            input.setPassword(null);
            input.setConfirmation(null);
            model.addAttribute("html5", html5);
            model.addAttribute("error", "The form contains errors.");
            return "registration/registration";
        }
        return "registration/welcome";
    }
}

Gehen wir diesen Code durch:

  • Zeilen 25–28: Eine mit [@InitBinder] annotierte Methode konfiguriert das Model Binding für die Actions dieses Controllers. Sie erhält das Objekt [WebDataBinder], das die Bindung durchführt. Dort wird ein Property-Editor für den Typ [String] registriert: [StringTrimmerEditor] entfernt führende und nachfolgende Leerzeichen aus jedem empfangenen String; mit dem Argument [true] wird ein leerer String zu [null]. Ein eingegebener Name [" Martin "] wird zu ["Martin"]. Achtung: Das gilt für alle Strings, auch für Passwörter;
  • Zeilen 31–36: das leere Formular. Der Parameter [html5] wird später erklärt. Das Formularobjekt wird im Template unter dem Namen [registration] gespeichert;
  • Zeile 40: [@Valid] fordert die Validierung des Objekts an; [@ModelAttribute("registration")] speichert es im Modell unter dem Namen [registration], demselben wie in Zeile 33, der von der View verwendet wird. Der Parameter [BindingResult] muss unmittelbar auf das validierte Objekt folgen: Er erhält die Binding- und Validierungsfehler, und die Action wird dann immer ausgeführt (siehe Beispiel 09);
  • Zeile 41: [@RequestParam] liest einen Parameter aus der URL oder aus dem Anfrage-Body: Hier stammt [html5] aus der URL des Formulars;
  • Zeilen 42–50: Wenn Fehler vorliegen, wird das Formular mit den eingegebenen Werten – außer den Passwörtern – und einer allgemeinen Meldung, die im Template gespeichert wird, erneut angezeigt. Mehr ist nicht zu tun: Das Objekt [registration] und seine Fehler ([BindingResult]) befinden sich bereits im Modell, wo die View sie findet;
  • Zeile 51: andernfalls die Willkommensseite, die ebenfalls das Objekt [registration] aus dem Modell verwendet.

Ein Konvertierungsfehler (ein Alter [abc]) erzeugt eine englische Standardmeldung, die schwer lesbar ist: [Failed to convert property value of type java.lang.String to required type java.lang.Integer for property age; For input string: "abc"]. Die Datei [messages.properties] ersetzt sie:

1
2
3
# die Meldungen der KONVERTIERUNGSfehler (z. B. age "abc"), standardmäßig technisch;
# der Schlüssel: typeMismatch.<erwarteter Java-Typ>
typeMismatch.java.lang.Integer=The value entered is not an integer.
  • Zeile 3: [Spring Boot] liest automatisch die Ressourcendatei [messages.properties]: Dies ist die Nachrichtendatei der Anwendung (das nächste Kapitel erklärt, wie sie in mehrere Sprachen lokalisiert wird). Bei einem Konvertierungsfehler sucht [Spring] unter mehreren Schlüsseln nach einer Nachricht, vom spezifischsten zum allgemeinsten: [typeMismatch.registration.age] (das Objekt und seine Eigenschaft), [typeMismatch.age] (die Eigenschaft), [typeMismatch.java.lang.Integer] (der erwartete Typ) und schließlich [typeMismatch]. Der erste gefundene Schlüssel hat Vorrang; andernfalls wird die englische Nachricht verwendet. In einer solchen Datei muss ein Apostroph doppelt geschrieben werden (auf Französisch zum Beispiel: [n''est]): Die Nachrichten werden von der Klasse [MessageFormat] von [Java] verarbeitet, für die der einfache Apostroph ein Sonderzeichen ist. Die Fallstudie ersetzt daher alle diese Nachrichten.

4.7.1. Ein Feld-Fragment

Alle Felder folgen demselben Muster: ein Label, ein Feld und eine Fehlermeldung. Ein Fragment fasst diese Bestandteile zusammen. Die Datei [templates/fragments/field.html]:

<!--/* ein Eingabefeld, mit seinem Label und seiner Fehlermeldung. Das Fragment hat
       keine Signatur: Seine Parameter sind benannte, optionale Variablen:
       name, label, type und die HTML5-Constraints required, maxlength, minlength,
       min, max. [errorOf]: die Eigenschaft, deren Fehler angezeigt wird (standardmäßig name) */-->
<div class="mb-2" th:fragment="field" th:with="key=${errorOf ?: name}">
  <label class="form-label" th:for="${name}" th:text="${label}">Label</label>
  <!--/* __${name}__: VORVERARBEITUNG; ${name} wird zuerst ausgewertet, und sein Ergebnis
         ("email") ersetzt den Ausdruck: th:field="*{email}" */-->
  <input class="form-control" th:type="${type}" th:field="*{__${name}__}"
         th:classappend="${#fields.hasErrors(key)} ? 'is-invalid'"
         th:required="${required}"
         th:attr="maxlength=${maxlength},minlength=${minlength},min=${min},max=${max}">
  <!--/* die ERSTE Fehlermeldung des Feldes, unter dem Feld */-->
  <div class="invalid-feedback" th:if="${#fields.hasErrors(key)}" th:text="${#fields.errors(key)[0]}">error</div>
</div>

Kommentieren wir diesen Code:

  • Zeile 5: Das Fragment [field] wird ohne Signatur deklariert, das heißt ohne Parameterliste. Es wird mit benannten Parametern ([field(name='age', label='Age', ...)]) aufgerufen, die zu Variablen des Fragments werden; ein nicht übergebener Parameter wird einfach auf [null] gesetzt. Das ist nützlich für ein Fragment mit vielen optionalen Parametern. [th:with] deklariert die Variable [key]: den Namen der Eigenschaft, für die der Fehler angezeigt wird. Der Operator [?:] (bekannt als „Elvis“) liefert seinen linken Operanden, wenn dieser nicht [null] ist, andernfalls seinen rechten Operanden: [errorOf], falls angegeben, andernfalls [name];
  • Zeile 9: [th:type] schreibt das Attribut [type]. [th:field] muss den Namen der Eigenschaft erhalten, der in der Variablen [name] gespeichert ist. Man kann nicht [*{name}] schreiben (das wäre die Eigenschaft [name]): Verwenden Sie stattdessen den Vorverarbeitungsschritt [__...__]. Der Ausdruck zwischen den doppelten Unterstrichen wird zuerst ausgewertet, und sein Ergebnis ersetzt den Text: Wenn [name] gleich [email] ist, wird das Attribut zu [th:field="*{email}"], das dann normal ausgewertet wird. [th:field] verwendet das Formularobjekt ([th:object]), das von der View deklariert wird, die das Fragment einfügt;
  • Zeile 10: [#fields.hasErrors(key)] gibt an, ob die Eigenschaft im [BindingResult] des Formularobjekts Fehler hat. Die Klassen [Bootstrap] und [is-invalid] heben das Feld dann rot hervor;
  • Zeile 11: Das Boolesche Attribut [required] wird geschrieben, wenn [required] wahr ist; andernfalls wird es weggelassen;
  • Zeile 12: [th:attr] schreibt mehrere Attribute auf einmal. Ein Attribut mit dem Wert [null] wird nicht geschrieben: Jedes Feld erhält nur die HTML5-Einschränkungen, die für es gelten;
  • Zeile 14: die Fehlermeldung unterhalb des Feldes (Klasse [Bootstrap] [invalid-feedback]). [#fields.errors(key)] liefert die Liste der Meldungen für die Eigenschaft; eine Eigenschaft kann mehrere Einschränkungen verletzen, und nur die erste wird angezeigt ([[0]]).

Die Datei [templates/registration/registration.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3">Registration</h1>
  <p th:if="${html5}">Browser validation <b>enabled</b> - <a href="/register">disable it</a></p>
  <p th:unless="${html5}">Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>
  <!--/* novalidate: der Browser ignoriert die Attribute required, min ... und
         sendet das Formular unverändert; nur der Server validiert */-->
  <form method="post" th:action="${html5} ? '/register?html5=true' : '/register'"
        th:novalidate="${!html5}" th:object="${registration}">
    <div th:replace="~{fragments/field :: field(name='name', label='Name', type='text', required=true, maxlength=20)}"></div>
    <div th:replace="~{fragments/field :: field(name='email', label='Email address', type='email', required=true)}"></div>
    <div th:replace="~{fragments/field :: field(name='age', label='Age', type='number', required=true, min=18, max=120)}"></div>
    <div th:replace="~{fragments/field :: field(name='password', label='Password', type='password', required=true, minlength=6)}"></div>
    <div th:replace="~{fragments/field :: field(name='confirmation', label='Confirmation', type='password', required=true, errorOf='confirmationValid')}"></div>
    <button class="btn btn-primary" type="submit">Register</button>
  </form>
</main>
</body>
</html>
  • Zeilen 6–7: der Link, der die Validierung durch den Browser aktiviert oder deaktiviert;
  • Zeile 10: Das Attribut [action] des Formulars behält den Parameter [html5] bei;
  • Zeile 11: Das Boolesche Attribut [novalidate] wird gesetzt, wenn [html5] falsch ist. [th:object] verweist auf das Formularobjekt [registration];
  • Zeilen 12–16: Jedes Feld ist eine Einfügung des Fragments mit benannten Parametern. Bei der Bestätigung (Zeile 16) ist der anzuzeigende Fehler der der Eigenschaft [confirmationValid] und der der Regel [@AssertTrue].

Die Datei [templates/layout.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Registration</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    <main th:replace="${content}"></main>
    <!--/* der globale Fehler, am Seitenende, auf hellrosa Hintergrund; [error] wird von der Action gesetzt */-->
    <div class="error-area" role="alert" th:if="${error != null}" th:text="${error}">error</div>
  </div>
</body>
</html>
  • Zeile 13: Die globale Meldung wird am Ende der Seite auf hellrosa Hintergrund angezeigt (Klasse [error-area] aus [static/css/styles.css] abgeleitet), wie in der Fallstudie zu sehen.

Die Datei [templates/registration/welcome.html]:

1
2
3
4
5
6
7
8
9
<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main th:object="${registration}">
  <h1 class="h3" th:text="|Welcome *{name}|">Welcome</h1>
  <p>Your registration is saved: address <b th:text="*{email}">email</b>, age <b th:text="*{age}">42</b> years.</p>
</main>
</body>
</html>
  • Zeile 4: [th:object] ist nicht Formularen vorbehalten: Im [<main>]-Tag erlaubt es, [*{name}] statt [${registration.name}] zu schreiben;
  • Zeilen 5–6: die konvertierten und bereinigten Werte: Das Alter ist eine Zahl, und der Name enthält keine Leerzeichen mehr.

Das leere Formular (http://localhost:5000/register), dann mit mehreren Fehlern gesendet (ein nur aus Leerzeichen bestehender Name, eine unvollständige Adresse, ein zu geringes Alter sowie zu kurze und voneinander verschiedene Passwörter):

Image

Image

dann korrekt ausgefüllt (mit Leerzeichen um den Namen):

Image

Und mit einem nicht numerischen Alter, gesendet mit [curl] (der Browser hätte es in einem [type="number"]-Feld abgelehnt):

curl -i -d "name=Martin&email=xx&age=abc" http://localhost:5000/register
HTTP/1.1 200
Content-Type: text/html;charset=UTF-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Registration</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    <main>
  <h1 class="h3">Registration</h1>

  <p>Browser validation <b>disabled</b> - <a href="/register?html5=true">enable it</a></p>

  <form method="post" action="/register" novalidate="novalidate">
    <div class="mb-2">
  <label class="form-label" for="name">Name</label>

  <input class="form-control" type="text" maxlength="20" required="required" id="name" name="name" value="Martin">


</div>
    <div class="mb-2">
  <label class="form-label" for="email">Email address</label>

  <input class="form-control is-invalid" type="email" required="required" id="email" name="email" value="xx">

  <div class="invalid-feedback">Invalid email address.</div>
</div>
    <div class="mb-2">
  <label class="form-label" for="age">Age</label>

  <input class="form-control is-invalid" type="number" min="18" max="120" required="required" id="age" name="age" value="">

  <div class="invalid-feedback">The value entered is not an integer.</div>
</div>
    <div class="mb-2">
  <label class="form-label" for="password">Password</label>

  <input class="form-control is-invalid" type="password" minlength="6" required="required" id="password" name="password" value="">

  <div class="invalid-feedback">The password is required.</div>
</div>
    <div class="mb-2">
  <label class="form-label" for="confirmation">Confirmation</label>

  <input class="form-control" type="password" required="required" id="confirmation" name="confirmation" value="">


</div>
    <button class="btn btn-primary" type="submit">Register</button>
  </form>
</main>

    <div class="error-area" role="alert">The form contains errors.</div>
  </div>
</body>
</html>

Beachten Sie Folgendes:

  • Der Konvertierungsfehler beim Alter verwendet die Nachricht aus [messages.properties];
  • Das Feld [age] zeigt den abgelehnten Wert [abc] nicht erneut an: Bei einem Feld [type="number"] schreibt [th:field] keinen Wert, der keine Zahl ist (mit [type="text"] hätte es [value="abc"] geschrieben);
  • Das fehlende Passwort hat nur einen Fehler, „erforderlich“: [@Size] validiert keinen Wert [null]. Die Bestätigung hat dagegen keinen Fehler: Zwei fehlende Passwörter sind gleich;
  • Die Felder ohne Fehler haben nicht die Klasse [is-invalid], und ihr Fragment erzeugt keine Meldung.

4.7.2. Validierung im Browser

Die Attribute [required], [maxlength], [min], [max], [type="email"] ... weisen den Browser an, das Formular vor dem Absenden zu validieren: Der Benutzer wird sofort über einen Tooltip benachrichtigt, ohne dass eine Kommunikation mit dem Server stattfindet. Dieses Verhalten erhalten Sie, wenn Sie auf den Link „enable it“ klicken (http://localhost:5000/register?html5=true), der das Attribut [novalidate] aus dem Formular entfernt.

Diese Validierung ist eine Komfortfunktion und keine Sicherheitsmaßnahme: Man kann sie umgehen, indem man das Attribut [required] mit den Entwicklerwerkzeugen des Browsers entfernt oder die Anfrage mit [curl] sendet. Die serverseitige Validierung bleibt unerlässlich. Deshalb deaktiviert das Beispiel die Browser-Validierung standardmäßig: um die Funktionsweise des Servers zu zeigen. Die Fallstudie behält dagegen beides bei: die HTML5-Attribute für den Komfort und die serverseitige Validierung für die Sicherheit.

4.8. Beispiel 20: Das Post/Redirect/Get-Muster

Wird ein POST-Formular erfolgreich gesendet, kann die Action direkt eine Seite anzeigen. Das Problem entsteht, wenn der Benutzer diese Seite anschließend neu lädt (Taste F5): Der Browser sendet das Formular erneut, und die Operation wird ein zweites Mal ausgeführt (eine doppelt aufgegebene Bestellung, ein doppelt vereinbarter Termin ...). Das Post/Redirect/Get-Muster (PRG) verhindert dieses Problem: Eine erfolgreiche POST-Action erzeugt keine Seite, sondern leitet auf eine GET-Seite um. Das erneute Laden dieser Seite löst lediglich ein weiteres GET ohne Auswirkung aus.

Ein Detail bleibt: Die GET-Seite muss eine Meldung anzeigen („Die Aufgabe wurde hinzugefügt“), obwohl diese Meldung von der POST-Action in einer anderen Anfrage erzeugt wurde. [Spring MVC] stellt hierfür die Flash-Attribute bereit: Attribute, die vor der Umleitung gesetzt werden und bis zur nächsten Anfrage erhalten bleiben, wo sie dem Template hinzugefügt werden und dann verschwinden. Man spricht von einer Flash-Meldung. Standardmäßig speichert [Spring MVC] die Flash-Attribute in der HTTP-Session des Benutzers: einem Speicherbereich, den der Server jedem Browser zuordnet (dem Kapitel „Datenbereiche“ ist dieses Thema gewidmet).

Die Datei [services/TasksService.java]:

package example20.services;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import org.springframework.stereotype.Service;

// die Liste der Aufgaben, im Speicher, von allen gemeinsam genutzt (Singleton).
// CopyOnWriteArrayList: eine Liste, die von mehreren gleichzeitigen Anfragen verwendet werden kann
@Service
public class TasksService {

    private final List<String> tasks = new CopyOnWriteArrayList<>(List.of("Read chapter 3"));

    public List<String> list() {
        return List.copyOf(tasks);
    }

    public void add(String label) {
        tasks.add(label);
    }
}
  • Zeile 13: Ein Singleton wird von allen Anfragen gemeinsam genutzt, die gleichzeitig laufen können. Eine Standard-[ArrayList] unterstützt das nicht; [CopyOnWriteArrayList] ist eine Liste, die genau dafür konzipiert ist;
  • Zeilen 15–17: [List.copyOf] gibt eine schreibgeschützte Kopie der Liste zurück: Der Aufrufer kann die Liste des Service nicht ändern.

Die Datei [controllers/TasksController.java]:

package example20.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import example20.services.TasksService;

@Controller
@RequestMapping("/tasks")
public class TasksController {

    private final TasksService tasks;

    public TasksController(TasksService tasks) {
        this.tasks = tasks;
    }

    // GET /tasks: die Liste und das Formular zum Hinzufügen
    @GetMapping("")
    public String display(Model model) {
        model.addAttribute("tasks", tasks.list());
        return "tasks/tasks";
    }

    // POST /tasks: das Muster Post / Redirect / Get
    @PostMapping("")
    public String add(@RequestParam(required = false) String label, Model model,
            RedirectAttributes redirect) {
        String text = label == null ? "" : label.trim();
        if (text.isEmpty() || text.length() > 40) {
            // ungültige Eingabe: wir zeigen die Seite erneut an, ohne Weiterleitung
            model.addAttribute("label", label);
            model.addAttribute("error", "The label must have 1 to 40 characters.");
            return display(model);
        }
        tasks.add(text);
        // ein "Flash"-Attribut: es übersteht die Weiterleitung, für die NÄCHSTE Anfrage
        redirect.addFlashAttribute("flash", "The task [" + text + "] has been added.");
        // keine Seite: eine Weiterleitung auf die GET-Seite
        return "redirect:/tasks";
    }

    // POST /tasks/without-prg: das Gegenbeispiel (eine Seite als Antwort auf das POST)
    @PostMapping("/without-prg")
    public String addWithoutPrg(@RequestParam(required = false) String label, Model model) {
        tasks.add(label == null || label.isBlank() ? "(untitled)" : label.trim());
        model.addAttribute("withoutPrg", true);
        return display(model);
    }
}

Kommentieren wir diesen Code:

  • Zeilen 24–28: die Listenseite;
  • Zeile 33: ein Parameter vom Typ [RedirectAttributes], bereitgestellt von [Spring MVC]: die Umleitungsattribute;
  • Zeilen 35–40: eine ungültige Eingabe – die Seite wird ohne Umleitung erneut angezeigt (die Eingabe und die Fehlermeldung müssen erhalten bleiben). Zeile 39 ruft einfach die Methode [display] auf, wie jede andere [Java]-Methode: Sie fügt dem Template die Aufgabenliste hinzu und gibt den Namen der View zurück;
  • Zeile 43: eine gültige Eingabe: Nach der Operation zeigt [addFlashAttribute] die Flash-Meldung an;
  • Zeile 45: Ein String, der mit [redirect:] beginnt, ist kein View-Name: [Spring MVC] antwortet mit einer Umleitung (Code 302) an die folgende Adresse (siehe Beispiel 04);
  • Zeilen 49–54: das Gegenbeispiel zum Vergleich: eine Seite als Antwort auf POST.

Die Datei [templates/tasks/tasks.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3">My tasks</h1>
  <ol>
    <li th:each="task : ${tasks}" th:text="${task}">task</li>
  </ol>
  <form method="post" action="/tasks" class="d-flex gap-2">
    <input class="form-control" name="label" th:value="${label}" placeholder="New task">
    <button class="btn btn-primary text-nowrap" type="submit">Add</button>
    <!--/* formaction: dieser Button sendet dasselbe Formular an eine andere Adresse */-->
    <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
  </form>
  <p class="text-danger mt-2" th:if="${withoutPrg}">Page displayed in response to a POST: press F5 and the task will be added a second time.</p>
</main>
</body>
</html>
  • Zeile 10: die Eingabe, die nach einem Fehler erneut angezeigt wird (das Attribut [label] existiert in den anderen Fällen nicht: Das Feld ist leer);
  • Zeile 13: Das Attribut [formaction] einer Schaltfläche sendet das Formular an eine andere Adresse als die des Attributs [action] des Formulars. Das Formular hat somit zwei Schaltflächen, die zwei verschiedene Actions auslösen. Die Fallstudie verwendet diesen Ansatz auf ihrer Anmeldeseite;
  • Zeile 15: Ein im Template fehlendes Attribut wird auf [null] gesetzt, und [th:if] behandelt [null] als falsch.

Die Datei [templates/layout.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Tasks</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">
    <!--/* die Flash-Meldung, oben auf der Seite: ein Modellattribut, VOR der Weiterleitung gesetzt */-->
    <div class="alert alert-success" role="status" th:if="${flash != null}" th:text="${flash}">flash</div>
    <main th:replace="${content}"></main>
    <div class="error-area" role="alert" th:if="${error != null}" th:text="${error}">error</div>
  </div>
</body>
</html>

Die Flash-Meldung wird am Seitenanfang angezeigt (Zeile 12) und der Fehler am Seitenende (Zeile 14). Aus Sicht der View ist ein Flash-Attribut einfach ein weiteres Modellattribut.

Hier sehen Sie, was [curl] beim erfolgreichen Absenden des Formulars sieht. Die Option [-c file] speichert die empfangenen Cookies, [-b file] sendet sie zurück; [--data-urlencode] codiert Leerzeichen und Akzente im Feld:

curl -i -c cookies.txt -b cookies.txt --data-urlencode "label=Review Spring" http://localhost:5000/tasks
1
2
3
4
HTTP/1.1 302
Set-Cookie: JSESSIONID=74250348252FFBFF6F46F1BDFDDF7DEA; Path=/; HttpOnly
Location: http://localhost:5000/tasks
Content-Length: 0

Die Antwort ist eine Umleitung auf [/tasks]. Um die Flash-Meldung zu speichern, hat [Spring MVC] eine HTTP-Session angelegt: Der Server ([Tomcat]) hat ihr eine Kennung zugewiesen, die im Cookie [JSESSIONID] an den Browser gesendet wurde. Die folgende Anfrage sendet dieses Cookie zurück, sodass der Server die Session und die Meldung abrufen kann:

curl -i -c cookies.txt -b cookies.txt http://localhost:5000/tasks
HTTP/1.1 200
Content-Type: text/html;charset=UTF-8

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Tasks</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 36rem">

    <div class="alert alert-success" role="status">The task [Review Spring] has been added.</div>
    <main>
  <h1 class="h3">My tasks</h1>
  <ol>
    <li>Read chapter 3</li>
    <li>Review Spring</li>
  </ol>
  <form method="post" action="/tasks" class="d-flex gap-2">
    <input class="form-control" name="label" value="" placeholder="New task">
    <button class="btn btn-primary text-nowrap" type="submit">Add</button>

    <button class="btn btn-outline-secondary text-nowrap" type="submit" formaction="/tasks/without-prg">Add without PRG</button>
  </form>

</main>

  </div>
</body>
</html>

Die Flash-Meldung wird angezeigt; wird die Seite neu geladen, verschwindet sie. Die Session bleibt jedoch geöffnet: Ihre Kennung ändert sich nicht, und der Server sendet das Cookie nicht erneut.

Die Datei [application.properties] enthält eine Einstellung zur Session:

1
2
3
4
5
6
7
# der Listening-Port des Servers (standardmäßig 8080)
server.port=5000
# die Fehlerantworten von Spring Boot enthalten den Call Stack nicht
spring.web.error.include-stacktrace=never
# die Session (die die Flash-Attribute trägt) wird ausschließlich über ein Cookie verfolgt
# und niemals über ein ";jsessionid=...", das den URLs angehängt wird
server.servlet.session.tracking-modes=cookie
  • Zeile 7: Die Session wird ausschließlich über ein Cookie verfolgt. Ohne diese Einstellung weiß [Tomcat] bei der ersten Antwort nicht, ob der Browser Cookies akzeptiert: Es sendet das Cookie, fügt aber zusätzlich die Session-ID in die URL der Umleitung ein. Das Ergebnis ist:
1
2
3
4
HTTP/1.1 302
Set-Cookie: JSESSIONID=836C471F9879CC83E0C2C4C1ED8FD048; Path=/; HttpOnly
Location: http://localhost:5000/tasks;jsessionid=836C471F9879CC83E0C2C4C1ED8FD048
Content-Length: 0

Die URL und [/tasks;jsessionid=...] funktionieren, erscheinen aber in der Adressleiste des Browsers, und eine in der URL zirkulierende Session-ID (Browserverlauf, Lesezeichen, kopierte Links) stellt ein Sicherheitsrisiko dar. Alle Beispiele, die Flash-Attribute verwenden, haben diese Einstellung.

Im Browser (http://localhost:5000/tasks) nach dem Hinzufügen einer Aufgabe:

Image

Die Adressleiste zeigt [/tasks]: Das ist die GET-Seite. Sie können sie bedenkenlos neu laden; die Meldung verschwindet. Eine Eingabe mit Leerzeichen:

Image

Und das Gegenbeispiel:

Image

Hier zeigt die Adressleiste [/tasks/without-prg], die Adresse von POST. Das Neuladen der Seite löst eine Browserwarnung aus („Formularübermittlung bestätigen“) und fügt die Aufgabe dann ein zweites Mal hinzu. Alle POST-Formulare der Fallstudie folgen dem PRG-Schema. Die Fallstudie speichert ihre Flash-Attribute jedoch in einem Cookie statt in der Session, da ihr Server zwischen Anfragen keine Daten aufbewahrt.

Eine einfache Regel leitet die Wahl zwischen einem Link und einer Schaltfläche:

  • Ein Link ([<a href>]) erzeugt eine Anfrage (GET). Eine Anfrage (GET) darf nichts ändern: Browser, Suchmaschinen und Virenscanner können Links von sich aus aufrufen, um eine Seite vorzubereiten oder zu analysieren;
  • Eine Operation, die Daten ändert (hinzufügen, bearbeiten, löschen, abmelden), ist eine Schaltfläche in einem POST-Formular.

Beispiel 21 verwaltet eine Kontaktliste: Man sieht sich einen Kontakt über einen Link an und löscht ihn über eine Schaltfläche, die ein Bestätigungsfenster öffnet. Die Dateien dieses Beispiels:

21-links-buttons/
├── src/
│   └── main/
│       ├── java/
│       │   └── example21/
│       │       ├── config/
│       │       │   └── WebConfig.java
│       │       ├── controllers/
│       │       │   └── ContactsController.java
│       │       ├── services/
│       │       │   └── ContactsService.java
│       │       └── Example21Application.java
│       └── resources/
│           ├── static/
│           │   ├── css/
│           │   │   └── styles.css
│           │   └── js/
│           │       └── app.js
│           ├── templates/
│           │   ├── contacts/
│           │   │   ├── details.html
│           │   │   └── list.html
│           │   ├── fragments/
│           │   │   └── confirmation.html
│           │   └── layout.html
│           └── application.properties
└── pom.xml

Die Datei [services/ContactsService.java]:

package example21.services;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

import org.springframework.stereotype.Service;

// die Kontakte, im Speicher, von allen gemeinsam genutzt (Singleton)
@Service
public class ContactsService {

    // ein Kontakt: eine Kennung, ein Name, eine Telefonnummer
    public record Contact(int id, String name, String phone) {
    }

    private final List<Contact> contacts = new ArrayList<>(List.of(
            new Contact(1, "Marie Durand", "01 23 45 67 89"),
            new Contact(2, "Paul Martin", "06 12 34 56 78"),
            new Contact(3, "Philippe Jandot", "02 98 76 54 32")));
    private int lastId = 3;

    // synchronized: jeweils nur eine Anfrage führt die Methode aus
    public synchronized List<Contact> list() {
        return List.copyOf(contacts);
    }

    // Optional: ein Kontakt oder "nichts", wenn er nicht existiert
    public synchronized Optional<Contact> read(int id) {
        return contacts.stream().filter(c -> c.id() == id).findFirst();
    }

    public synchronized Optional<Contact> edit(int id, String name, String phone) {
        for (int i = 0; i < contacts.size(); i++) {
            if (contacts.get(i).id() == id) {
                // ein Record ist unveränderlich: wir ersetzen ihn durch einen neuen
                Contact edited = new Contact(id, name, phone);
                contacts.set(i, edited);
                return Optional.of(edited);
            }
        }
        return Optional.empty();
    }

    public synchronized Contact add(String name, String phone) {
        Contact contact = new Contact(++lastId, name, phone);
        contacts.add(contact);
        return contact;
    }

    public synchronized Optional<Contact> delete(int id) {
        Optional<Contact> contact = read(id);
        contact.ifPresent(contacts::remove);
        return contact;
    }
}

Kommentieren wir diesen Code:

  • Zeilen 14–15: ein Kontakt;
  • Zeilen 17–20: die Liste der Kontakte: eine [ArrayList] (veränderbar), initialisiert mit drei Kontakten;
  • Zeile 24: Das Schlüsselwort [synchronized] stellt sicher, dass immer nur eine Anfrage gleichzeitig eine [synchronized]-Methode des Objekts ausführt: Gleichzeitige Anfragen können die Liste nicht zur selben Zeit ändern. Das ist eine andere Lösung als die Liste [CopyOnWriteArrayList] in Beispiel 20;
  • Zeilen 29–31: [read] gibt ein [Optional<Contact>] zurück (siehe Beispiel 06): ein Objekt, das einen Kontakt enthält oder nichts, wenn kein Kontakt diese ID hat. [findFirst()] gibt das erste Element des Streams als [Optional] zurück;
  • Zeilen 36–38: Ein Record ist unveränderlich: Seine Felder werden nicht geändert; stattdessen wird er durch einen neuen ersetzt;
  • Zeile 46: [++lastId] erhöht den Zähler, bevor er verwendet wird: Die folgenden Kennungen sind 4, 5 ...;
  • Zeile 53: [ifPresent] führt eine Aktion aus, wenn [Optional] einen Kontakt enthält. [contacts::remove] ist eine Methodenreferenz: eine Kurzschreibweise für das Lambda [c -> contacts.remove(c)].

Die Datei [controllers/ContactsController.java]:

package example21.controllers;

import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import example21.services.ContactsService;
import example21.services.ContactsService.Contact;

@Controller
@RequestMapping("/contacts")
public class ContactsController {

    private final ContactsService contacts;

    public ContactsController(ContactsService contacts) {
        this.contacts = contacts;
    }

    // ein LINK (<a href>): eine GET-Anfrage, die nichts verändert
    @GetMapping("")
    public String list(Model model) {
        model.addAttribute("contacts", contacts.list());
        return "contacts/list";
    }

    @GetMapping("/{id:\\d+}")
    public String details(@PathVariable int id, Model model) {
        model.addAttribute("contact", contacts.read(id).orElseThrow(ContactsController::notFound));
        return "contacts/details";
    }

    // ein BUTTON in einem POST-Formular: eine Anfrage, die Daten verändert
    @PostMapping("/{id:\\d+}")
    public String save(@PathVariable int id, @RequestParam String name, @RequestParam String phone,
            RedirectAttributes redirect) {
        Contact contact = contacts.edit(id, name, phone).orElseThrow(ContactsController::notFound);
        redirect.addFlashAttribute("flash", "The contact [" + contact.name() + "] has been edited.");
        return "redirect:/contacts";
    }

    // dasselbe Formular, ein anderer Button (Attribut formaction): eine andere Action
    @PostMapping("/{id:\\d+}/duplicate")
    public String duplicate(@PathVariable int id, @RequestParam String name, @RequestParam String phone,
            RedirectAttributes redirect) {
        Contact copy = contacts.add(name + " (copy)", phone);
        redirect.addFlashAttribute("flash", "The contact [" + copy.name() + "] has been created.");
        return "redirect:/contacts";
    }

    @PostMapping("/{id:\\d+}/delete")
    public String delete(@PathVariable int id, RedirectAttributes redirect) {
        Contact contact = contacts.delete(id).orElseThrow(ContactsController::notFound);
        redirect.addFlashAttribute("flash", "The contact [" + contact.name() + "] has been deleted.");
        return "redirect:/contacts";
    }

    // eine Exception, die eine 404-Antwort erzeugt
    private static ResponseStatusException notFound() {
        return new ResponseStatusException(HttpStatus.NOT_FOUND, "unknown contact");
    }
}

Kommentieren wir diesen Code:

  • Zeilen 28–38: die beiden Seiten – die Liste und das Profil des Kontakts. Die Einschränkung [{id:\\d+}] (siehe Beispiel 02) akzeptiert nur eine Kennung, die aus Ziffern besteht;
  • Zeile 36: [orElseThrow] gibt den in [Optional] enthaltenen Kontakt zurück oder löst, wenn es leer ist, die Exception aus, die von der übergebenen Funktion erzeugt wird: hier die Methodenreferenz [ContactsController::notFound];
  • Zeilen 41–47: Speichern eines Datensatzes im PRG-Muster. Die Parameter [name] und [phone] sind erforderlich: [@RequestParam] kann nicht ohne [required = false] verwendet werden;
  • Zeilen 50–56: Duplizieren, ausgelöst durch eine zweite Schaltfläche im selben Formular (Attribut [formaction]);
  • Zeilen 58–63: Löschen über ein POST;
  • Zeilen 66–68: Eine Exception [ResponseStatusException] trägt einen HTTP-Code und eine Begründung. Wird sie von einer Action ausgelöst, erzeugt sie eine Fehlerantwort mit diesem Code: in diesem Fall 404. Ein nicht vorhandener Kontakt löst somit in den Actions [details], [save] und [delete] einen 404 aus; das Duplizieren liest den Kontakt dagegen nicht erneut ein: Es erzeugt eine Kopie auf Grundlage der empfangenen Felder.

Die Datei [templates/contacts/list.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h3">Contacts</h1>
  <table class="table align-middle">
    <tbody>
      <tr th:each="contact : ${contacts}">
        <td th:text="${contact.name}">Marie Durand</td>
        <td th:text="${contact.phone}">01 23 45 67 89</td>
        <td class="text-end">
          <!--/* view: ein einfacher Link; @{/contacts/{id}(id=...)}: eine URL mit einer Variablen */-->
          <a class="btn btn-sm btn-outline-primary" th:href="@{/contacts/{id}(id=${contact.id})}">View</a>
          <!--/* delete: ein POST-Formular, dessen Absenden bestätigt wird */-->
          <form method="post" class="d-inline" th:action="@{/contacts/{id}/delete(id=${contact.id})}"
                th:data-confirmation="|Delete the contact ${contact.name}?|">
            <button class="btn btn-sm btn-outline-danger" type="submit">Delete</button>
          </form>
        </td>
      </tr>
    </tbody>
  </table>
</main>
</body>
</html>
  • Zeile 13: Ansehen: ein Link, der von [Bootstrap] als Schaltfläche dargestellt wird. Der Link-Ausdruck [@{/contacts/{id}(id=${contact.id})}] enthält eine Pfadvariable [{id}], die durch den gleichnamigen Parameter in den Klammern gefüllt wird: [/contacts/1]. Ein Parameter, der keiner Pfadvariablen entspricht, wird nach [?] angehängt (siehe Beispiel 16);
  • Zeilen 15–16: Löschen: ein kleines POST-Formular, das auf seine Schaltfläche reduziert ist. Das Attribut [data-confirmation] enthält die Frage, die vor dem Absenden gestellt werden soll. Die Attribute [data-*] sind nicht spezifiziert: HTML ignoriert sie, während [JavaScript] auf der Seite sie lesen kann. [Thymeleaf] kann jedes Attribut schreiben: [th:data-confirmation] berechnet das Attribut [data-confirmation], dessen Wert maskiert wird.

Die Datei [templates/contacts/details.html]:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main th:object="${contact}">
  <h1 class="h3" th:text="|Contact no. *{id}|">Contact no. 1</h1>
  <form method="post" th:action="@{/contacts/{id}(id=*{id})}">
    <div class="mb-2">
      <label class="form-label" for="name">Name</label>
      <input class="form-control" id="name" name="name" th:value="*{name}">
    </div>
    <div class="mb-3">
      <label class="form-label" for="phone">Phone</label>
      <input class="form-control" id="phone" name="phone" th:value="*{phone}">
    </div>
    <!--/* zwei Submit-Buttons für dasselbe Formular */-->
    <button class="btn btn-primary" type="submit">Save</button>
    <button class="btn btn-outline-primary" type="submit" th:formaction="@{/contacts/{id}/duplicate(id=*{id})}">Duplicate</button>
    <a class="btn btn-link" href="/contacts">Back to the list</a>
  </form>
</main>
</body>
</html>
  • Zeile 4: [th:object] am [<main>]-Tag: Der Kontakt ist das ausgewählte Objekt, und [*{id}] verweist auf seine ID;
  • Zeile 6: die Adresse des Formulars mit einer Pfadvariablen, die durch einen Auswahlausdruck gefüllt wird;
  • Zeilen 9 und 13: Dieses Formular verwendet [th:field] nicht: Die Felder sind nicht mit einem Formularobjekt verbunden, daher genügt [th:value];
  • Zeilen 16–17: zwei Absende-Schaltflächen für dasselbe Formular; die zweite hat ihr eigenes Attribut [formaction].

4.9.1. Das Bestätigungsfenster

Das Dialogfeld des Browsers ([window.confirm]) lässt sich weder formatieren noch übersetzen: Seine Schaltflächen bleiben in der Sprache des Browsers. Es wird durch ein [Bootstrap]-Fenster ersetzt, das in die Seite eingebettet und bis zum Bedarfsfall ausgeblendet ist. Die Datei [templates/fragments/confirmation.html]:

<!--/* ein einziges Fenster für die gesamte Seite, zunächst verborgen (d-none) */-->
<div id="confirmation-modal" class="d-none" th:fragment="confirmation">
  <div class="modal-backdrop fade show"></div>
  <div class="modal fade show d-block" tabindex="-1" role="alertdialog" aria-modal="true">
    <div class="modal-dialog modal-dialog-centered">
      <div class="modal-content">
        <div class="modal-header">
          <h5 class="modal-title">Confirmation</h5>
        </div>
        <div class="modal-body">
          <p class="mb-0" id="confirmation-modal-message"></p>
        </div>
        <div class="modal-footer">
          <button type="button" class="btn btn-secondary" data-action="no">No, go back</button>
          <button type="button" class="btn btn-danger" data-action="yes">Yes, confirm</button>
        </div>
      </div>
    </div>
  </div>
</div>
  • Zeile 2: ein Fragment ohne Parameter. Die Klasse [d-none] blendet das Fenster aus;
  • Zeile 3: der graue Hintergrund;
  • Zeile 11: der Ort der Frage;
  • Zeilen 14–15: die beiden Schaltflächen, identifiziert durch das Attribut [data-action].

Die Datei [templates/layout.html]:

<!doctype html>
<html lang="en" xmlns:th="http://www.thymeleaf.org" th:fragment="page(content)">
<head>
  <meta charset="utf-8">
  <title>Contacts</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
  <link rel="stylesheet" href="/css/styles.css">
</head>
<body>
  <div class="container py-3" style="max-width: 40rem">
    <div class="alert alert-success" role="status" th:if="${flash != null}" th:text="${flash}">flash</div>
    <main th:replace="${content}"></main>
  </div>
  <!--/* das Bestätigungsfenster, auf allen Seiten vorhanden */-->
  <div th:replace="~{fragments/confirmation :: confirmation}"></div>
  <!--/* das Skript am Ende der Seite: die Elemente, die es sucht, existieren bereits */-->
  <script src="/js/app.js"></script>
</body>
</html>
  • Zeile 11: die Flash-Meldung;
  • Zeile 15: Das Fenster erscheint auf jeder Seite;
  • Zeile 17: Das Skript wird am Ende der Seite geladen; wenn es ausgeführt wird, existieren die gesuchten Elemente bereits. Es wird als statische Datei aus [static/js/app.js] ausgeliefert.

Ein kleiner Teil [JavaScript] verbindet die Formulare mit dem Fenster. Die Datei [static/js/app.js]:

// Bestätigung der Formulare, die das Attribut data-confirmation="..." tragen
// Ohne JavaScript werden diese Formulare einfach ohne Bestätigung gesendet.
(() => {
  const modal = document.getElementById('confirmation-modal');
  const message = document.getElementById('confirmation-modal-message');
  let pending = null; // das Formular, das gesendet wird, wenn der Benutzer bestätigt

  // 1. wir fangen das Absenden der zu bestätigenden Formulare ab
  document.querySelectorAll('form[data-confirmation]').forEach((form) => {
    form.addEventListener('submit', (event) => {
      event.preventDefault(); // das Absenden wird angehalten
      pending = form;
      message.textContent = form.dataset.confirmation;
      modal.classList.remove('d-none'); // das Fenster erscheint
    });
  });

  // 2. die beiden Buttons des Fensters
  modal.addEventListener('click', (event) => {
    const action = event.target.dataset.action;
    if (action === 'yes') {
      pending.submit(); // Absenden, OHNE das Ereignis 'submit' erneut auszulösen
    } else if (action === 'no') {
      modal.classList.add('d-none');
      pending = null;
    }
  });
})();
  • Zeile 3: Der Code ist in eine Funktion eingebettet, die sofort ausgeführt wird, um keine globalen Variablen zu erzeugen;
  • Zeilen 9–16: Das Absenden jedes Formulars mit dem Attribut [data-confirmation] wird abgefangen. [preventDefault()] unterbricht das Absenden; das Formular wird gemerkt, die Frage wird im Fenster platziert ([textContent], nicht [innerHTML]: Die Frage wird als Text angezeigt und niemals als HTML interpretiert), und das Fenster wird angezeigt;
  • Zeilen 19–27: „Ja“ sendet das gemerkte Formular ab. Die Methode [submit()] eines Formulars sendet es ab, ohne das Ereignis [submit] auszulösen: Es erscheint keine erneute Bestätigungsabfrage. „Nein“ blendet das Fenster aus.

Wenn [JavaScript] deaktiviert ist, werden Formulare einfach ohne Bestätigung gesendet: Die Anwendung funktioniert weiterhin. Dies ist das Prinzip der schrittweisen Verbesserung: [JavaScript] fügt Komfort hinzu, ist aber nicht unerlässlich. Die Fallstudie folgt diesem Prinzip (ihr Skript [static/js/app.js] ergänzt die Tastaturbedienung: Esc-Taste, Fokus). Die resultierenden Seiten ab http://localhost:5000/contacts: die Liste, die Bestätigungsabfrage, die Liste nach dem Löschen und das Profil eines Kontakts:

Image

Image

Image

Image

Schließlich überprüfen wir, dass das Löschen nicht durch eine GET-Anfrage ausgelöst werden kann:

curl -i http://localhost:5000/contacts/2/delete
1
2
3
4
5
HTTP/1.1 405
Allow: POST
Content-Type: application/json

{"timestamp":"2026-09-25T16:54:31.432Z","status":405,"error":"Method Not Allowed","message":"Method 'GET' is not supported.","path":"/contacts/2/delete"}

Der Pfad existiert, aber nicht für die Methode GET: [Spring MVC] gibt [405 Method Not Allowed] zurück, und der Header [Allow] nennt die akzeptierte Methode. Der Antwort-Body ist die Fehlerantwort von [Spring Boot], wie sie bei [curl] als JSON zu sehen ist (ein Browser, der HTML anfordert, erhält eine Fehlerseite). Mit POST:

curl -i -X POST http://localhost:5000/contacts/2/delete
1
2
3
4
HTTP/1.1 302
Set-Cookie: JSESSIONID=A9EDA1129B98CE1244D75669371DA9B0; Path=/; HttpOnly
Location: http://localhost:5000/contacts
Content-Length: 0

Das Löschen wurde durchgeführt, gefolgt von einer Umleitung auf die Liste; das Cookie [JSESSIONID] ist das Session-Cookie, das die Flash-Meldung trägt. Und ein nicht vorhandener Kontakt:

curl -i http://localhost:5000/contacts/99
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"timestamp":"2026-09-25T16:54:31.498Z","status":404,"error":"Not Found","message":"unknown contact","path":"/contacts/99"}

Die 404-Antwort wiederholt die für die Exception [ResponseStatusException] ([unknown contact]) angegebene Begründung. Dieses Feld, [message], ist nur während der Entwicklung vorhanden: Die Entwicklungswerkzeuge von [Spring Boot] ([devtools], eine Abhängigkeit aller Beispiele) aktivieren seine Anzeige; ohne sie enthält die Antwort nur den Code, den Fehler und den Pfad.