Skip to content

7. O ciclo de vida de uma requisição

Entre a chegada de uma requisição e a execução da action, vários tipos de objetos intervêm, cada um com um papel específico. Já encontramos alguns deles: o tratador de arquivos estáticos, o [LocaleResolver] (Capítulo 5), o filtro do Exemplo 23, os argument resolvers ([HandlerMethodArgumentResolver], Exemplo 12) e [@ControllerAdvice] (Exemplo 15). É hora de situá-los uns em relação aos outros.

Há duas camadas. A primeira é formada pelo servidor ([Tomcat]) e pelo padrão Servlet ([Java]): um servlet é um objeto que processa requisições (HTTP), e os filtros servlet podem envolvê-lo para agir antes e depois dele. A segunda camada é o próprio [Spring MVC] , que nada mais é que um servlet, [DispatcherServlet]: ele seleciona a action, vincula seus parâmetros, a executa e, em seguida, renderiza a view. Dentro dele, interceptors podem agir antes e depois da action. Enquanto o [ASP.NET Core] tem middleware e filtros (MVC), [Spring] tem filtros servlet e interceptors. O estudo de caso usa a maioria desses objetos:

Image

Objeto
Papel
No estudo de caso
Filtro servlet
Prepara a requisição; não conhece a action
Filtros do [Spring Security]: lê o token; acesso negado sem conexão
Interceptor
código antes e depois da action; conhece a action
(não usado: os papéis são verificados por [@PreAuthorize], veja o Capítulo 8, e [CommonModel] completa o modelo)
argument resolver
fornece o valor de um parâmetro da action
os do [Spring MVC]: formulários, validação, [BindingResult]
[@ExceptionHandler]
Converte uma exceção em uma resposta
sessão inválida: retorno à página de login
Página de erro [/error]
Gera uma página de resposta de erro
[ErrorController]: páginas 400, 403, 404, 500

7.1. Exemplo 24: Etapas do processamento de uma requisição

O Exemplo 24 tem uma função que calcula o quadrado de um número e um objeto de cada tipo. Cada um escreve uma linha no console: isso mostra a ordem em que são executados. Os números listados correspondem aos do 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

Os arquivos [pom.xml], [application.properties], e [Example24Application.java] são os dos exemplos anteriores.

7.1.1. O filtro servlet

O arquivo [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;

// um FILTRO de servlet: ele vê cada requisição passar ANTES do Spring MVC, e a
// resposta DEPOIS. @Component: o Spring Boot o adiciona à cadeia 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 o restante: Spring MVC, ação, view
        System.out.println("7. filter (after: code " + response.getStatus() + ")");
    }
}
  • linhas 15–16: um filtro, como o do Exemplo 23. [OncePerRequestFilter] é uma subclasse do [Spring] que implementa a interface [Filter] do padrão Servlet, garantindo uma única execução por requisição; sobrescrevemos seu método [doFilterInternal], que é chamado a cada requisição. Com [@Component], o [Spring Boot] adiciona o filtro à cadeia de filtros do servidor;
  • linhas 21–22: o método, o caminho e os parâmetros da requisição. O filtro não sabe nada sobre a action que processará a requisição: ele intervém antes do [Spring MVC], que ainda não a selecionou;
  • linha 26: o filtro passa a requisição para o restante da cadeia (os demais filtros e, depois, o [DispatcherServlet]) e aguarda o término. Se ele não a chamasse, a requisição pararia ali (ele teria então de gerar a resposta por conta própria). O código colocado antes dessa chamada é executado na ida; o código colocado depois dela é executado na volta: o filtro “envolve” todo o resto;
  • linha 27: no caminho de volta, o filtro vê o código de status da resposta.

7.1.2. Interceptors

Um interceptor é aplicado a todas as actions da aplicação (veja [WebConfig] abaixo). Para garantir que ele atue apenas em certas actions, marcamos essas actions com uma anotação personalizada que o interceptor procurará. O arquivo [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;

// uma anotação que marca um controller; BlockInterceptor a procura
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Block {
}
  • linha 11: [@interface] declara uma anotação. Essa anotação não tem parâmetros: sua simples presença é suficiente;
  • linha 9: [@Target] especifica onde a anotação pode ser aplicada: neste caso, em um tipo (uma classe);
  • linha 10: [@Retention(RetentionPolicy.RUNTIME)]: a anotação é preservada no código compilado e permanece legível durante a execução. Sem isso, o compilador a removeria, e o interceptor não conseguiria encontrá-la.

O arquivo [filters/Timing.java] é idêntico, exceto pelo nome. O arquivo [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;

// um INTERCEPTOR: ele é executado dentro do Spring MVC, depois que a ação é escolhida.
// Este decide se a ação pode ser executada.
public class BlockInterceptor implements HandlerInterceptor {

    // preHandle: antes da ação; retornar false interrompe o processamento ali
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // handler: o que tratará a requisição; para uma ação, um HandlerMethod.
        // Ao contrário do filtro, o interceptor conhece, portanto, a ação visada.
        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) {
                // uma resposta de erro 403 (acesso negado), e nada mais
                response.sendError(HttpServletResponse.SC_FORBIDDEN);
                return false; // nem binding nem ação
            }
        }
        return true;
    }
}
  • linha 11: um interceptor implementa a interface [HandlerInterceptor] do [Spring MVC]. Seus três métodos—[preHandle], [postHandle] e [afterCompletion]—têm uma implementação padrão que não faz nada: sobrescrevemos apenas os que precisamos;
  • linha 15: [preHandle] é executado antes da action, e mesmo antes de seus parâmetros serem vinculados. Seu parâmetro, [handler], é o que processará a requisição: para uma action, um objeto [HandlerMethod], que descreve o método do controller;
  • linha 19: ao contrário do filtro, o interceptor sabe, portanto, qual action está sendo visada. [handler instanceof HandlerMethod action] verifica o tipo do objeto e, se corresponder, o armazena na variável [action], que tem o tipo correto. [getBeanType()] indica a classe do controller; [isAnnotationPresent(Block.class)] informa se ela carrega a anotação [@Block];
  • linhas 21–25: um interceptor rejeita a requisição retornando [false]: o restante do processo (vinculação, action, view) não é executado. Ele deve então gerar a resposta por conta própria: neste caso, [sendError(403)] cria uma resposta de erro de “acesso negado”, para a qual o servidor gerará a página (veremos como);
  • linha 27: [true]: a requisição continua.

O arquivo [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;

// um segundo interceptor: ele mede a duração do processamento
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 da ação (e antes do binding de seus parâmetros)
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (concerned(handler)) {
            System.out.println("3. Timing interceptor (before)");
            // a hora de início, armazenada em um atributo de requisição (escopo de requisição)
            request.setAttribute(KEY, System.nanoTime());
        }
        return true;
    }

    // após a ação, ANTES da view; não é chamado se a ação lançou uma exceção
    @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()) + ")");
        }
    }

    // no final de tudo, DEPOIS da view; sempre chamado, com a eventual exceção
    @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 + ")");
        }
    }
}
  • linhas 15–17: o interceptor só se interessa pelas actions de controllers anotados com [@Timing];
  • linhas 21–28: antes da action, o horário de início ([System.nanoTime()], em nanossegundos) é registrado e armazenado em um atributo da requisição (escopo de requisição; veja o Capítulo 6);
  • linhas 32–38: [postHandle] é executado depois da action e antes da view. Ele recebe o [ModelAndView] produzido pela action (o nome da view e o modelo) e ainda pode modificá-lo. Não é chamado se a action lançou uma exceção;
  • linhas 42–49: [afterCompletion] é executado bem no final, depois da view, independentemente de tudo ter corrido bem ou não: é o lugar certo para liberar um recurso ou medir o tempo de execução. Seu último parâmetro é a exceção, se houver. Linha 44: [instanceof Long start] verifica e converte o valor do atributo em uma única etapa.

7.1.3. Vinculação de parâmetros

O arquivo [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;

// um parâmetro inteiro, lido do caminho por IntegerParamResolver (veja o exemplo 12)
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface IntegerParam {
}

Uma anotação, desta vez em um parâmetro (linha 9). O arquivo [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;

// o binding de um parâmetro @IntegerParam Integer: a variável de caminho de mesmo nome,
// convertida em inteiro, ou null se não for um inteiro
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) {
        // as variáveis de caminho ({n}...), armazenadas pelo Spring em um atributo de requisição
        @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; // a ação decidirá
        }
    }
}

Um argument resolver, como o do Exemplo 12:

  • linhas 18–20: ele trata os parâmetros do tipo [Integer] anotados com [@IntegerParam];
  • linhas 27–28: o [Spring MVC] já analisou o caminho ([/square/{n}]) ao selecionar a action; ele armazenou as variáveis de caminho em um atributo da requisição, na forma de um dicionário [name -> value];
  • linha 29: o valor da variável com o nome do parâmetro ([n]);
  • linhas 31–35: o valor convertido em inteiro, ou [null] se não for um inteiro. Um valor inválido não interrompe nada: quem decide é a action.

7.1.4. Tratamento de exceções

O arquivo [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: transformam uma exceção, lançada por
// qualquer ação, em uma resposta (aqui, para toda a aplicação)
@ControllerAdvice
public class ErrorPageAdvice {

    // somente as IllegalStateException: as outras exceções seguem seu caminho
    @ExceptionHandler(IllegalStateException.class)
    public ModelAndView error(IllegalStateException e) {
        System.out.println("x. @ExceptionHandler (" + e.getClass().getSimpleName() + ": " + e.getMessage() + ")");
        // em vez da página de erro padrão, nossa view [error], com o código 500
        ModelAndView mav = new ModelAndView("error", HttpStatus.INTERNAL_SERVER_ERROR);
        mav.addObject("code", 500);
        return mav;
    }
}
  • linha 10: [@ControllerAdvice] faz desta classe um complemento de todos os controllers (veja o Exemplo 15);
  • linhas 14–15: um método [@ExceptionHandler] é chamado quando uma action lança uma exceção do tipo especificado, neste caso [IllegalStateException] (ou de um tipo derivado). Se estiver em um controller, aplica-se apenas às actions desse controller; em um [@ControllerAdvice], aplica-se a toda a aplicação. Ele recebe a exceção como parâmetro e gera a resposta exatamente como uma action;
  • linhas 18–20: em vez da página de erro padrão, a view [error], com código de status 500. Um [ModelAndView] combina o que uma action normalmente retorna em duas partes: o nome da view e o modelo (e aqui, o código de status).

As demais exceções não são tratadas aqui: veremos mais adiante o que acontece com elas.

7.1.5. Configuração

O arquivo [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;

// a configuração do Spring MVC, complementada
@Configuration
public class WebConfig implements WebMvcConfigurer {

    // Bootstrap, compartilhado pelos exemplos: a pasta examples/common/bootstrap
    // é servida na URL /bootstrap/...
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/bootstrap/**")
                // "file:": uma pasta do disco, relativa à pasta atual. Duas
                // tentativas: iniciado a partir da pasta do exemplo, ou a partir de [examples]
                .addResourceLocations("file:../common/bootstrap/", "file:common/bootstrap/");
    }

    // os interceptors, executados na ordem em que são adicionados
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new BlockInterceptor());
        registry.addInterceptor(new TimingInterceptor());
    }

    // o binding dos parâmetros @IntegerParam
    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
        resolvers.add(new IntegerParamResolver());
    }
}
  • linhas 30–34: os interceptors são adicionados ao [Spring MVC], que os executa na ordem em que foram adicionados (e [postHandle], [afterCompletion] na ordem inversa). Eles se aplicam a todas as actions; poderiam ser limitados a certos caminhos ([.addPathPatterns("/square/**")]), mas nossas anotações são mais precisas;
  • linhas 37–40: o argument resolver, como no Exemplo 12.

7.1.6. O controller e a página de erro

O arquivo [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;

// duas anotações colocadas no controller: os interceptors as procuram
@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) {
            // um erro 400: veja ErrorPageController
            throw new ResponseStatusException(HttpStatus.BAD_REQUEST);
        }
        if (n == 13) {
            throw new IllegalStateException("13 brings bad luck"); // um erro "inesperado"
        }
        model.addAttribute("n", n);
        model.addAttribute("square", n * n);
        return "calc/result";
    }
}
  • linhas 14–15: as duas anotações que os interceptors procuram;
  • linha 20: o parâmetro [n], fornecido por nosso resolver;
  • linhas 22–25: um parâmetro inválido: um erro 400 (requisição inválida). A [ResponseStatusException] (veja o Exemplo 21) é transformada pelo [Spring MVC] em uma resposta de erro sem conteúdo;
  • linhas 26–28: um erro “inesperado”, para ver o [@ExceptionHandler] em ação;
  • linhas 29–31: o caso normal. O arquivo [templates/calc/result.html] exibe o 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>
  • Linha 2: a página usa o template [templates/layout.html], como esperado (veja o Exemplo 15): um título e o [Bootstrap];
  • Linha 5: entre duas barras verticais, [|...|] é uma string na qual o [Thymeleaf] substitui cada ocorrência de [${...}] pelo seu valor.

Resta a página de erro. Quando uma requisição resulta em uma resposta de erro (uma chamada a [sendError], uma [ResponseStatusException], um endereço desconhecido ou uma exceção não tratada), o servidor não retorna uma resposta vazia: ele encaminha a requisição para o endereço [/error] para gerar a página a ser retornada e, nesse processo, armazena o código de erro em um atributo da requisição. [Spring Boot] já fornece uma action para esse endereço: é ela que, até agora, gerou as respostas de erro JSON (para o [curl]) e a “Whitelabel Error Page” (para um navegador). O arquivo [controllers/ErrorPageController.java] a substitui:

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;

// a página de erro da aplicação. Uma resposta de erro (sendError, exceção não
// tratada) é encaminhada pelo servidor ao endereço /error; implementar
// ErrorController substitui a página de erro do Spring Boot pela nossa.
@Controller
public class ErrorPageController implements ErrorController {

    // @RequestMapping sem método HTTP: todos os métodos (GET, POST...)
    @RequestMapping("/error")
    public String error(HttpServletRequest request, HttpServletResponse response, Model model) {
        // o código de erro original, armazenado pelo servidor em um atributo de requisição
        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); // a página mantém o código de erro
        model.addAttribute("code", status);
        return "error";
    }
}
  • linhas 15–16: um controller que implementa a interface [ErrorController] do [Spring Boot]. Essa interface não tem métodos; serve como marcador. Assim que um bean a implementa, o [Spring Boot] remove seu próprio tratador de erros;
  • linha 19: [@RequestMapping], que não especifica métodos (HTTP), aceita todos os métodos: uma requisição POST encaminhada para [/error] continua sendo uma requisição POST;
  • linhas 22–23: o código de erro original, armazenado pelo servidor no atributo [RequestDispatcher.ERROR_STATUS_CODE]. [code instanceof Integer c ? c : 500]: se o atributo for um inteiro, seu valor; caso contrário, 500 (por exemplo, se [/error] for solicitado diretamente);
  • Linhas 25–27: a página guarda o código de erro, que é passado para a view.

O arquivo [templates/error.html]:

<!doctype html>
<!--/* a página de erro; seu modelo: o código de erro */-->
<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: o primeiro case igual ao valor; *: todos os outros */-->
    <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>
  • linhas 9–14: [th:switch] e [th:case]: apenas a primeira tag [th:case] cujo valor é igual ao de [th:switch] é mantida; [*] corresponde a todo o resto. A view é usada tanto para [ErrorPageController] and [ErrorPageAdvice].

7.1.7. Execução

Cinco requisições: um cálculo normal (http://localhost:5000/square/7), um parâmetro inválido ([/square/abc]), uma requisição bloqueada pelo interceptor ([/square/7?block=1]), um erro inesperado ([/square/13]) e um endereço desconhecido ([/unknown]). O console do 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 log mostra:

  • a ordem das etapas no caso normal: o filtro, os interceptors ([preHandle]) na ordem em que foram adicionados, a vinculação dos parâmetros, a action, [postHandle] (a view ainda não foi renderizada), [afterCompletion] (a view é renderizada) e, depois, o filtro novamente, que vê o código de resposta final;
  • o interceptor que rejeita a requisição ([/square/7?block=1]) contorna todo o resto do [Spring MVC]: nenhum segundo interceptor, nenhuma vinculação, nenhuma action;
  • um parâmetro inválido não impede a execução da action: é a própria action que decide ([square(null)]), neste caso lançando uma [ResponseStatusException]. [Spring MVC] passa qualquer exceção lançada por uma action a uma série de tratadores de exceção ([HandlerExceptionResolver]); o de [ResponseStatusException] a converte em uma resposta de erro 400 e a registra no log (linha [WARN ... Resolved]). Como a action lançou uma exceção, [postHandle] não é chamado; [afterCompletion] é chamado, sem exceção: ela já foi tratada;
  • a exceção de [/square/13] é tratada da mesma forma, pelo resolver, que procura os métodos [@ExceptionHandler] (etapa x). Esse método gera uma página completa com código de status 500: a requisição termina ali, sem passar por [/error];
  • uma resposta de erro sem conteúdo (400, 403, 404) é convertida em página ao ser passada para [/error] (etapa 8). Observe que essa etapa ocorre depois que a requisição retorna ao filtro (etapa 7): [sendError] apenas marca a resposta como erro, e é o servidor ([Tomcat]) que, concluída a cadeia de filtros, encaminha a requisição para [/error]. Essa segunda passagem não passa pelo nosso filtro: [Spring Boot] registra de fato o filtro para requisições encaminhadas a [/error], mas [OncePerRequestFilter] deixa-as passar sem executá-lo (esse é seu comportamento padrão, que poderia ser alterado redefinindo seu método [shouldNotFilterErrorDispatch]). Em compensação, ela passa pelos interceptors, já que é o [Spring MVC] que executa a action [/error]; mas [ErrorPageController] não carrega suas anotações, e eles não escrevem nada;
  • para um endereço desconhecido, nenhuma action corresponde: o [Spring MVC] passa então a requisição ao tratador de arquivos estáticos (um [ResourceHttpRequestHandler]), que não encontra nenhum arquivo e lança uma exceção [NoResourceFoundException], convertida por um exception resolver em uma resposta de erro 404 (desta vez sem linha [WARN] no log). Os interceptors foram de fato chamados, mas o [handler] que receberam não é uma action ([HandlerMethod]): eles não escreveram nada.

As páginas resultantes:

Image

Image

Image

Image

Vamos verificar se o código de erro é preservado:

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>

Somente o [span] do caso selecionado por [th:switch] aparece na página.

O estudo de caso combina esses mecanismos: um tratador [ErrorController] para as páginas 400, 403, 404 e 500, para o qual o servidor encaminha todas as respostas de erro, inclusive as de exceções que ninguém tratou (a página 500, sem a pilha de chamadas); e um [@ExceptionHandler] ([web/HtmlExceptionHandler.java]) para um caso específico: uma sessão inválida (a conta foi excluída após o login) não exibe uma página de erro, mas redireciona para a página de login.