¿Cómo funciona el ciclo de vida de una petición en Spring Boot?

Question

IT Interview Practice · Accepted Answer

En Spring Boot (Spring MVC), una petición pasa por el **servlet container**, una cadena de **Filters**, el **`DispatcherServlet`** central, luego los **interceptors** y tu **`@Controller`**, y el valor de retorno se convierte en la respuesta HTTP.

## Las etapas

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── el front controller
   ▼
HandlerMapping  ── encuentra el método @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── tu lógica → devuelve object o ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializa a JSON o renderiza view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat entrega la petición a la cadena de `Filter`. Los Filters (incluido Spring Security) son la capa más externa y pueden bloquear o envolver la petición antes de que MVC la vea.
2. **DispatcherServlet** — el front controller que orquesta todo lo de abajo.
3. **HandlerMapping** — resuelve qué método de controlador maneja la URL + el método.
4. **`preHandle`** — los `HandlerInterceptor` se ejecutan antes del controlador (comprobaciones de auth, logging, timing); devolver `false` detiene la petición.
5. **Resolución de argumentos** — `@PathVariable`, `@RequestParam` y `@RequestBody` (vía `HttpMessageConverter`) se enlazan (bind) y validan.
6. **Controller** — tu método `@RestController` ejecuta la lógica de negocio y devuelve un object o `ResponseEntity`.
7. **`postHandle`**, luego el valor de retorno lo serializa un `HttpMessageConverter` (JSON vía Jackson) o un `ViewResolver` renderiza una view.
8. **`afterCompletion`** se ejecuta después de que la respuesta se confirma (commit); `@ExceptionHandler`/`@ControllerAdvice` manejan las excepciones por el camino.

```java
// 4/7/8. interceptor
public class TimingInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest req, HttpServletResponse res, Object h) {
        req.setAttribute("started", System.nanoTime());
        return true;                       // false = cortocircuito
    }
}

// 6. controller
@RestController
class ItemController {
    @GetMapping("/items/{id}")            // 3. mapping
    ResponseEntity<Item> show(@PathVariable Long id) {  // 5. resolución de argumentos
        return ResponseEntity.ok(service.find(id));      // 7. serializado a JSON
    }
}
```

## Por qué es importante

El ciclo de vida de Spring tiene dos capas de extensión distintas que a los entrevistadores les encanta sondear: los **Filters** (a nivel de servlet, los más externos — donde vive Spring Security) y los **Interceptors** (a nivel de Spring MVC, alrededor del controlador). Conocer el orden — filters, DispatcherServlet, mapping, interceptor `preHandle`, binding de argumentos, controlador, conversión de mensaje, `afterCompletion` — te dice dónde poner la autenticación frente al logging, por qué un filtro de Security rechaza una petición antes de que se ejecute cualquier interceptor o controlador, y cómo `@ControllerAdvice` centraliza el manejo de excepciones en todo el flujo.

Las etapas

Por qué es importante

Preguntas relacionadas