Skip to content

7. El ciclo de vida de una solicitud

Entre la llegada de una solicitud y la ejecución de la acción intervienen varios tipos de objetos, cada uno con un rol específico. Ya nos hemos encontrado con algunos: el manejador de archivos estáticos, [LocaleResolver] (capítulo 5), el filtro del ejemplo 23, los resolvedores de argumentos ([HandlerMethodArgumentResolver], ejemplo 12) y [@ControllerAdvice] (ejemplo 15). Es momento de situarlos en contexto unos respecto de otros.

Hay dos capas. La primera consta del servidor ([Tomcat]) y del estándar Servlet ([Java]): un servlet es un objeto que procesa solicitudes (HTTP), y los filtros de servlet pueden envolverlo para actuar antes y después de él. La segunda capa es [Spring MVC] en sí, que es simplemente un servlet, [DispatcherServlet]: selecciona la acción, vincula sus parámetros, la ejecuta y luego renderiza la vista. Dentro de él, los interceptores pueden actuar antes y después de la acción. Mientras que [ASP.NET Core] tiene middleware y filtros (MVC), [Spring] tiene filtros de servlet e interceptores. El caso de estudio utiliza la mayoría de estos objetos:

Image

Objeto
Rol
En el caso de estudio
Filtro de servlet
Prepara la solicitud; no conoce la acción
Filtros de [Spring Security]: lee el token; acceso denegado sin una conexión
Interceptor
código antes y después de la acción; conoce la acción
(no se usa: los roles se verifican con [@PreAuthorize], véase el capítulo 8, y [CommonModel] completa el modelo)
resolvedor de argumentos
proporciona el valor de un parámetro de la acción
los de [Spring MVC]: formularios, validación, [BindingResult]
[@ExceptionHandler]
Convierte una excepción en una respuesta
sesión no válida: regreso a la página de inicio de sesión
[/error] página de error
Genera una página de respuesta de error
[ErrorController]: páginas 400, 403, 404, 500

7.1. Ejemplo 24: Pasos en el procesamiento de una solicitud

El ejemplo 24 tiene una función que calcula el cuadrado de un número y un objeto de cada tipo. Cada uno escribe una línea en la consola: esto muestra el orden en que se ejecutan. Los números indicados corresponden a los del diagrama.

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

Los archivos [pom.xml], [application.properties], y [Example24Application.java] son los de los ejemplos anteriores.

7.1.1. El filtro de servlet

El archivo [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;

// un FILTRO de servlet: ve pasar cada solicitud ANTES de Spring MVC, y la
// respuesta DESPUÉS. @Component: Spring Boot lo agrega a la cadena de filtros.
@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); // todo el resto: Spring MVC, acción, vista
        System.out.println("7. filter (after: code " + response.getStatus() + ")");
    }
}
  • líneas 15-16: un filtro, como el del ejemplo 23. [OncePerRequestFilter] es una subclase de [Spring] que implementa la interfaz [Filter] del estándar Servlet y garantiza una única ejecución por solicitud; sobrescribimos su método [doFilterInternal], que se llama en cada solicitud. Mediante [@Component], [Spring Boot] agrega el filtro a la cadena de filtros del servidor;
  • líneas 21-22: el método, la ruta y los parámetros de la solicitud. El filtro no sabe nada de la acción que procesará la solicitud: interviene antes que [Spring MVC], que todavía no la ha seleccionado;
  • línea 26: el filtro pasa la solicitud al resto de la cadena (los demás filtros y luego [DispatcherServlet]) y espera a que termine. Si no lo llamara, la solicitud se detendría allí (tendría entonces que generar la respuesta por sí mismo). El código colocado antes de esta llamada se ejecuta a la ida; el código colocado después se ejecuta a la vuelta: el filtro "envuelve" todo lo demás;
  • línea 27: en el camino de regreso, el filtro ve el código de estado de la respuesta.

7.1.2. Interceptores

Un interceptor se aplica a todas las acciones de la aplicación (véase [WebConfig] más adelante). Para que actúe solo sobre ciertas acciones, marcamos esas acciones con una anotación personalizada que el interceptor buscará. El archivo [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;

// una anotación que marca un controlador; BlockInterceptor la busca
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Block {
}
  • línea 11: [@interface] declara una anotación. Esta anotación no tiene parámetros: basta con su sola presencia;
  • línea 9: [@Target] especifica dónde puede aplicarse la anotación: en este caso, sobre un tipo (una clase);
  • línea 10: [@Retention(RetentionPolicy.RUNTIME)]: la anotación se conserva en el código compilado y sigue siendo legible durante la ejecución. Sin esto, el compilador la eliminaría y el interceptor no podría encontrarla.

El archivo [filters/Timing.java] es idéntico, salvo por el nombre. El archivo [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;

// un INTERCEPTOR: se ejecuta dentro de Spring MVC, una vez elegida la acción.
// Este decide si la acción puede ejecutarse.
public class BlockInterceptor implements HandlerInterceptor {

    // preHandle: antes de la acción; devolver false detiene allí el procesamiento
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // handler: lo que manejará la solicitud; para una acción, un HandlerMethod.
        // A diferencia del filtro, el interceptor conoce por lo tanto la acción objetivo.
        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) {
                // una respuesta de error 403 (acceso denegado), y nada más
                response.sendError(HttpServletResponse.SC_FORBIDDEN);
                return false; // ni enlace ni acción
            }
        }
        return true;
    }
}
  • línea 11: un interceptor implementa la interfaz [HandlerInterceptor] de [Spring MVC]. Sus tres métodos, [preHandle], [postHandle] y [afterCompletion], tienen una implementación predeterminada que no hace nada: solo sobrescribimos los que necesitamos;
  • línea 15: [preHandle] se ejecuta antes de la acción, e incluso antes de que se vinculen sus parámetros. Su parámetro, [handler], es lo que procesará la solicitud: para una acción, un objeto [HandlerMethod] que describe el método del controlador;
  • línea 19: a diferencia del filtro, el interceptor sí sabe a qué acción apunta. [handler instanceof HandlerMethod action] verifica el tipo del objeto y, si coincide, lo almacena en la variable [action], que es del tipo correcto. [getBeanType()] especifica la clase del controlador; [isAnnotationPresent(Block.class)] indica si lleva la anotación [@Block];
  • líneas 21-25: un interceptor rechaza la solicitud devolviendo [false]: el resto del proceso (vinculación, acción, vista) no se ejecuta. Entonces debe generar la respuesta por sí mismo: en este caso, [sendError(403)] crea una respuesta de error de "acceso denegado", cuya página generará el servidor (veremos cómo);
  • Línea 27: [true]: la solicitud continúa.

El archivo [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;

// un segundo interceptor: mide la duración del procesamiento
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);
    }

    // antes de la acción (y antes del enlace de sus parámetros)
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (concerned(handler)) {
            System.out.println("3. Timing interceptor (before)");
            // la hora de inicio, almacenada en un atributo de la solicitud (ámbito request)
            request.setAttribute(KEY, System.nanoTime());
        }
        return true;
    }

    // después de la acción, ANTES de la vista; no se invoca si la acción lanzó una excepción
    @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()) + ")");
        }
    }

    // al final de todo, DESPUÉS de la vista; siempre se invoca, con la posible excepción
    @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 + ")");
        }
    }
}
  • líneas 15-17: el interceptor solo se interesa por las acciones de los controladores anotados con [@Timing];
  • Líneas 21-28: antes de la acción, se registra la hora de inicio ([System.nanoTime()], en nanosegundos) y se almacena en un atributo de solicitud (ámbito de solicitud; véase el capítulo 6);
  • líneas 32-38: [postHandle] se ejecuta después de la acción y antes de la vista. Recibe el [ModelAndView] producido por la acción (el nombre de la vista y el modelo) y todavía puede modificarlo. No se llama si la acción lanzó una excepción;
  • líneas 42-49: [afterCompletion] se ejecuta al final de todo, después de la vista, independientemente de si todo salió bien o no: es el lugar adecuado para liberar un recurso o medir el tiempo de ejecución. Su último parámetro es la excepción, si la hubo. Línea 44: [instanceof Long start] verifica y convierte el valor del atributo en un solo paso.

7.1.3. Vinculación de parámetros

El archivo [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;

// un parámetro entero, leído de la ruta por IntegerParamResolver (vea el ejemplo 12)
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface IntegerParam {
}

Una anotación, esta vez sobre un parámetro (línea 9). El archivo [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;

// el enlace de un parámetro @IntegerParam Integer: la variable de ruta del mismo nombre,
// convertida a entero, o null si no es un entero
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) {
        // las variables de ruta ({n}...), almacenadas por Spring en un atributo de la solicitud
        @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; // la acción decidirá
        }
    }
}

Un resolvedor de argumentos, como el del ejemplo 12:

  • líneas 18-20: maneja los parámetros de tipo [Integer] anotados con [@IntegerParam];
  • líneas 27-28: [Spring MVC] ya analizó la ruta ([/square/{n}]) al seleccionar la acción; almacenó las variables de la ruta en un atributo de solicitud, en forma de un diccionario [name -> value];
  • línea 29: el valor de la variable que lleva el nombre del parámetro ([n]);
  • líneas 31-35: el valor convertido a entero, o [null] si no es un entero. Un valor no válido no detiene nada: decide la acción.

7.1.4. Manejo de excepciones

El archivo [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: convierten una excepción, lanzada por
// cualquier acción, en una respuesta (aquí, para toda la aplicación)
@ControllerAdvice
public class ErrorPageAdvice {

    // solo las IllegalStateException: las demás excepciones siguen su camino
    @ExceptionHandler(IllegalStateException.class)
    public ModelAndView error(IllegalStateException e) {
        System.out.println("x. @ExceptionHandler (" + e.getClass().getSimpleName() + ": " + e.getMessage() + ")");
        // en lugar de la página de error por defecto, nuestra vista [error], con el código 500
        ModelAndView mav = new ModelAndView("error", HttpStatus.INTERNAL_SERVER_ERROR);
        mav.addObject("code", 500);
        return mav;
    }
}
  • línea 10: [@ControllerAdvice] convierte esta clase en un complemento de todos los controladores (véase el ejemplo 15);
  • líneas 14-15: un método [@ExceptionHandler] se llama cuando una acción lanza una excepción del tipo especificado, en este caso [IllegalStateException] (o de un tipo derivado). Si se coloca en un controlador, se aplicaría solo a las acciones de ese controlador; en un [@ControllerAdvice], se aplica a toda la aplicación. Recibe la excepción como parámetro y genera la respuesta igual que lo haría una acción;
  • líneas 18-20: en lugar de la página de error predeterminada, la vista [error], con el código de estado 500. Un [ModelAndView] combina lo que una acción suele devolver en dos partes: el nombre de la vista y el modelo (y aquí, el código de estado).

Las demás excepciones no se tratan aquí: veremos más adelante qué sucede con ellas.

7.1.5. Configuración

El archivo [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;

// la configuración de Spring MVC, complementada
@Configuration
public class WebConfig implements WebMvcConfigurer {

    // Bootstrap, compartido por los ejemplos: la carpeta examples/common/bootstrap
    // se sirve bajo la URL /bootstrap/...
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/bootstrap/**")
                // "file:": una carpeta del disco, relativa a la carpeta actual. Dos
                // intentos: iniciado desde la carpeta del ejemplo, o desde [examples]
                .addResourceLocations("file:../common/bootstrap/", "file:common/bootstrap/");
    }

    // los interceptores, ejecutados en el orden en que se agregan
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new BlockInterceptor());
        registry.addInterceptor(new TimingInterceptor());
    }

    // el enlace de los parámetros @IntegerParam
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new IntegerParamResolver());
    }
}
  • líneas 30-34: los interceptores se agregan a [Spring MVC], que los ejecuta en el orden en que se agregaron (y [postHandle], [afterCompletion] en orden inverso). Se aplican a todas las acciones; podrían limitarse a ciertas rutas ([.addPathPatterns("/square/**")]), pero nuestras anotaciones son más precisas;
  • líneas 37-40: el resolvedor de argumentos, como en el ejemplo 12.

7.1.6. El controlador y la página de error

El archivo [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;

// dos anotaciones colocadas en el controlador: los interceptores las buscan
@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) {
            // un error 400: vea ErrorPageController
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
        }
        if (n == 13) {
            throw new IllegalStateException("13 brings bad luck"); // un error "inesperado"
        }
        model.addAttribute("n", n);
        model.addAttribute("square", n * n);
        return "calc/result";
    }
}
  • líneas 14-15: las dos anotaciones que buscan los interceptores;
  • línea 20: el parámetro [n], proporcionado por nuestro resolvedor;
  • líneas 22-25: un parámetro no válido: un error 400 (solicitud no válida). La [ResponseStatusException] (véase el ejemplo 21) es transformada por [Spring MVC] en una respuesta de error sin contenido;
  • líneas 26-28: un error "inesperado", para ver [@ExceptionHandler] en acción;
  • líneas 29-31: el caso normal. El archivo [templates/calc/result.html] muestra el resultado:
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>
  • Línea 2: la página usa la plantilla [templates/layout.html], como es habitual (véase el ejemplo 15): un título y [Bootstrap];
  • Línea 5: entre dos barras verticales, [|...|] es una cadena en la que [Thymeleaf] reemplaza cada aparición de [${...}] por su valor.

Queda la página de error. Cuando una solicitud da como resultado una respuesta de error (una llamada a [sendError], una [ResponseStatusException], una dirección desconocida o una excepción no controlada), el servidor no devuelve una respuesta vacía: reenvía la solicitud a la dirección [/error] para generar la página que se devolverá y, en el proceso, almacena el código de error en un atributo de solicitud. [Spring Boot] ya proporciona una acción para esta dirección: es la que hasta ahora ha generado las respuestas de error JSON (para [curl]) y la "Whitelabel Error Page" (para un navegador). El archivo [controllers/ErrorPageController.java] la reemplaza:

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;

// la página de error de la aplicación. Una respuesta de error (sendError, excepción
// no controlada) es reenviada por el servidor a la dirección /error; implementar
// ErrorController reemplaza la página de error de Spring Boot por la nuestra.
@Controller
public class ErrorPageController implements ErrorController {

    // @RequestMapping sin método HTTP: todos los métodos (GET, POST...)
    @RequestMapping("/error")
    public String error(HttpServletRequest request, HttpServletResponse response, Model model) {
        // el código de error original, almacenado por el servidor en un atributo de la solicitud
        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); // la página conserva el código de error
        model.addAttribute("code", status);
        return "error";
    }
}
  • líneas 15-16: un controlador que implementa la interfaz [ErrorController] de [Spring Boot]. Esta interfaz no tiene métodos; sirve como marcador. En cuanto un bean la implementa, [Spring Boot] elimina su propio manejador de errores;
  • línea 19: [@RequestMapping], que no especifica métodos (HTTP), acepta todos los métodos: una solicitud POST reenviada a [/error] sigue siendo una solicitud POST;
  • líneas 22-23: el código de error original, almacenado por el servidor en el atributo [RequestDispatcher.ERROR_STATUS_CODE]. [code instanceof Integer c ? c : 500]: si el atributo es un entero, su valor; de lo contrario, 500 (por ejemplo, si se solicita [/error] directamente);
  • Líneas 25-27: la página conserva el código de error, que se pasa a la vista.

El archivo [templates/error.html]:

<!doctype html>
<!--la página de error; su modelo: el código de error-->
<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: el primer caso igual al valor; *: todos los demás-->
    <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>
  • líneas 9-14: [th:switch] y [th:case]: solo se conserva la primera etiqueta [th:case] cuyo valor es igual al de [th:switch]; [*] corresponde a todo lo demás. La vista se usa tanto para [ErrorPageController] y [ErrorPageAdvice].

7.1.7. Ejecución

Cinco solicitudes: un cálculo normal (http://localhost:5000/square/7), un parámetro no válido ([/square/abc]), una solicitud bloqueada por el interceptor ([/square/7?block=1]), un error inesperado ([/square/13]) y una dirección desconocida ([/unknown]). La consola del servidor:

--- 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)

Este registro muestra:

  • el orden de los pasos en el caso normal: el filtro, los interceptores ([preHandle]) en el orden en que se agregaron, la vinculación de parámetros, la acción, [postHandle] (la vista todavía no se ha renderizado), [afterCompletion] (la vista se renderiza) y luego de nuevo el filtro, que ve el código de respuesta final;
  • el interceptor que rechaza la solicitud ([/square/7?block=1]) evita todo lo demás en [Spring MVC]: no hay segundo interceptor, ni vinculación, ni acción;
  • un parámetro no válido no impide que la acción se ejecute: la propia acción decide ([square(null)]), en este caso lanzando una [ResponseStatusException]. [Spring MVC] pasa cualquier excepción lanzada por una acción a una serie de manejadores de excepciones ([HandlerExceptionResolver]); el de [ResponseStatusException] la convierte en una respuesta de error 400 y la registra (línea [WARN ... Resolved]). Como la acción lanzó una excepción, [postHandle] no se llama; [afterCompletion] se llama, sin excepción: la excepción ya fue manejada;
  • la excepción de [/square/13] se maneja de la misma manera, mediante el resolvedor, que busca los métodos [@ExceptionHandler] (paso x). Este método genera una página completa con un código de estado 500: la solicitud termina allí, sin pasar por [/error];
  • una respuesta de error sin contenido (400, 403, 404) se convierte en una página pasándola a [/error] (paso 8). Observe que este paso ocurre después de que la solicitud regresa al filtro (paso 7): [sendError] solo marca la respuesta como un error, y es el servidor ([Tomcat]) quien, una vez completada la cadena de filtros, reenvía la solicitud a [/error]. Esta segunda pasada no atraviesa nuestro filtro: [Spring Boot] sí registra el filtro para las solicitudes reenviadas a [/error], pero [OncePerRequestFilter] las deja pasar sin ejecutarlo (este es su comportamiento predeterminado, que podría cambiarse redefiniendo su método [shouldNotFilterErrorDispatch]). En cambio, sí pasa por los interceptores, ya que es [Spring MVC] quien ejecuta la acción [/error]; pero [ErrorPageController] no lleva sus anotaciones y estos no escriben nada;
  • para una dirección desconocida, ninguna acción coincide: [Spring MVC] pasa entonces la solicitud al manejador de archivos estáticos (un [ResourceHttpRequestHandler]), que no encuentra ningún archivo y lanza una excepción [NoResourceFoundException], que un resolvedor de excepciones convierte en una respuesta de error 404 (esta vez sin ninguna línea [WARN] en el registro). Los interceptores sí fueron llamados, pero el [handler] que recibieron no es una acción ([HandlerMethod]): no escribieron nada.

Las páginas resultantes:

Image

Image

Image

Image

Verifiquemos que el código de error se conserva:

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>

Solo el [span] del caso seleccionado por [th:switch] aparece en la página.

El caso de estudio combina estos mecanismos: un manejador [ErrorController] para las páginas 400, 403, 404 y 500, al que el servidor reenvía todas las respuestas de error, incluidas las de excepciones que nadie ha manejado (la página 500, sin la pila de llamadas); y un [@ExceptionHandler] ([web/HtmlExceptionHandler.java]) para un caso específico: una sesión no válida (la cuenta se eliminó después del inicio de sesión) no muestra una página de error, sino que redirige a la página de inicio de sesión.