Skip to content

2. Controller, Actions, Routing

Dieses Kapitel untersucht den Weg einer Anfrage vom Browser bis zur Action, die sie verarbeitet, sowie die Antwort, die diese Action zurückgibt. Views werden erst in Kapitel 4 behandelt: Hier geben die Actions Text oder JSON direkt zurück.

2.1. Beispiel 01: Die Struktur einer Spring-MVC-Anwendung

Das erste Beispiel ist die kleinstmögliche [Spring MVC]-Anwendung. Zusätzlich zu den in der Einführung vorgestellten Dateien [pom.xml] und [application.properties] enthält es zwei Dateien:

01-structure/
├── src/
│   └── main/
│       ├── java/
│       │   └── example01/
│       │       ├── controllers/
│       │       │   └── HomeController.java
│       │       └── Example01Application.java
│       └── resources/
│           └── application.properties
└── pom.xml

2.1.1. Der Einstiegspunkt: Example01Application.java

package example01;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

// @SpringBootApplication: diese Klasse ist der Startpunkt der Anwendung.
// Spring Boot sucht die Komponenten (Controller, Services ...) in seinem
// Paket [example01] und in allen Unterpaketen.
@SpringBootApplication
public class Example01Application {

    // die Java-main-Methode: der Einstiegspunkt des Programms
    public static void main(String[] args) {
        // wir starten Spring: Konfiguration, Erzeugung der Objekte, Tomcat-Webserver
        // (http://localhost:5000, siehe application.properties); Strg-C beendet ihn
        SpringApplication.run(Example01Application.class, args);
    }
}

Gehen wir diesen Code durch:

  • Zeile 1: das Paket der Klasse. Es muss dem Verzeichnis der Datei entsprechen ([src/main/java/example01]);
  • Zeilen 3–4: Klassen aus anderen Paketen, die von dieser Datei verwendet werden. Anders als [C#] kennt [Java] keine impliziten Importe (außer für das Paket [java.lang], das [String], [Integer] ... enthält): Jede Datei importiert die von ihr verwendeten Klassen ausdrücklich;
  • Zeile 9: [@SpringBootApplication] ist eine Annotation. Eine [Java]-Annotation wird als [@Name] geschrieben, unmittelbar vor dem, was sie beschreibt (einer Klasse, einer Methode, einem Parameter ...): Sie fügt Informationen hinzu, die das Framework beim Start liest. Das entspricht den Attributen [[...]] in [C#]. [@SpringBootApplication] kennzeichnet die Startklasse der Anwendung und vereint drei Annotationen: [@Configuration] (die Klasse kann von [Spring] verwaltete Objekte deklarieren; siehe Beispiel 06), [@EnableAutoConfiguration] (Autokonfiguration: [Spring Boot] konfiguriert automatisch alles, was die verfügbaren Bibliotheken unterstützen, hier [Spring MVC], [Tomcat] und [Jackson]) und [@ComponentScan] (Komponentensuche: [Spring] sucht im Paket dieser Klasse, [example01], und in allen seinen Unterpaketen, etwa [example01.controllers], nach Klassen, die mit [@Controller], [@Service] ... annotiert sind);
  • Zeile 13: die Methode [main], der Einstiegspunkt jedes [Java]-Programms. Sie ist [public] (von überall sichtbar) und [static] (sie gehört zur Klasse, nicht zu einem Objekt der Klasse). Der Parameter [args] enthält die Kommandozeilenargumente;
  • Zeile 16: [SpringApplication.run] startet [Spring]: Es liest die Konfiguration (die Datei [application.properties], Umgebungsvariablen, Kommandozeilenargumente ...), erstellt die Objekte der Anwendung und startet dann den Webserver [Tomcat], der auf Anfragen wartet, bis die Anwendung beendet wird ([Ctrl-C]). [Example01Application.class] verweist auf die Klasse selbst: [Spring] liest daraus die Annotation [@SpringBootApplication] und leitet das zu durchsuchende Paket ab.

Mehr ist nicht zu schreiben: keine Liste von Controllern, keine Routendeklarationen. Die Komponentensuche findet die Controller, und die Autokonfiguration richtet alles Übrige ein.

2.1.2. Der Controller: controllers/HomeController.java

package example01.controllers;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;

// @Controller: diese Klasse ist ein Spring-MVC-Controller
@Controller
public class HomeController {

    // eine Action: die für die Anfrage GET / aufgerufene Methode
    @GetMapping("/")
    // @ResponseBody: der von der Action zurückgegebene Wert IST die an den Browser gesendete Antwort
    @ResponseBody
    public String index() {
        return "Hello from Spring MVC!";
    }
}
  • Zeile 1: Die Klasse liegt im Paket [example01.controllers], einem Unterpaket von [example01]: Die Komponentensuche findet sie;
  • Zeile 8: Die Annotation [@Controller] kennzeichnet die Klasse als Controller für [Spring MVC]. Die Klasse muss nicht von einer Framework-Klasse erben (das unterscheidet sich von [ASP.NET Core MVC]); ihr Name endet üblicherweise auf [Controller]. [Spring] erzeugt das Controller-Objekt beim Start selbst;
  • Zeile 12: Die Annotation [@GetMapping("/")] verknüpft die Methode [index] mit Anfragen vom Typ [GET /]. Eine auf diese Weise mit einer Route verknüpfte Methode ist eine Action;
  • Zeile 14: Die Annotation [@ResponseBody] legt fest, dass der von der Action zurückgegebene Wert der Body der an den Browser gesendeten Antwort ist. Ohne sie würde [Spring MVC] den zurückgegebenen String als Namen einer View behandeln, die angezeigt werden soll (das sehen wir in Beispiel 04 und dann in Kapitel 4);
  • Zeilen 15–16: Die Action gibt einen String zurück. Üblicherweise beginnen [Java]-Methodennamen mit einem Kleinbuchstaben.

2.1.3. Ausführung

Geben Sie in einem Terminalfenster, das im Ordner [01-structure] geöffnet ist, [../mvnw spring-boot:run] ein ([..\mvnw spring-boot:run] unter [Windows]). Nach der Kompilierung zeigt [Spring Boot] sein Banner, gefolgt von seinen Startmeldungen (Datum, Uhrzeit, Prozessnummer und Thread-Name ersetzen wir durch [...] und kürzen die Pfade ab):

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

 :: Spring Boot ::                (v4.1.1)

... INFO ... example01.Example01Application : Starting Example01Application using Java 21.0.10 with PID 4545 (.../examples/01-structure/target/classes ...)
... INFO ... example01.Example01Application : No active profile set, falling back to 1 default profile: "default"
... INFO ... o.s.boot.tomcat.TomcatWebServer : Tomcat initialized with port 5000 (http)
... INFO ... o.apache.catalina.core.StandardEngine : Starting Servlet engine: [Apache Tomcat/11.0.24]
... INFO ... o.s.boot.tomcat.TomcatWebServer : Tomcat started on port 5000 (http) with context path '/'
... INFO ... example01.Example01Application : Started Example01Application in 1.509 seconds (process running for 1.864)

Die Startmeldungen geben die Version von [Java], den Listening-Port (5000, festgelegt durch [application.properties]) und die Version des in die Anwendung eingebetteten Servers [Tomcat] an. Sie nennen außerdem das aktive Profil: [default]. Ein Profil ist eine Gruppe von Einstellungen (Entwicklung, Produktion usw.); die Fallstudie wird eines verwenden. Rufen wir die URL [http://localhost:5000/] mit einem Browser auf:

Image

Dann mit [curl]. Die Option [-i] zeigt auch die HTTP-Header der Antwort an (hier geben wir nur einige davon wieder):

curl -i http://localhost:5000/
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 22

Hello from Spring MVC!

Die erste Zeile der Antwort ist der Statuscode 200, ohne den üblichen Text [OK]: [Tomcat] sendet ihn nicht, weil das HTTP-Protokoll ihn nicht verlangt. Der Browser und [curl] akzeptieren nur den Code.

[curl] hat den String mit dem Header [Content-Type: text/plain] empfangen: reiner Text. Der Browser hat ihn jedoch als HTML dargestellt (erkennbar an der Schriftart, die der von HTML-Seiten entspricht). Das liegt daran, dass [Spring MVC] bei einem String, den eine Action ohne weitere Angaben zurückgibt, den Antworttyp anhand des Headers [Accept] der Anfrage wählt, mit dem der Client die akzeptierten Typen angibt: Das ist die Content Negotiation. [curl] sendet [Accept: */*] (alle Typen) und erhält [text/plain]; ein Browser sendet [Accept: text/html,...] und erhält [text/html]. Überprüfen wir das, indem wir mit [curl] einen Browser-Header senden (Option [-H]):

curl -i -H "Accept: text/html" http://localhost:5000/
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/html;charset=UTF-8
Content-Length: 22

Hello from Spring MVC!

Das unterscheidet sich von [ASP.NET Core MVC], das einen String immer als reinen Text sendete. Beispiel 02 zeigt, wie man den Antworttyp festlegt.

Bei der ersten Anfrage zeigt die Konsole drei weitere Zeilen an:

1
2
3
... INFO ... o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring DispatcherServlet 'dispatcherServlet'
... INFO ... o.s.web.servlet.DispatcherServlet : Initializing Servlet 'dispatcherServlet'
... INFO ... o.s.web.servlet.DispatcherServlet : Completed initialization in 1 ms

[DispatcherServlet] ist der Einstiegspunkt von [Spring MVC] (siehe das Diagramm in der Einführung): [Tomcat] leitet alle Anfragen an ihn weiter, und er wählt die Action aus, die jeweils zuständig ist. [Tomcat] bereitet ihn erst beim Empfang der ersten Anfrage vor.

2.2. Beispiel 02: Routing

Das Routing ordnet einer URL und einer HTTP-Methode (GET, POST ...) eine Action zu. Beispiel 02 hat zwei Controller:

1
2
3
4
5
02-routing/src/main/java/example02/
├── controllers/
│   ├── HomeController.java
│   └── FirstController.java
└── Example02Application.java

Die Klasse [Example02Application] ist bis auf den Namen identisch mit der aus Beispiel 01: Das gilt für alle Beispiele. Die Datei [controllers/HomeController.java]:

package example02.controllers;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

// @RestController = @Controller + @ResponseBody auf jeder Action
@RestController
public class HomeController {

    // GET /: eine HTML-Seite mit Links zu den anderen Actions.
    // produces: der Typ der Antwort (Content-Type-Header), hier HTML
    @GetMapping(value = "/", produces = MediaType.TEXT_HTML_VALUE)
    public String index() {
        return """
            <h2>Example 02 - routing</h2>
            <ul>
              <li><a href="/first">/first</a></li>
              <li><a href="/first/action01">/first/action01</a></li>
              <li><a href="/first/products/17">/first/products/17</a></li>
              <li><a href="/first/products/17/reviews/3">/first/products/17/reviews/3</a></li>
              <li><a href="/first/files/images/logo.png">/first/files/images/logo.png</a></li>
              <li><a href="/first/products/abc">/first/products/abc</a></li>
              <li><a href="/unknown">/unknown</a></li>
            </ul>
            """;
    }
}
  • Zeile 8: [@RestController] vereint [@Controller] und [@ResponseBody]: Alle Actions der Klasse geben direkt den Body der Antwort zurück. Das ist die gebräuchlichste Form für einen Controller, der keine Views erzeugt; wir verwenden sie bis Kapitel 4;
  • Zeile 13: Eine Annotation kann mehrere Attribute haben, geschrieben als [name = value]. [value] ist der Routenpfad (steht es allein, kann [value =] entfallen, wie in Beispiel 01); [produces] legt den Antworttyp fest (den Header [Content-Type]), hier [text/html], unabhängig vom Anfrage-Header [Accept]. [MediaType.TEXT_HTML_VALUE] ist eine Konstante, die gleich ["text/html"] ist: Ein Tippfehler in ihrem Namen würde einen Kompilierfehler verursachen, was bei einem von Hand geschriebenen String nicht der Fall ist;
  • Zeilen 15–26: ein Textblock ([text block], [Java] 15), begrenzt durch drei Anführungszeichen. Er kann sich über mehrere Zeilen erstrecken und Anführungszeichen enthalten, ohne dass sie maskiert werden müssen. Die allen seinen Zeilen gemeinsame Einrückung (einschließlich der des schließenden ["""]) wird entfernt.

Die Action [index] gibt also eine HTML-Seite zurück, die Links auf die Actions des anderen Controllers enthält:

Image

Die Datei [controllers/FirstController.java]:

package example02.controllers;

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.RestController;

// Präfix, das alle Routen des Controllers gemeinsam haben
@RestController
@RequestMapping("/first")
public class FirstController {

    // GET /first
    @GetMapping("")
    public String index() {
        return "Action [index] of the [First] controller";
    }

    // GET /first/action01
    @GetMapping("/action01")
    public String action01() {
        return "Action [action01] of the [First] controller, GET request";
    }

    // POST /first/action01: gleicher Pfad, andere HTTP-Methode
    @PostMapping("/action01")
    public String action01Post() {
        return "Action [action01Post] of the [First] controller, POST request";
    }

    // GET /first/products/17: {id} ist eine Pfadvariable; \d+: nur Ziffern
    @GetMapping("/products/{id:\\d+}")
    public String product(@PathVariable int id) {
        return "Product no. " + id;
    }

    // GET /first/products/17/reviews/3: zwei Pfadvariablen
    @GetMapping("/products/{id:\\d+}/reviews/{number:\\d+}")
    public String review(@PathVariable int id, @PathVariable int number) {
        return "Review no. %d of product no. %d".formatted(number, id);
    }

    // GET /first/files/...: {*path} akzeptiert jedes beliebige Pfadende
    @GetMapping("/files/{*path}")
    public String file(@PathVariable String path) {
        return "Requested file: " + path;
    }
}

Kommentieren wir diesen Code:

  • Zeilen 10–11: Die auf die Klasse angewandte Annotation ***[@RequestMapping("/first")]*** legt das allen Routen des Controllers gemeinsame Präfix fest: Seine Actions behandeln URL-Routen, die mit ***[/first]*** beginnen;
  • Zeilen 15–16: [@GetMapping("")]: Die Action [index] verarbeitet [GET /first]. Die URL einer Action ist die Verkettung des Controller-Präfixes und des Action-Pfads;
  • Zeilen 21–22: Die Action [action01] verarbeitet [GET /first/action01];
  • Zeilen 27–28: derselbe Pfad, aber für die Methode POST: [@PostMapping] ersetzt [@GetMapping]. Es gibt außerdem [@PutMapping], [@DeleteMapping], [@PatchMapping] ... (und [@RequestMapping], auf eine Methode angewandt, akzeptiert alle HTTP-Methoden). Der Name der [Java] -Methode ([action01Post]) ist beliebig: Für das Routing zählen nur die Annotationen. Außerdem können innerhalb derselben Klasse zwei Methoden nicht denselben Namen mit denselben Parametern haben;
  • Zeilen 33–34: [{id}] ist eine Pfadvariable: Dieses URL-Segment kann mehrere Werte annehmen. [\d+] ist ein regulärer Ausdruck: Das Segment muss aus einer oder mehreren Ziffern bestehen, andernfalls passt die Route nicht. In einem [Java]-String wird das Zeichen [\] als [\\] geschrieben: daher [{id:\\d+}]. Die Annotation [@PathVariable] weist [Spring MVC] an, den Wert des Segments an den gleichnamigen Parameter der Action zu übergeben, [id], nachdem er in [int] konvertiert wurde: Für [/first/products/17] ist [id] gleich der Zahl 17. Das ist das Datenbinding ([data binding]), das das nächste Kapitel im Detail behandelt. Damit [Spring] die Namen der Parameter kennt, muss der Compiler sie in den kompilierten Klassen erhalten (Option [-parameters]): [spring-boot-starter-parent] kümmert sich darum;
  • Zeile 35: Der Operator [+] verkettet einen String und eine Zahl;
  • Zeilen 39–41: Zwei Pfadvariablen werden als zwei Parameter an die Action übergeben. Die Methode [formatted] ersetzt jedes Vorkommen von [%d] im Text durch eine ganze Zahl, in der Reihenfolge der Argumente;
  • Zeilen 45–47: [{*path}] ist eine „Catch-all“-Variable ([catch-all]): Sie akzeptiert jedes URL-Ende, einschließlich [/]. Ihr Wert beginnt mit einem [/].

Hier die Ergebnisse für einige Anfragen:

curl -i http://localhost:5000/first
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 40

Action [index] of the [First] controller
curl -i http://localhost:5000/first/action01
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 56

Action [action01] of the [First] controller, GET request
curl -i http://localhost:5000/first/products/17
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 14

Product no. 17
curl -i http://localhost:5000/first/products/17/reviews/3
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 30

Review no. 3 of product no. 17
curl -i http://localhost:5000/first/files/images/logo.png
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 32

Requested file: /images/logo.png

Um eine POST-Anfrage zu senden, verwenden Sie die Option [-X POST] von [curl]:

curl -i -X POST http://localhost:5000/first/action01
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 61

Action [action01Post] of the [First] controller, POST request

Eine HTTP-Methode, die von keiner Action für diesen Pfad behandelt wird, führt zu einem Fehler 405 ([Method Not Allowed]). Der Header [Allow] listet die akzeptierten Methoden auf:

curl -i -X PUT http://localhost:5000/first/action01
1
2
3
4
5
HTTP/1.1 405
Allow: POST, GET
Content-Type: application/json

{"timestamp":"2026-09-25T16:45:30.867Z","status":405,"error":"Method Not Allowed","message":"Method 'PUT' is not supported.","path":"/first/action01"}

Schließlich führt eine URL, die von keiner Route behandelt wird, zu einem Fehler 404. Das gilt auch für einen Bezeichner, der nicht dem regulären Ausdruck [\d+] entspricht: Keine Route passt zu [/first/products/abc].

curl -i http://localhost:5000/first/products/abc
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"timestamp":"2026-09-25T16:45:30.828Z","status":404,"error":"Not Found","message":"No static resource first/products/abc.","path":"/first/products/abc"}
curl -i http://localhost:5000/unknown
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"timestamp":"2026-09-25T16:45:30.841Z","status":404,"error":"Not Found","message":"No static resource unknown.","path":"/unknown"}

Anders als bei [ASP.NET Core] enthalten die Fehlerantworten von [Spring Boot] folgende Informationen: das Datum des Fehlers, den Statuscode, seine Beschreibung, eine Meldung und den angeforderten Pfad. Die Meldung [No static resource] lässt sich so erklären: Wenn keine Action zur URL passt, sucht [Spring MVC] nach einer statischen Datei mit diesem Namen (einem Bild, einem Stylesheet ... im Ordner [src/main/resources/static] der Anwendung); da es keine findet, meldet es einen Fehler 404. [Spring Boot] erzeugt dann die Fehlerantwort, und die Content Negotiation greift erneut: [curl] erhält JSON, ein Browser eine HTML-Seite, die „Whitelabel Error Page“ (eine „neutrale“ Fehlerseite):

Image

Kapitel 7 zeigt, wie sich diese Seite durch eine anwendungsspezifische Fehlerseite ersetzen lässt.

2.3. Beispiel 03: Antworten einer Action

Was eine Action zurückgibt, bestimmt die HTTP-Antwort. Beispiel 03 geht die wichtigsten Fälle durch. Die Datei [controllers/ResponsesController.java]:

package example03.controllers;

import java.time.Duration;
import java.time.Instant;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/responses")
public class ResponsesController {

    // ein String, als reiner Text angekündigt: der Browser zeigt ihn unverändert an
    @GetMapping(value = "/text", produces = MediaType.TEXT_PLAIN_VALUE)
    public String text() {
        return "<h1>Action [text]</h1>";
    }

    // derselbe String, als HTML angekündigt: der Browser interpretiert ihn
    @GetMapping(value = "/html", produces = MediaType.TEXT_HTML_VALUE)
    public String html() {
        return "<h1>Action [html]</h1>";
    }

    // ein Record: eine Datenklasse (siehe Beispiel 06), hier innerhalb des Controllers deklariert
    public record Person(String lastName, String firstName, int age) {
    }

    // ein Objekt: als JSON serialisiert, mit dem Typ [application/json]
    @GetMapping("/json")
    public Person json() {
        return new Person("Martin", "Jean", 42);
    }

    // eine Liste: als JSON-Array serialisiert
    @GetMapping("/list")
    public List<String> list() {
        return List.of("Mme", "Melle", "Mr");
    }

    // ResponseEntity: die Action wählt die vollständige Antwort (Code, Header, Inhalt)
    // status(201): der Code 201 (Created) statt 200 (OK)
    @GetMapping("/created")
    public ResponseEntity<Map<String, String>> created() {
        return ResponseEntity.status(HttpStatus.CREATED).body(Map.of("message", "resource created"));
    }

    // keine Antwort: der Code 204 (No Content) bedeutet "nichts anzuzeigen"
    @GetMapping("/empty")
    public ResponseEntity<Void> empty() {
        return ResponseEntity.noContent().build();
    }

    // eine asynchrone Action: Spring MVC wartet auf das Ende der Verarbeitung (CompletableFuture)
    @GetMapping("/task")
    public CompletableFuture<Map<String, String>> task() {
        Instant start = Instant.now();
        // eine Wartezeit von 500 ms, ohne den Thread zu blockieren, der die Anfrage erhalten hat
        return CompletableFuture.supplyAsync(
                () -> Map.of("wait", Duration.between(start, Instant.now()).toMillis() + " ms"),
                CompletableFuture.delayedExecutor(500, TimeUnit.MILLISECONDS));
    }

    // ein "erwarteter" Fehler: status(404) erzeugt eine 404-Antwort
    @GetMapping("/not-found")
    public ResponseEntity<Map<String, String>> notFound() {
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(Map.of("message", "This resource does not exist"));
    }

    // ein "unerwarteter" Fehler: eine unbehandelte Exception erzeugt eine 500-Antwort
    @GetMapping("/exception")
    public String exception() {
        throw new IllegalStateException("An unexpected error");
    }
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeilen 22–25: ein String, durch das Attribut [produces] als reiner Text gekennzeichnet (siehe Beispiel 02): Der Browser zeigt ihn unverändert an, einschließlich der Tags;
  • Zeilen 28–31: derselbe String, als HTML deklariert: Der Browser interpretiert ihn;
  • Zeilen 34–35: ein Record ([Java] 16): eine Datenklasse, in einer einzigen Zeile deklariert. Der Compiler erzeugt für jede Komponente ein privates, schreibgeschütztes Feld ([lastName], [firstName], [age]), einen Konstruktor, der sie initialisiert, für jede eine Zugriffsmethode ([lastName()], [firstName()], [age()]) und Hilfsmethoden ([equals], [hashCode], [toString]). Der Record ist hier innerhalb des Controllers deklariert: Er ist eine verschachtelte Klasse, deren vollständiger Name [ResponsesController.Person] lautet;
  • Zeilen 38–41: Ein Objekt wird in JSON serialisiert, mit dem Header [Content-Type: application/json]. Die Konvertierung übernimmt die Bibliothek [Jackson], die vom Starter [spring-boot-starter-webmvc] bereitgestellt wird: Die Namen der JSON-Eigenschaften entsprechen den Komponenten des Records;
  • Zeilen 44–47: Eine Liste wird in ein JSON-Array serialisiert. [List.of(...)] erzeugt eine schreibgeschützte Liste. [List<String>] ist ein generischer Typ: eine Liste, deren Elemente Strings sind;
  • Zeilen 51–54: Wenn die Action den Statuscode selbst bestimmen muss, gibt sie eine [ResponseEntity<T>] zurück: ein Objekt, das die vollständige Antwort beschreibt (Code, Header, Body vom Typ [T]). Es wird über statische Methoden der Klasse [ResponseEntity] erzeugt, die nacheinander aufgerufen werden: [status(HttpStatus.CREATED)] setzt den Code auf 201 ([Created]), [body(...)] legt den Inhalt fest, der in JSON serialisiert wird. [Map.of("message", "resource created")] erzeugt ein nicht veränderbares Dictionary (eine [Map]) mit einem einzigen Schlüssel, die [Jackson] in ein JSON-Objekt serialisiert;
  • Zeilen 57–60: [noContent()] gibt eine Antwort 204 zurück ([No Content]): „kein Inhalt“. [build()] liefert eine Antwort ohne Body, was zum Typ [ResponseEntity<Void>] führt;
  • Zeilen 63–70: eine asynchrone Action. Sie gibt ein [CompletableFuture<T>] zurück, ein „ausstehendes“ Ergebnis (das Pendant zu einem [Task<T>] aus [C#] oder zu einem [JavaScript]-Promise); [Spring MVC] gibt den Thread von [Tomcat] , der die Anfrage bearbeitete, sofort frei und sendet die Antwort erst, wenn das Ergebnis vorliegt. [supplyAsync(function, executor)] berechnet das Ergebnis mit der Funktion, die hier nach einer Verzögerung von 500 ms ausgeführt wird. Die Funktion wird als Lambda geschrieben: [() -> expression] ist eine Funktion ohne Parameter, die den Wert des Ausdrucks zurückgibt. [Duration.between] misst die Zeitspanne zwischen zwei Zeitpunkten;
  • Zeilen 73–76: ein vom Programm vorhergesehener Fehler: eine [ResponseEntity] mit dem Code 404, die JSON enthält. Die Klasse [ResponseEntity] hat außerdem Kurzformen: [ok(...)] (200), [badRequest()] (400), [notFound()] (404) ...;
  • Zeilen 79–82: ein unerwarteter Fehler: Die Action wirft eine Exception, die sie nicht behandelt. [Spring Boot] antwortet dann mit einem Fehler 500 ([Internal Server Error]).

Empfangene Antworten:

curl -i http://localhost:5000/responses/text
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 22

<h1>Action [text]</h1>
curl -i http://localhost:5000/responses/html
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/html;charset=UTF-8
Content-Length: 22

<h1>Action [html]</h1>
curl -i http://localhost:5000/responses/json
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 49

{"lastName":"Martin","firstName":"Jean","age":42}
curl -i http://localhost:5000/responses/list
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 20

["Mme","Melle","Mr"]
curl -i http://localhost:5000/responses/created
1
2
3
4
HTTP/1.1 201
Content-Type: application/json

{"message":"resource created"}
curl -i http://localhost:5000/responses/empty
HTTP/1.1 204
curl -i http://localhost:5000/responses/task
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 17

{"wait":"506 ms"}
curl -i http://localhost:5000/responses/not-found
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"message":"This resource does not exist"}
curl -i http://localhost:5000/responses/exception
1
2
3
4
HTTP/1.1 500
Content-Type: application/json

{"timestamp":"2026-09-25T16:45:56.039Z","status":500,"error":"Internal Server Error","message":"An unexpected error","path":"/responses/exception"}

Bei der Exception enthält die Fehlerantwort von [Spring Boot] (siehe Beispiel 02) die Exception-Meldung, nicht aber den Aufrufstack, den die Datei [application.properties] untersagt (siehe Einführung). Die Meldung selbst erscheint dort nur, weil die Entwicklungswerkzeuge ([Spring Boot DevTools]) aktiv sind: Im Produktivbetrieb, ohne sie, würde die Antwort so aussehen:

1
2
3
4
HTTP/1.1 500
Content-Type: application/json

{"timestamp":"2026-09-25T16:46:17.984Z","status":500,"error":"Internal Server Error","path":"/responses/exception"}

Eine Exception-Meldung kann einem Angreifer tatsächlich Informationen liefern. Die Fehlerdetails werden in die Serverkonsole geschrieben (hier geben wir nur den Anfang wieder):

1
2
3
4
5
... ERROR ... o.a.c.c.C.[.[.[/].[dispatcherServlet] : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed: java.lang.IllegalStateException: An unexpected error] with root cause

java.lang.IllegalStateException: An unexpected error
    at example03.controllers.ResponsesController.exception(ResponsesController.java:81) ~[classes/:na]
    ...

Im Browser ist der Unterschied zwischen [text/plain] und [text/html] sichtbar:

Image

Image

2.4. Beispiel 04: Weiterleitungen

Eine Action kann mit einer Weiterleitung antworten: einem Statuscode 301 oder 302 und einem Header [Location], der dem Browser mitteilt, welche URL er als Nächstes anfordern soll. Der Browser fordert sie sofort an, ohne Zutun des Benutzers. Weiterleitungen sind in einer Webanwendung allgegenwärtig: nach dem erfolgreichen Absenden eines Formulars, nach der Anmeldung, nach dem Wechsel der Sprache ...

Die Datei [controllers/RedirectsController.java]:

package example04.controllers;

import java.net.URI;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

// @Controller (und nicht @RestController): ein von einer Action zurückgegebener String ist
// hier der NAME EINER VIEW, und "redirect:..." ein spezieller View-Name
@Controller
public class RedirectsController {

    // permanente Weiterleitung (301): die Seite hat dauerhaft eine neue Adresse
    @GetMapping("/old")
    public ResponseEntity<Void> oldPage() {
        return ResponseEntity.status(HttpStatus.MOVED_PERMANENTLY).location(URI.create("/new")).build();
    }

    @GetMapping("/new")
    @ResponseBody
    public String newPage() {
        return "You are on the [new] page";
    }

    // temporäre Weiterleitung (302) auf eine berechnete Adresse
    @GetMapping("/go/{destination}")
    public String go(@PathVariable String destination) {
        return "redirect:/page/" + destination;
    }

    // Weiterleitung auf eine TEMPLATE-Adresse: Spring ersetzt {name} durch den Wert
    // des Attributs [name] und kodiert ihn korrekt für eine URL
    @GetMapping("/to-template/{destination}")
    public String toTemplate(@PathVariable String destination, RedirectAttributes attributes) {
        attributes.addAttribute("name", destination);
        return "redirect:/page/{name}";
    }

    @GetMapping("/page/{name}")
    @ResponseBody
    public String page(@PathVariable String name) {
        return "You are on the [" + name + "] page";
    }

    // Weiterleitung auf eine andere Website
    @GetMapping("/documentation")
    public String documentation() {
        return "redirect:https://docs.spring.io/spring-framework/reference/web/webmvc.html";
    }
}

Kommentieren wir diesen Code:

  • Zeile 15: Die Klasse ist als [@Controller] annotiert, nicht als [@RestController]. Ein von einer Action zurückgegebener String ist daher – außer bei [@ResponseBody] – der Name einer View; und ein View-Name, der mit [redirect:] beginnt, ist ein besonderer Name, der eine Weiterleitung auslöst;
  • Zeilen 19–22: eine dauerhafte Weiterleitung (Statuscode 301, [Moved Permanently]): Die Seite ist dauerhaft an eine neue Adresse umgezogen. Browser und Suchmaschinen können die neue Adresse speichern. Sie wird mit einer [ResponseEntity] erzeugt (siehe Beispiel 03): [location(...)] setzt den Header [Location], dessen Wert ein [URI] -Objekt (eine Adresse) ist;
  • Zeilen 24–28: Die Annotation [@ResponseBody] ist hier erforderlich: Der zurückgegebene String ist der Body der Antwort, nicht ein View-Name;
  • Zeilen 31–34: ["redirect:" + url] erzeugt eine temporäre Weiterleitung (Statuscode 302, [Found]), hier an eine berechnete Adresse;
  • Zeilen 38–42: eine Weiterleitung an eine Template-Adresse: In [redirect:/page/{name}] ersetzt [Spring MVC] [{name}] durch den Wert des Attributs [name], das im Objekt [RedirectAttributes] gespeichert ist. Dieses Objekt stellt [Spring MVC] der Action bereit, die es als Parameter anfordert. Der Vorteil gegenüber der vorherigen Form: Der Wert wird für eine URL korrekt kodiert (siehe unten). Das Objekt [RedirectAttributes] wird in Kapitel 4 außerdem verwendet, um Nachrichten an die nächste Seite zu übergeben;
  • Zeilen 51–54: Sie können auch auf eine andere Website weiterleiten.

[curl] zeigt die Weiterleitung, ohne ihr tatsächlich zu folgen:

curl -i http://localhost:5000/old
1
2
3
HTTP/1.1 301
Location: /new
Content-Length: 0

Mit der Option [-L] folgt [curl] der Weiterleitung, genau wie es ein Browser täte. Wir sehen dann die beiden aufeinanderfolgenden Antworten:

curl -i -L http://localhost:5000/old
1
2
3
4
5
6
7
8
9
HTTP/1.1 301
Location: /new
Content-Length: 0

HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 25

You are on the [new] page
curl -i http://localhost:5000/go/contact
1
2
3
HTTP/1.1 302
Location: http://localhost:5000/page/contact
Content-Length: 0
curl -i http://localhost:5000/to-template/contact
1
2
3
HTTP/1.1 302
Location: http://localhost:5000/page/contact
Content-Length: 0

Beide Actions führen zur selben Weiterleitung. Beachten Sie, dass die Adresse im Header [Location] diesmal absolut ist ([http://localhost:5000/...]), obwohl die Action eine relative Adresse zurückgegeben hat ([/page/contact]): Eine Weiterleitung mit [redirect:] läuft über den Server [Tomcat], der die Adresse vervollständigt, weil [Spring Boot] ihn standardmäßig so einstellt (Eigenschaft [server.tomcat.use-relative-redirects], die auf [false] steht). Die Weiterleitung der Action [oldPage], die von einer [ResponseEntity] erzeugt wird, behält die Adresse dagegen unverändert bei. Beide Formen sind korrekt.

Der Unterschied zwischen den beiden Actions wird sichtbar, wenn das Ziel ein Zeichen enthält, das in einer URL kodiert werden muss, etwa ein Leerzeichen (kodiert als [%20]):

curl -i http://localhost:5000/go/my%20contact
1
2
3
HTTP/1.1 302
Location: http://localhost:5000/page/my contact
Content-Length: 0
curl -i http://localhost:5000/to-template/my%20contact
1
2
3
HTTP/1.1 302
Location: http://localhost:5000/page/my%20contact
Content-Length: 0

Der Pfadvariablen [destination] wurde der dekodierte Wert zugewiesen, [my contact]. Die Verkettung in der Action [go] kopiert ihn exakt so: Der Header [Location] enthält ein rohes Leerzeichen, was die Adresse ungültig macht (eine URL enthält kein Leerzeichen). Manche Clients korrigieren das von selbst ([curl -L] folgt der Weiterleitung zum Beispiel trotzdem und landet auf der Seite [my contact]), andere nicht: Das ist eine Falle, denn der Fehler bleibt beim Testen unbemerkt. Die Template-URL der Action [toTemplate] hingegen ist korrekt kodiert: Das ist der richtige Weg, einen variablen Wert in eine Weiterleitung einzufügen. Im Browser ist nur die endgültige Seite sichtbar; die Adressleiste zeigt die neue URL:

Image

curl -i http://localhost:5000/documentation
1
2
3
HTTP/1.1 302
Location: https://docs.spring.io/spring-framework/reference/web/webmvc.html
Content-Length: 0

2.5. Beispiel 05: Die Objekte Request und Response

[Spring MVC] beruht auf der API [Servlet] und auf [Jakarta EE] (früher [Java EE]), dem Standard für [Java]-Webserver: [Tomcat] ist ein Servlet-Container, und [DispatcherServlet] ist ein Servlet – also ein Objekt, an das der Server Anfragen delegiert. In diesem Standard wird jede Anfrage durch ein Objekt [HttpServletRequest] dargestellt und die gerade erzeugte Antwort durch ein Objekt [HttpServletResponse]. Eine Action kann beide erhalten: Sie müssen sie lediglich als Parameter anfordern. Das ist mitunter notwendig, und wir tun es in der Fallstudie (zum Beispiel, um ein Cookie zu lesen oder zu setzen), aber Sie sollten wissen, was Sie tun.

Die Datei [controllers/HttpController.java]:

package example05.controllers;

import java.io.IOException;
import java.util.LinkedHashMap;
import java.util.Map;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

@RestController
@RequestMapping("/http")
public class HttpController {

    // die Anfrage: Methode, Pfad, Parameter, Header ...
    // Spring übergibt das Objekt HttpServletRequest an die Action, die es anfordert
    @GetMapping("/request")
    public Map<String, String> request(HttpServletRequest request) {
        // LinkedHashMap: ein Dictionary, das die Einfügereihenfolge der Schlüssel beibehält
        Map<String, String> info = new LinkedHashMap<>();
        info.put("method", request.getMethod());
        info.put("path", request.getRequestURI());
        info.put("parameters", request.getQueryString());
        info.put("browser", request.getHeader("User-Agent"));
        info.put("ip", request.getRemoteAddr());
        return info;
    }

    // die Antwort: wir fügen ihr einen Header hinzu, dann gibt die Action ihren Wert ganz normal zurück
    @GetMapping("/header")
    public String header(HttpServletResponse response) {
        response.setHeader("X-Example", "05-request-response");
        return "Response with an added header";
    }

    // die Antwort "von Hand" geschrieben: Code, Typ, dann der Body
    @GetMapping("/response")
    public void response(HttpServletResponse response) throws IOException {
        response.setStatus(200);
        response.setContentType("text/plain;charset=UTF-8");
        response.getWriter().write("Response written by [response.getWriter()]");
    }

    // FEHLER, den man nicht machen darf: die Antwort schreiben und DANN ein Ergebnis zurückgeben
    @GetMapping("/double")
    public ResponseEntity<Void> doubleResponse(HttpServletResponse response) throws IOException {
        response.getWriter().write("Start of the response... ");
        // flushBuffer: die ersten Bytes gehen an den Browser
        response.flushBuffer();
        // die Antwort ist bereits gesendet: Code und Header können sich nicht mehr ändern
        return ResponseEntity.notFound().build();
    }
}

Kommentieren wir diesen Code:

  • Zeilen 12–13: Die Klassen der API [Servlet] liegen im Paket [jakarta.servlet...];
  • Zeile 22: Die Action deklariert einen Parameter vom Typ [HttpServletRequest]: [Spring MVC] übergibt ihr die aktuelle Anfrage. So stellt [Spring MVC] einer Action bereit, was sie braucht: anhand des Typs ihrer Parameter oder anhand ihrer Annotationen ([@PathVariable] ...);
  • Zeile 24: ein veränderbares Dictionary. [Map] ist ein Interface (ein Typ, der Operationen beschreibt, ohne sie zu implementieren; wir kommen in Beispiel 06 darauf zurück), [LinkedHashMap] ist eine seiner Implementierungen; [<>] übernimmt die generischen Typen aus der Deklaration ([<String, String>]);
  • Zeilen 25–29: die Anfrage: die HTTP-Methode ([getMethod]), der Pfad ([getRequestURI]), die URL-Parameter ([getQueryString], ohne das [?], oder [null] , falls keine vorhanden sind), ein Header ([getHeader]) und die IP-Adresse des Clients ([getRemoteAddr]);
  • Zeilen 34–38: Die Action fügt der Antwort einen Header hinzu und gibt dann normal seinen Wert zurück, den [Spring MVC] sendet. Das ist die häufigste Verwendung des Response-Objekts;
  • Zeilen 41–46: Die Action schreibt die Antwort selbst – Statuscode, Typ und dann den Body – mit dem Objekt [PrintWriter], das [getWriter()] liefert. Sie gibt nichts zurück ([void]): [Spring MVC] geht dann davon aus, dass die Antwort von der Action geschrieben wurde. Die Klausel [throws IOException] deklariert, dass die Methode eine [IOException] (einen Schreibfehler) werfen kann: In [Java] muss eine Methode auf diese Weise die sogenannten geprüften Exceptions deklarieren, die sie nicht behandelt;
  • Zeilen 49–56: der zu vermeidende Fehler: einen Teil der Antwort zu schreiben und dann ein Ergebnis zurückzugeben. Sobald die ersten Bytes des Bodys an den Browser gesendet wurden (hier erzwungen durch [flushBuffer]), können Statuscode und Header – die vor dem Body gesendet werden – nicht mehr geändert werden.

Die erhaltenen Antworten:

curl -i -A "Mozilla/5.0 (example)" "http://localhost:5000/http/request?name=martin"
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 117

{"method":"GET","path":"/http/request","parameters":"name=martin","browser":"Mozilla/5.0 (example)","ip":"127.0.0.1"}

(die Option [-A] von [curl] setzt den Header [User-Agent], der den Browser identifiziert)

curl -i http://localhost:5000/http/header
1
2
3
4
5
6
HTTP/1.1 200
X-Example: 05-request-response
Content-Type: text/plain;charset=UTF-8
Content-Length: 29

Response with an added header
curl -i http://localhost:5000/http/response
1
2
3
4
5
HTTP/1.1 200
Content-Type: text/plain;charset=UTF-8
Content-Length: 42

Response written by [response.getWriter()]
curl -i http://localhost:5000/http/double
1
2
3
HTTP/1.1 200

Start of the response...

Bei der letzten Anfrage erhält der Client den Statuscode 200 und den Anfang der Antwort statt des angeforderten 404. Und anders als bei [ASP.NET Core] meldet der Server nichts: Die Konsole bleibt stumm, und der Fehler kann unbemerkt bleiben. Die Antwort offenbart einen zweiten Mangel: Sie hat keinen Header [Content-Type]. Die Action hat den Antworttyp nicht festgelegt, bevor sie schrieb: Das Response-Objekt kodiert den Text dann gemäß dem Standardzeichensatz des Standards [Servlet], [ISO-8859-1], während das Terminal UTF-8 erwartet, sodass etwaige Umlaute und andere Sonderzeichen durch [�] ersetzt würden (dieser englische Text enthält keine). Der Browser seinerseits erhält keinen Hinweis auf einen Zeichensatz; er errät einen – in diesem Fall erfolgreich:

Image

Im weiteren Verlauf des Dokuments geben Actions fast immer einen Wert zurück (ein Objekt, eine [ResponseEntity], einen View-Namen) und überlassen [Spring MVC] das Schreiben der Antwort. [HttpServletRequest] und [HttpServletResponse] dienen nur noch dazu, die Anfrage zu lesen und Cookies zu setzen.

2.6. Beispiel 06: Services und Dependency Injection

Controller sollten keine Anwendungslogik enthalten; sie delegieren sie an Services. Ein Service ist ein gewöhnliches Objekt, das [Spring] erzeugt und den Klassen bereitstellt, die es brauchen: Das ist die Dependency Injection. Die Objekte, die [Spring] auf diese Weise erzeugt und verwaltet, heißen Beans (vom englischen Wort für „Bohnen“; Controller sind ebenfalls Beans). Die Gesamtheit der Beans einer Anwendung bildet den [Spring] -Kontext oder Bean-Container. Beispiel 06 gliedert eine kleine Anwendung in zwei Teile: Produkte und Kunden:

06-services/src/main/java/example06/
├── clients/
│   └── ClientsController.java
├── products/
│   ├── Product.java
│   ├── ProductsConfig.java
│   ├── ProductsController.java
│   ├── ProductsService.java
│   └── InMemoryProductsService.java
└── Example06Application.java

2.6.1. Das Produkt

1
2
3
4
5
6
7
package example06.products;

import java.math.BigDecimal;

// ein "Record": eine Datenklasse, deren Felder vom Konstruktor gesetzt werden
public record Product(int id, String name, BigDecimal price) {
}

Ein Record (siehe Beispiel 03), diesmal in einer eigenen Datei. Der Typ [BigDecimal] stellt Beträge ohne Rundungsfehler dar, was der Typ [double] nicht garantiert.

2.6.2. Der Service-Vertrag: ProductsService

package example06.products;

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

// der VERTRAG des Services: was er kann, ohne zu sagen, wie
public interface ProductsService {

    List<Product> findAll();

    Optional<Product> findById(int id);
}
  • Zeile 7: Ein Interface beschreibt, was der Service kann, ohne festzulegen, wie. Klassen, die den Service verwenden, kennen nur dieses Interface. Anders als die Konvention in [C#] ([IProductsService]) beginnt der Name eines [Java] -Interfaces nicht mit [I];
  • Zeile 9: [List<Product>]: eine Liste von Produkten;
  • Zeile 11: [Optional<Product>]: ein Produkt, oder nichts , wenn kein Produkt diese Kennung hat. Ein [Optional] ist ein Behälter, entweder leer oder mit einem Wert: Er zwingt den Aufrufer, den Fall zu bedenken, dass es kein Produkt gibt, während ein [null] übersehen werden könnte (und eine [NullPointerException] verursachen würde).

2.6.3. Die Implementierung: InMemoryProductsService

package example06.products;

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

// eine IMPLEMENTIERUNG des Vertrags: hier mit Daten im Speicher
public class InMemoryProductsService implements ProductsService {

    private final List<Product> products = List.of(
            new Product(1, "pen", new BigDecimal("1.5")),
            new Product(2, "notebook", new BigDecimal("3.2")),
            new Product(3, "eraser", new BigDecimal("0.8")));

    @Override
    public List<Product> findAll() {
        return products;
    }

    @Override
    public Optional<Product> findById(int id) {
        return products.stream().filter(p -> p.id() == id).findFirst();
    }
}
  • Zeile 8: Die Klasse implementiert das Interface ([implements]): Sie muss alle seine Methoden bereitstellen;
  • Zeilen 10–13: die Daten, hier im Speicher, in einer schreibgeschützten Liste. Die Beträge werden aus Strings erzeugt: [new BigDecimal("1.5")] ist exakt 1,5;
  • Zeilen 15 und 20: Die Annotation [@Override] zeigt an, dass die Methode zu einem Interface (oder einer Elternklasse) gehört: Der Compiler prüft, ob sie dort tatsächlich existiert;
  • Zeile 22: ein Iterator ([stream]) durchläuft die Liste: [filter] behält nur die Produkte, die die Bedingung erfüllen, geschrieben als Lambda mit einem Parameter (siehe Beispiel 03), [p]; [findFirst] gibt das erste verbleibende Produkt in einem [Optional] zurück, das leer ist, wenn keines übrig bleibt. [p.id()] ist die Zugriffsmethode für die Komponente [id] des Records.

Die Klasse hat keine Annotationen: Sie ist eine gewöhnliche [Java]-Klasse, die nichts von [Spring] weiß. Wie sie zu einer Bean wird, sehen wir gleich.

2.6.4. Der Controller ProductsController

package example06.products;

import java.util.List;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/products")
public class ProductsController {

    private final ProductsService productsService;

    // Dependency Injection: Spring stellt die Implementierung von ProductsService bereit
    public ProductsController(ProductsService productsService) {
        this.productsService = productsService;
    }

    @GetMapping("")
    public List<Product> list() {
        return productsService.findAll();
    }

    @GetMapping("/{id:\\d+}")
    public ResponseEntity<?> oneProduct(@PathVariable int id) {
        return productsService.findById(id)
                .<ResponseEntity<?>>map(ResponseEntity::ok)
                .orElseGet(() -> ResponseEntity.status(HttpStatus.NOT_FOUND)
                        .body(Map.of("message", "Product no. " + id + " not found")));
    }
}
  • Zeilen 17–22: Dependency Injection. Der Controller deklariert in seinem Konstruktor, dass er einen [ProductsService] benötigt; [Spring], das den Controller erzeugt, stellt ihm eine Bean dieses Typs bereit (siehe unten). Der Controller ruft nie [new InMemoryProductsService()] auf: Er kennt diese Klasse nicht einmal, nur das Interface. Wir könnten die Implementierung ersetzen (durch eine Version, die eine Datenbank liest, oder durch eine Testversion), ohne den Controller zu ändern. Das Feld ist als ***[final]*** deklariert: Es kann nur einmal zugewiesen werden, im Konstruktor;
  • Zeilen 24–27: Die Action delegiert an den Service. Die Liste wird als JSON serialisiert;
  • Zeilen 29–35: [{id:\\d+}] akzeptiert nur Zahlen; ein nicht vorhandenes Produkt liefert eine Antwort 404. Das vom Service zurückgegebene [Optional] wird in zwei Schritten verarbeitet: [map] wandelt seinen Inhalt, falls vorhanden, in eine Antwort 200 um; [orElseGet] liefert die Antwort, die verwendet wird, wenn das [Optional] leer ist – hier eine Antwort 404 mit einer Meldung. [ResponseEntity::ok] ist eine Methodenreferenz: eine kürzere Schreibweise für das Lambda [p -> ResponseEntity.ok(p)]. Der Typ [ResponseEntity<?>] ([?]: beliebiger Body-Typ) erlaubt es der Action, ein Produkt oder ein Dictionary zurückzugeben; die Schreibweise [.<ResponseEntity<?>>map(...)] teilt dem Compiler diesen Typ mit, den er nicht selbst ableiten kann.

2.6.5. Der Controller ClientsController

package example06.clients;

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

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import example06.products.Product;
import example06.products.ProductsService;

// ein einziger Konstruktor: Spring verwendet ihn für die Injektion, ganz ohne weiteren Hinweis.
// Das Feld [final] ist daher zwangsläufig initialisiert.
@RestController
@RequestMapping("/clients")
public class ClientsController {

    private final ProductsService productsService;

    public ClientsController(ProductsService productsService) {
        this.productsService = productsService;
    }

    // der Inhalt des Warenkorbs, als JSON zurückgegeben
    public record Cart(String client, int items, BigDecimal total) {
    }

    @GetMapping("/cart")
    public Cart cart() {
        List<Product> products = productsService.findAll();
        // die Summe der Preise: map (transformieren), dann reduce (akkumulieren)
        BigDecimal total = products.stream().map(Product::price).reduce(BigDecimal.ZERO, BigDecimal::add);
        return new Cart("Jean Martin", products.size(), total);
    }
}
  • Zeilen 19–23: [ClientsController] erhält denselben Service wie [ProductsController]. Die Klasse hat nur einen Konstruktor: [Spring] verwendet ihn ohne weitere Angaben für die Injektion. Das ist die empfohlene Form der Injektion und die im gesamten Dokument verwendete;
  • Zeilen 26–27: ein verschachtelter Record, der die JSON-Antwort beschreibt;
  • Zeile 33: die Berechnung der Summe. [map] wandelt den Stream der Produkte in einen Stream der Preise um ([Product::price] ist ein Verweis auf die Zugriffsmethode [price()] des Records), dann akkumuliert [reduce] sie, ausgehend von null ([BigDecimal.ZERO]) und indem es sie paarweise addiert ([BigDecimal::add]).

2.6.6. Beans deklarieren

[Spring] kann einen Service nur bereitstellen, wenn es ihn kennt: Jeder Service muss als Bean deklariert werden. Controller werden über ihre Annotation [@RestController] deklariert, die bei der Komponentensuche erkannt wird (siehe Beispiel 01). Die Klasse [InMemoryProductsService] hingegen hat keine Annotation: Sie wird in der Datei [products/ProductsConfig.java] deklariert:

package example06.products;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

// eine KONFIGURATIONSklasse: ihre @Bean-Methoden erzeugen Objekte, die Spring
// verwaltet ("Beans") und denen bereitstellt, die sie benötigen. Sie bündelt
// die Deklarationen des Teils "Produkte" der Anwendung.
@Configuration
public class ProductsConfig {

    // "wenn ein ProductsService angefordert wird, DIESES Objekt bereitstellen"; standardmäßig ist
    // eine Bean ein Singleton: eine einzige Instanz, von allen Anfragen gemeinsam genutzt
    @Bean
    public ProductsService productsService() {
        return new InMemoryProductsService();
    }
}
  • Zeile 9: Die Annotation [@Configuration] kennzeichnet die Klasse als Konfigurationsklasse; auch sie wird bei der Komponentensuche gefunden, und [Spring] führt beim Start ihre mit [@Bean] annotierten Methoden aus. Sie bündelt die Deklarationen für den Teil „Produkte“ der Anwendung;
  • Zeilen 14–17: Eine Methode, die mit [@Bean] annotiert ist, erzeugt eine Bean. Das bedeutet: „Wenn eine Klasse einen [ProductsService] anfordert, stelle ihr das Objekt bereit, das diese Methode zurückgibt.“ Der Methodenname ([productsService]) wird zum Namen der Bean.

Es gibt eine weitere, kürzere Möglichkeit, eine Bean zu deklarieren: die Klasse selbst mit [@Service] (oder [@Component], wovon [@Service], [@Controller] und [@Repository] Varianten sind) zu annotieren, was die Komponentensuche genauso findet wie Controller. Würde man [@Service] vor die Klasse [InMemoryProductsService] setzen, wäre die Datei [ProductsConfig.java] überflüssig. Die Methode mit [@Bean] ist nützlich, wenn die Klasse keine Annotation tragen kann (etwa eine Klasse aus einer Bibliothek) oder wenn zur Erzeugung des Objekts Code nötig ist. Beide Formen werden später in diesem Dokument verwendet.

Standardmäßig ist eine Bean ein Singleton: [Spring] erzeugt beim Start eine einzige Instanz und stellt sie während der gesamten Laufzeit der Anwendung allen Klassen bereit, die sie anfordern. [ProductsController] und [ClientsController] erhalten somit dasselbe [InMemoryProductsService]-Objekt. Es gibt weitere Scopes: [prototype] (eine neue Instanz bei jeder Anforderung), [request] (eine Instanz pro HTTP-Anfrage), [session] ... Kapitel 6 greift dieses Thema wieder auf.

Auch Controller sind Singletons: Ein einziges [ProductsController]-Objekt bearbeitet alle Anfragen, möglicherweise gleichzeitig in mehreren Threads. Das ist ein wesentlicher Unterschied zu [ASP.NET Core MVC], das für jede Anfrage ein neues Controller-Objekt erzeugt. Ein [Spring]-Controller darf daher keine anfragespezifischen Daten in seinen Feldern speichern: Seine Felder enthalten nur die injizierten Services, deklariert als [final].

Die Klasse [Example06Application] ist dieselbe wie in den vorherigen Beispielen: Dort muss nichts registriert werden; die Komponentensuche findet die Controller und die Konfigurationsklasse in den Unterpaketen [clients] und [products].

2.6.7. Ausführung

curl -i http://localhost:5000/products
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 111

[{"id":1,"name":"pen","price":1.5},{"id":2,"name":"notebook","price":3.2},{"id":3,"name":"eraser","price":0.8}]
curl -i http://localhost:5000/products/2
1
2
3
4
HTTP/1.1 200
Content-Type: application/json

{"id":2,"name":"notebook","price":3.2}
curl -i http://localhost:5000/products/9
1
2
3
4
HTTP/1.1 404
Content-Type: application/json

{"message":"Product no. 9 not found"}
curl -i http://localhost:5000/clients/cart
1
2
3
4
5
HTTP/1.1 200
Content-Type: application/json
Content-Length: 46

{"client":"Jean Martin","items":3,"total":5.5}

Die Fallstudie ist genau so aufgebaut: schlanke Controller, die an injizierte Services delegieren, welche durch Interfaces beschrieben und als Beans deklariert werden.