Skip to content

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:

Image

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.

24-lifecycle/
├── src/main/java/example24/
│   ├── config/
│   │   └── WebConfig.java
│   ├── controllers/
│   │   ├── CalcController.java
│   │   └── ErrorPageController.java
│   ├── filters/
│   │   ├── Block.java
│   │   ├── BlockInterceptor.java
│   │   ├── Timing.java
│   │   ├── TimingInterceptor.java
│   │   ├── IntegerParam.java
│   │   ├── IntegerParamResolver.java
│   │   ├── LoggerFilter.java
│   │   └── ErrorPageAdvice.java
│   └── Example24Application.java
├── src/main/resources/
│   ├── templates/
│   │   ├── calc/
│   │   │   └── result.html
│   │   ├── error.html
│   │   └── layout.html
│   └── application.properties
└── pom.xml

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]:

package example24.filters;

import java.io.IOException;

import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

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

// ein Servlet-FILTER: er sieht jede Anfrage VOR Spring MVC vorbeikommen und die
// Antwort NACH Spring MVC. @Component: Spring Boot fügt ihn der Filterkette hinzu.
@Component
public class LoggerFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain next)
            throws ServletException, IOException {
        String requestLine = request.getMethod() + " " + request.getRequestURI()
                + (request.getQueryString() == null ? "" : "?" + request.getQueryString());
        System.out.println();
        System.out.println("--- " + requestLine);
        System.out.println("1. filter (before)");
        next.doFilter(request, response); // der ganze Rest: Spring MVC, Action, View
        System.out.println("7. filter (after: code " + response.getStatus() + ")");
    }
}
  • 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]:

package example24.filters;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// eine Annotation, die einen Controller markiert; BlockInterceptor sucht nach ihr
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Block {
}
  • 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]:

package example24.filters;

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;

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

// ein INTERCEPTOR: er läuft innerhalb von Spring MVC, sobald die Action gewählt ist.
// Dieser entscheidet, ob die Action ausgeführt werden darf.
public class BlockInterceptor implements HandlerInterceptor {

    // preHandle: vor der Action; die Rückgabe von false beendet die Verarbeitung an dieser Stelle
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // handler: was die Anfrage bearbeiten wird; bei einer Action ein HandlerMethod.
        // Anders als der Filter kennt der Interceptor also die anvisierte Action.
        if (handler instanceof HandlerMethod action && action.getBeanType().isAnnotationPresent(Block.class)) {
            System.out.println("2. Block interceptor (targeted action: " + action.getMethod().getName() + ")");
            if (request.getParameter("block") != null) {
                // eine Fehlerantwort 403 (Zugriff verweigert) und sonst nichts
                response.sendError(HttpServletResponse.SC_FORBIDDEN);
                return false; // weder Binding noch Action
            }
        }
        return true;
    }
}
  • 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]:

package example24.filters;

import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

// ein zweiter Interceptor: er misst die Dauer der Verarbeitung
public class TimingInterceptor implements HandlerInterceptor {

    private static final String KEY = "timing";

    private static boolean concerned(Object handler) {
        return handler instanceof HandlerMethod action && action.getBeanType().isAnnotationPresent(Timing.class);
    }

    // vor der Action (und vor dem Binding ihrer Parameter)
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (concerned(handler)) {
            System.out.println("3. Timing interceptor (before)");
            // die Startzeit, in einem Request-Attribut gespeichert (Request-Scope)
            request.setAttribute(KEY, System.nanoTime());
        }
        return true;
    }

    // nach der Action, VOR der View; wird nicht aufgerufen, wenn die Action eine Exception geworfen hat
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView mav) {
        if (concerned(handler)) {
            System.out.println("6a. Timing interceptor (after the action; chosen view: "
                    + (mav == null ? null : mav.getViewName()) + ")");
        }
    }

    // ganz am Ende, NACH der View; wird immer aufgerufen, mit der eventuellen Exception
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception exception) {
        if (concerned(handler) && request.getAttribute(KEY) instanceof Long start) {
            long ms = (System.nanoTime() - start) / 1_000_000;
            String outcome = exception == null ? "" : ", exception " + exception.getClass().getSimpleName();
            System.out.println("6b. Timing interceptor (end, " + ms + " ms" + outcome + ")");
        }
    }
}
  • 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]:

package example24.filters;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// ein ganzzahliger Parameter, vom IntegerParamResolver aus dem Pfad gelesen (siehe Beispiel 12)
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface IntegerParam {
}

Eine Annotation, diesmal auf einem Parameter (Zeile 9). Die Datei [filters/IntegerParamResolver.java]:

package example24.filters;

import java.util.Map;

import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import org.springframework.web.servlet.HandlerMapping;

// das Binding eines Parameters @IntegerParam Integer: die gleichnamige Pfadvariable,
// in eine ganze Zahl konvertiert, oder null, wenn sie keine ganze Zahl ist
public class IntegerParamResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(IntegerParam.class) && parameter.getParameterType() == Integer.class;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
            NativeWebRequest request, WebDataBinderFactory binderFactory) {
        // die Pfadvariablen ({n}...), von Spring in einem Request-Attribut gespeichert
        @SuppressWarnings("unchecked")
        Map<String, String> variables = (Map<String, String>) request.getAttribute(
                HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE, RequestAttributes.SCOPE_REQUEST);
        String value = variables == null ? null : variables.get(parameter.getParameterName());
        System.out.println("4. parameter binding (received value: \"" + value + "\")");
        try {
            return Integer.valueOf(value);
        } catch (NumberFormatException e) {
            return null; // die Action wird entscheiden
        }
    }
}

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]:

package example24.filters;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.servlet.ModelAndView;

// @ControllerAdvice + @ExceptionHandler: eine von einer beliebigen Action geworfene
// Exception in eine Antwort umwandeln (hier für die gesamte Anwendung)
@ControllerAdvice
public class ErrorPageAdvice {

    // nur die IllegalStateException: die anderen Exceptions nehmen ihren Lauf
    @ExceptionHandler(IllegalStateException.class)
    public ModelAndView error(IllegalStateException e) {
        System.out.println("x. @ExceptionHandler (" + e.getClass().getSimpleName() + ": " + e.getMessage() + ")");
        // statt der Standard-Fehlerseite unsere View [error], mit dem Code 500
        ModelAndView mav = new ModelAndView("error", HttpStatus.INTERNAL_SERVER_ERROR);
        mav.addObject("code", 500);
        return mav;
    }
}
  • 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]:

package example24.config;

import java.util.List;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import example24.filters.BlockInterceptor;
import example24.filters.TimingInterceptor;
import example24.filters.IntegerParamResolver;

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

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

    // die Interceptors, in der Reihenfolge ausgeführt, in der sie hinzugefügt werden
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new BlockInterceptor());
        registry.addInterceptor(new TimingInterceptor());
    }

    // das Binding der Parameter @IntegerParam
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new IntegerParamResolver());
    }
}
  • 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]:

package example24.controllers;

import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.server.ResponseStatusException;

import example24.filters.Block;
import example24.filters.Timing;
import example24.filters.IntegerParam;

// zwei am Controller gesetzte Annotationen: die Interceptors suchen nach ihnen
@Block
@Timing
@Controller
public class CalcController {

    @GetMapping("/square/{n}")
    public String square(@IntegerParam Integer n, Model model) {
        System.out.println("5. action square(" + n + ")");
        if (n == null) {
            // ein Fehler 400: siehe ErrorPageController
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
        }
        if (n == 13) {
            throw new IllegalStateException("13 brings bad luck"); // ein "unerwarteter" Fehler
        }
        model.addAttribute("n", n);
        model.addAttribute("square", n * n);
        return "calc/result";
    }
}
  • 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:
1
2
3
4
5
6
7
8
<!doctype html>
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <h1 class="h4" th:text="|${n} squared = ${square}|">7 squared = 49</h1>
</main>
</body>
</html>
  • 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:

package example24.controllers;

import org.springframework.boot.webmvc.error.ErrorController;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

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

// die Fehlerseite der Anwendung. Eine Fehlerantwort (sendError, unbehandelte
// Exception) wird vom Server an die Adresse /error weitergeleitet; die Implementierung
// von ErrorController ersetzt die Fehlerseite von Spring Boot durch unsere.
@Controller
public class ErrorPageController implements ErrorController {

    // @RequestMapping ohne HTTP-Methode: alle Methoden (GET, POST ...)
    @RequestMapping("/error")
    public String error(HttpServletRequest request, HttpServletResponse response, Model model) {
        // der ursprüngliche Fehlercode, vom Server in einem Request-Attribut gespeichert
        Object code = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
        int status = code instanceof Integer c ? c : 500;
        System.out.println("8. error page " + status + " (request forwarded to /error)");
        response.setStatus(status); // die Seite behält den Fehlercode
        model.addAttribute("code", status);
        return "error";
    }
}
  • 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]:

<!doctype html>
<!--/* die Fehlerseite; ihr Modell: der Fehlercode */-->
<html xmlns:th="http://www.thymeleaf.org" th:replace="~{layout :: page(~{::main})}">
<body>
<main>
  <div class="alert alert-danger">
    <h1 class="h4" th:text="|Error ${code}|">Error 500</h1>
    <!--/* th:switch / th:case: der erste Fall, der dem Wert entspricht; *: alle anderen */-->
    <p class="mb-0" th:switch="${code}">
      <span th:case="400">Bad request.</span>
      <span th:case="403">Access denied.</span>
      <span th:case="404">Page not found.</span>
      <span th:case="*">Internal server error.</span>
    </p>
  </div>
</main>
</body>
</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:

--- GET /square/7
1. filter (before)
2. Block interceptor (targeted action: square)
3. Timing interceptor (before)
4. parameter binding (received value: "7")
5. action square(7)
6a. Timing interceptor (after the action; chosen view: calc/result)
6b. Timing interceptor (end, 5 ms)
7. filter (after: code 200)

--- GET /square/abc
1. filter (before)
2. Block interceptor (targeted action: square)
3. Timing interceptor (before)
4. parameter binding (received value: "abc")
5. action square(null)
2026-09-25T18:48:16.146+02:00  WARN 23271 --- [nio-5000-exec-3] .w.s.m.a.ResponseStatusExceptionResolver : Resolved [org.springframework.web.server.ResponseStatusException: 400 BAD_REQUEST]
6b. Timing interceptor (end, 1 ms)
7. filter (after: code 400)
8. error page 400 (request forwarded to /error)

--- GET /square/7?block=1
1. filter (before)
2. Block interceptor (targeted action: square)
7. filter (after: code 403)
8. error page 403 (request forwarded to /error)

--- GET /square/13
1. filter (before)
2. Block interceptor (targeted action: square)
3. Timing interceptor (before)
4. parameter binding (received value: "13")
5. action square(13)
x. @ExceptionHandler (IllegalStateException: 13 brings bad luck)
2026-09-25T18:48:16.174+02:00  WARN 23271 --- [nio-5000-exec-5] .m.m.a.ExceptionHandlerExceptionResolver : Resolved [java.lang.IllegalStateException: 13 brings bad luck]
6b. Timing interceptor (end, 5 ms)
7. filter (after: code 500)

--- GET /unknown
1. filter (before)
7. filter (after: code 404)
8. error page 404 (request forwarded to /error)

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:

Image

Image

Image

Image

Prüfen wir, ob der Fehlercode erhalten bleibt:

curl -i "http://localhost:5000/square/7?block=1"
HTTP/1.1 403
Content-Type: text/html;charset=UTF-8

<!doctype html>

<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Lifecycle</title>
  <link rel="stylesheet" href="/bootstrap/css/bootstrap.min.css">
</head>
<body>
  <div class="container py-3">
    <main>
  <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>

    <p class="mb-0">

      <span>Access denied.</span>


    </p>
  </div>
</main>
  </div>
</body>
</html>

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.