7. Der Lebenszyklus einer Anfrage
Zwischen dem Eintreffen einer Anfrage und der Ausführung der Action sind mehrere Arten von Objekten beteiligt, jedes mit einer bestimmten Rolle. Einigen davon sind wir bereits begegnet: dem Handler für statische Dateien, [LocaleResolver] (Kapitel 5), dem Filter aus Beispiel 23, den Argument-Resolvern ([HandlerMethodArgumentResolver], Beispiel 12) und [@ControllerAdvice] (Beispiel 15). Es ist an der Zeit, sie zueinander in Beziehung zu setzen.
Es gibt zwei Schichten. Die erste besteht aus dem Server ([Tomcat]) und dem Servlet-Standard ([Java]): Ein Servlet ist ein Objekt, das (HTTP-)Anfragen verarbeitet, und Servlet-Filter können es umhüllen, um davor und danach zu agieren. Die zweite Schicht ist [Spring MVC] selbst, das einfach ein Servlet ist, nämlich [DispatcherServlet]: Es wählt die Action aus, bindet ihre Parameter, führt sie aus und rendert dann die View. Innerhalb davon können Interceptors vor und nach der Action agieren. Während [ASP.NET Core] über Middleware und Filter (MVC) verfügt, [Spring] über Servlet-Filter und Interceptors verfügt. Die Fallstudie nutzt die meisten dieser Objekte:

Objekt | Rolle | In der Fallstudie |
Servlet-Filter | Bereitet die Anfrage vor; kennt die Action nicht | [Spring Security]-Filter: lesen das Token; ohne Anmeldung wird der Zugriff verweigert |
Interceptor | Code vor und nach der Action; kennt die Action | (nicht verwendet: Rollen werden von [@PreAuthorize] geprüft, siehe Kapitel 8, und [CommonModel] ergänzt das Modell) |
Argument-Resolver | liefert den Wert eines Action-Parameters | die von [Spring MVC]: Formulare, Validierung, [BindingResult] |
[@ExceptionHandler] | Wandelt eine Exception in eine Antwort um | ungültige Session: Rückkehr zur Anmeldeseite |
[/error]-Fehlerseite | Erzeugt eine Fehlerantwortseite | [ErrorController]: Seiten 400, 403, 404, 500 |
7.1. Beispiel 24: Schritte bei der Verarbeitung einer Anfrage
Beispiel 24 hat eine Funktion, die das Quadrat einer Zahl berechnet, und ein Objekt jeder Art. Jedes schreibt eine Zeile auf die Konsole: Dies zeigt die Reihenfolge, in der sie ausgeführt werden. Die aufgeführten Nummern entsprechen denen im Diagramm.
Die Dateien [pom.xml], [application.properties], und [Example24Application.java] stammen aus den vorherigen Beispielen.
7.1.1. Der Servlet-Filter
Die Datei [filters/LoggerFilter.java]:
- Zeilen 15–16: ein Filter wie der in Beispiel 23. [OncePerRequestFilter] ist eine Unterklasse von [Spring] , die die Schnittstelle [Filter] des Servlet-Standards implementiert und eine einmalige Ausführung pro Anfrage sicherstellt; wir überschreiben ihre Methode [doFilterInternal], die bei jeder Anfrage aufgerufen wird. Mit [@Component] fügt [Spring Boot] den Filter der Filterkette des Servers hinzu;
- Zeilen 21–22: die Methode, der Pfad und die Anfrageparameter. Der Filter weiß nichts über die Action, die die Anfrage verarbeiten wird: Er greift vor [Spring MVC] ein, das sie noch nicht ausgewählt hat;
- Zeile 26: Der Filter übergibt die Anfrage an den Rest der Kette (die anderen Filter, dann [DispatcherServlet]) und wartet darauf, dass sie abgeschlossen ist. Würde er sie nicht aufrufen, würde die Anfrage dort enden (er müsste dann die Antwort selbst erzeugen). Der Code vor diesem Aufruf wird auf dem Hinweg ausgeführt, der Code danach auf dem Rückweg: Der Filter „umhüllt“ alles andere;
- Zeile 27: auf dem Rückweg sieht der Filter den Statuscode der Antwort.
7.1.2. Interceptors
Ein Interceptor wird auf alle Actions der Anwendung angewendet (siehe [WebConfig] weiter unten). Damit er nur auf bestimmte Actions wirkt, markieren wir diese mit einer eigenen Annotation , nach der der Interceptor sucht. Die Datei [filters/Block.java]:
- Zeile 11: [@interface] deklariert eine Annotation. Diese Annotation hat keine Parameter: Ihr bloßes Vorhandensein genügt;
- Zeile 9: [@Target] legt fest, wo die Annotation angewendet werden kann: hier auf einem Typ (einer Klasse);
- Zeile 10: [@Retention(RetentionPolicy.RUNTIME)]: Die Annotation bleibt im kompilierten Code erhalten und ist zur Laufzeit lesbar. Ohne dies würde der Compiler sie entfernen, und der Interceptor könnte sie nicht finden.
Die Datei [filters/Timing.java] ist bis auf den Namen identisch. Die Datei [filters/BlockInterceptor.java]:
- Zeile 11: Ein Interceptor implementiert die Schnittstelle [HandlerInterceptor] von [Spring MVC]. Seine drei Methoden – [preHandle], [postHandle] und [afterCompletion] – haben eine Standardimplementierung, die nichts tut: Wir überschreiben nur diejenigen, die wir benötigen;
- Zeile 15: [preHandle] wird vor der Action ausgeführt, sogar noch bevor ihre Parameter gebunden werden. Sein Parameter [handler], ist das, was die Anfrage verarbeiten wird: bei einer Action ein [HandlerMethod]-Objekt, das die Methode des Controllers beschreibt;
- Zeile 19: Anders als der Filter weiß der Interceptor also, auf welche Action er zielt. [handler instanceof HandlerMethod action] prüft den Typ des Objekts und speichert es, falls er passt, in der Variablen [action], die den richtigen Typ hat. [getBeanType()] gibt die Klasse des Controllers an; [isAnnotationPresent(Block.class)] zeigt an, ob er die Annotation [@Block] trägt;
- Zeilen 21–25: Ein Interceptor lehnt die Anfrage ab, indem er [false] zurückgibt: Der Rest des Ablaufs (Binding, Action, View) wird nicht ausgeführt. Er muss dann die Antwort selbst erzeugen: Hier erstellt [sendError(403)] eine Fehlerantwort „Zugriff verweigert“, für die der Server die Seite erzeugt (wir werden sehen, wie);
- Zeile 27: [true]: Die Anfrage wird fortgesetzt.
Die Datei [filters/TimingInterceptor.java]:
- Zeilen 15–17: Der Interceptor interessiert sich nur für die Actions von Controllern, die mit [@Timing] annotiert sind;
- Zeilen 21–28: Vor der Action wird die Startzeit ([System.nanoTime()], in Nanosekunden) erfasst und in einem Request-Attribut gespeichert (Request-Scope; siehe Kapitel 6);
- Zeilen 32–38: [postHandle] läuft nach der Action und vor der View. Sie erhält das von der Action erzeugte [ModelAndView] (den Namen der View und das Modell) und kann es noch ändern. Sie wird nicht aufgerufen, wenn die Action eine Exception ausgelöst hat;
- Zeilen 42–49: [afterCompletion] läuft ganz am Ende, nach der View, unabhängig davon, ob alles gut gegangen ist oder nicht: Dies ist der richtige Ort, um eine Ressource freizugeben oder die Ausführungszeit zu messen. Ihr letzter Parameter ist die Exception, falls vorhanden. Zeile 44: [instanceof Long start] prüft und konvertiert den Wert des Attributs in einem einzigen Schritt.
7.1.3. Parameter-Binding
Die Datei [filters/IntegerParam.java]:
Eine Annotation, diesmal auf einem Parameter (Zeile 9). Die Datei [filters/IntegerParamResolver.java]:
Ein Argument-Resolver, wie der in Beispiel 12:
- Zeilen 18–20: Er behandelt Parameter vom Typ [Integer] mit der Annotation [@IntegerParam];
- Zeilen 27–28: [Spring MVC] hat den Pfad ([/square/{n}]) bei der Auswahl der Action bereits analysiert; es hat die Pfadvariablen in einem Request-Attribut in Form eines Dictionarys [name -> value] abgelegt;
- Zeile 29: der Wert der Variablen, die wie der Parameter heißt ([n]);
- Zeilen 31–35: der in eine ganze Zahl umgewandelte Wert oder [null] , wenn er keine ganze Zahl ist. Ein ungültiger Wert hält nichts auf: Die Action entscheidet.
7.1.4. Exception-Behandlung
Die Datei [filters/ErrorPageAdvice.java]:
- Zeile 10: [@ControllerAdvice] macht diese Klasse zu einer Ergänzung aller Controller (siehe Beispiel 15);
- Zeilen 14–15: Eine [@ExceptionHandler]-Methode wird aufgerufen, wenn eine Action eine Exception des angegebenen Typs auslöst, hier [IllegalStateException] (oder eines abgeleiteten Typs). In einem Controller platziert, würde sie nur für die Actions dieses Controllers gelten; in einem [@ControllerAdvice] gilt sie für die gesamte Anwendung. Sie erhält die Exception als Parameter und erzeugt die Antwort genau wie eine Action;
- Zeilen 18–20: Statt der Standard-Fehlerseite die View [error] mit dem Statuscode 500. Ein [ModelAndView] fasst zusammen, was eine Action üblicherweise in zwei Teilen zurückgibt: den Namen der View und das Modell (und hier den Statuscode).
Die anderen Exceptions werden hier nicht behandelt: Was mit ihnen geschieht, sehen wir später.
7.1.5. Konfiguration
Die Datei [config/WebConfig.java]:
- Zeilen 30–34: Die Interceptors werden zu [Spring MVC] hinzugefügt, das sie in der Reihenfolge ausführt, in der sie hinzugefügt wurden (und [postHandle], [afterCompletion] in umgekehrter Reihenfolge). Sie gelten für alle Actions; sie ließen sich auf bestimmte Pfade beschränken ([.addPathPatterns("/square/**")]), aber unsere Annotationen sind präziser;
- Zeilen 37–40: der Argument-Resolver, wie in Beispiel 12.
7.1.6. Der Controller und die Fehlerseite
Die Datei [controllers/CalcController.java]:
- Zeilen 14–15: die beiden Annotationen, nach denen die Interceptors suchen;
- Zeile 20: der Parameter [n], bereitgestellt von unserem Resolver;
- Zeilen 22–25: ein ungültiger Parameter: ein Fehler 400 (ungültige Anfrage). Die [ResponseStatusException] (siehe Beispiel 21) wird von [Spring MVC] in eine Fehlerantwort ohne Inhalt umgewandelt;
- Zeilen 26–28: ein „unerwarteter“ Fehler, um [@ExceptionHandler] in Aktion zu sehen;
- Zeilen 29–31: der Normalfall. Die Datei [templates/calc/result.html] zeigt das Ergebnis an:
- Zeile 2: Die Seite verwendet das Template [templates/layout.html] wie erwartet (siehe Beispiel 15): einen Titel und [Bootstrap];
- Zeile 5: Zwischen zwei senkrechten Strichen ist [|...|] eine Zeichenkette, in der [Thymeleaf] jedes Vorkommen von [${...}] durch seinen Wert ersetzt.
Bleibt die Fehlerseite. Wenn eine Anfrage in einer Fehlerantwort (einem Aufruf von [sendError], einer [ResponseStatusException], einer unbekannten Adresse oder einer unbehandelten Exception) endet, gibt der Server keine leere Antwort zurück: Er leitet die Anfrage an die Adresse [/error] weiter, um die zurückzugebende Seite zu erzeugen, und speichert dabei den Fehlercode in einem Request-Attribut. [Spring Boot] stellt für diese Adresse bereits eine Action bereit: Sie hat bisher die JSON-Fehlerantworten (für [curl]) und die „Whitelabel Error Page“ (für einen Browser) erzeugt. Die Datei [controllers/ErrorPageController.java] ersetzt sie:
- Zeilen 15–16: ein Controller, der die Schnittstelle [ErrorController] von [Spring Boot] implementiert. Diese Schnittstelle hat keine Methoden; sie dient als Markierung. Sobald ein Bean sie implementiert, entfernt [Spring Boot] seinen eigenen Fehler-Handler;
- Zeile 19: [@RequestMapping], das keine Methoden (HTTP) angibt, akzeptiert alle Methoden: Eine an [/error] weitergeleitete POST-Anfrage bleibt eine POST-Anfrage;
- Zeilen 22–23: der ursprüngliche Fehlercode, vom Server im Attribut [RequestDispatcher.ERROR_STATUS_CODE] gespeichert. [code instanceof Integer c ? c : 500]: Wenn das Attribut eine ganze Zahl ist, deren Wert; andernfalls 500 (zum Beispiel, wenn [/error] direkt aufgerufen wird);
- Zeilen 25–27: Die Seite behält den Fehlercode bei und übergibt ihn an die View.
Die Datei [templates/error.html]:
- Zeilen 9–14: [th:switch] und [th:case]: Nur das erste Tag, [th:case], dessen Wert gleich dem von [th:switch] ist, wird beibehalten; [*] entspricht allem anderen. Die View wird sowohl für [ErrorPageController] als auch [ErrorPageAdvice] verwendet.
7.1.7. Ausführung
Fünf Anfragen: eine normale Berechnung (http://localhost:5000/square/7), ein ungültiger Parameter ([/square/abc]), eine vom Interceptor blockierte Anfrage ([/square/7?block=1]), ein unerwarteter Fehler ([/square/13]) und eine unbekannte Adresse ([/unknown]). Die Serverkonsole:
Dieses Protokoll zeigt:
- die Reihenfolge der Schritte im Normalfall: der Filter, die Interceptors ([preHandle]) in der Reihenfolge ihres Hinzufügens, das Parameter-Binding, die Action, [postHandle] (die View ist noch nicht gerendert), [afterCompletion] (die View ist gerendert) und dann erneut der Filter, der den endgültigen Antwortcode sieht;
- der Interceptor, der die Anfrage ablehnt ([/square/7?block=1]), umgeht alles andere in [Spring MVC]: kein zweiter Interceptor, kein Binding, keine Action;
- Ein ungültiger Parameter verhindert die Ausführung der Action nicht: Die Action selbst entscheidet ([square(null)]), hier durch Auslösen einer [ResponseStatusException]. [Spring MVC] übergibt jede von einer Action ausgelöste Exception an eine Reihe von Exception-Handlern ([HandlerExceptionResolver]); derjenige der [ResponseStatusException] wandelt sie in eine Fehlerantwort 400 um und protokolliert sie (Zeile [WARN ... Resolved]). Da die Action eine Exception ausgelöst hat, wird [postHandle] nicht aufgerufen; [afterCompletion] wird ohne Exception aufgerufen: Die Exception wurde bereits behandelt;
- die Exception von [/square/13] wird auf dieselbe Weise vom Resolver behandelt, der nach den [@ExceptionHandler]-Methoden sucht (Schritt x). Diese Methode erzeugt eine vollständige Seite mit dem Statuscode 500: Die Anfrage endet dort, ohne über [/error] zu laufen;
- eine Fehlerantwort ohne Inhalt (400, 403, 404) wird in eine Seite umgewandelt, indem sie an [/error] weitergegeben wird (Schritt 8). Beachten Sie, dass dieser Schritt nach der Rückkehr der Anfrage zum Filter erfolgt (Schritt 7): [sendError] markiert die Antwort lediglich als Fehler, und es ist der Server ([Tomcat]), der die Anfrage nach Abschluss der Filterkette an [/error] weiterleitet. Dieser zweite Durchlauf geht nicht durch unseren Filter: [Spring Boot] registriert den Filter zwar für Anfragen, die an [/error] weitergeleitet werden, aber [OncePerRequestFilter] lässt sie passieren, ohne ihn auszuführen (dies ist sein Standardverhalten, das sich durch Überschreiben seiner Methode [shouldNotFilterErrorDispatch] ändern ließe). Er durchläuft jedoch die Interceptors, da es [Spring MVC] ist, das die Action [/error] ausführt; aber [ErrorPageController] trägt deren Annotationen nicht, und sie schreiben nichts;
- Bei einer unbekannten Adresse passt keine Action: [Spring MVC] übergibt die Anfrage dann an den Handler für statische Dateien (einen [ResourceHttpRequestHandler]), der keine Datei findet und eine [NoResourceFoundException]-Exception auslöst, die von einem Exception-Resolver in eine Fehlerantwort 404 umgewandelt wird (diesmal ohne [WARN]-Zeile im Protokoll). Die Interceptors wurden zwar aufgerufen, aber der [handler], den sie erhielten, ist keine Action ([HandlerMethod]): Sie haben nichts geschrieben.
Die resultierenden Seiten:




Prüfen wir, ob der Fehlercode erhalten bleibt:
Nur das [span] des von [th:switch] ausgewählten Falls erscheint auf der Seite.
Die Fallstudie kombiniert diese Mechanismen: einen [ErrorController]-Handler für die Seiten 400, 403, 404 und 500, an den der Server alle Fehlerantworten weiterleitet, einschließlich der Exceptions, die niemand behandelt hat (die Seite 500, ohne den Call Stack); und einen [@ExceptionHandler] ([web/HtmlExceptionHandler.java]) für einen Sonderfall: Eine ungültige Session (das Konto wurde nach der Anmeldung gelöscht) zeigt keine Fehlerseite an, sondern leitet zur Anmeldeseite um.