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:
2.1.1. Der Einstiegspunkt: Example01Application.java
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
- 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):
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:
![]()
Dann mit [curl]. Die Option [-i] zeigt auch die HTTP-Header der Antwort an (hier geben wir nur einige davon wieder):
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]):
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:
[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:
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]:
- 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:

Die Datei [controllers/FirstController.java]:
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 behandelnURL-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:
Um eine POST-Anfrage zu senden, verwenden Sie die Option [-X POST] von [curl]:
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:
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].
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):

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]:
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:
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:
Eine Exception-Meldung kann einem Angreifer tatsächlich Informationen liefern. Die Fehlerdetails werden in die Serverkonsole geschrieben (hier geben wir nur den Anfang wieder):
Im Browser ist der Unterschied zwischen [text/plain] und [text/html] sichtbar:


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]:
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:
Mit der Option [-L] folgt [curl] der Weiterleitung, genau wie es ein Browser täte. Wir sehen dann die beiden aufeinanderfolgenden Antworten:
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]):
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:
![]()
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]:
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:
(die Option [-A] von [curl] setzt den Header [User-Agent], der den Browser identifiziert)
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:

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:
2.6.1. Das Produkt
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
- 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
- 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
- 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
- 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:
- 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
Die Fallstudie ist genau so aufgebaut: schlanke Controller, die an injizierte Services delegieren, welche durch Interfaces beschrieben und als Beans deklariert werden.