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:

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




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.