Jak funguje životní cyklus požadavku ve Spring Bootu?

Question

IT Interview Practice · Accepted Answer

Ve Spring Bootu (Spring MVC) prochází požadavek přes **servlet container**, řetězec **Filtrů**, centrální **`DispatcherServlet`**, poté **interceptory** a váš **`@Controller`**, a návratová hodnota se převede na HTTP odpověď.

## Fáze

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── najde metodu @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── vaše logika → vrací object nebo ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializace do JSON nebo vykreslení view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filtry** — Tomcat předá požadavek řetězci `Filter`. Filtry (včetně Spring Security) jsou nejvnější vrstva a mohou požadavek zablokovat nebo obalit dřív, než jej MVC uvidí.
2. **DispatcherServlet** — front controller, který orchestruje vše níže.
3. **HandlerMapping** — určí, která metoda controlleru zpracuje URL + metodu.
4. **`preHandle`** — `HandlerInterceptor`y běží před controllerem (kontroly autentizace, logování, měření času); vrácení `false` požadavek zastaví.
5. **Rozlišení argumentů** — `@PathVariable`, `@RequestParam` a `@RequestBody` (přes `HttpMessageConverter`) se navážou (bind) a zvalidují.
6. **Controller** — vaše metoda `@RestController` spustí byznys logiku a vrátí object nebo `ResponseEntity`.
7. **`postHandle`**, poté se návratová hodnota serializuje pomocí `HttpMessageConverter` (JSON přes Jackson) nebo se view vykreslí pomocí `ViewResolver`.
8. **`afterCompletion`** běží poté, co je odpověď potvrzena (committed); `@ExceptionHandler`/`@ControllerAdvice` zpracovávají výjimky po cestě.

```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 = zkratování
    }
}

// 6. controller
@RestController
class ItemController {
    @GetMapping("/items/{id}")            // 3. mapping
    ResponseEntity<Item> show(@PathVariable Long id) {  // 5. rozlišení argumentů
        return ResponseEntity.ok(service.find(id));      // 7. serializace do JSON
    }
}
```

## Proč je to důležité

Životní cyklus Springu má dvě odlišné rozšiřující vrstvy, které tazatelé rádi zkoumají: **Filtry** (na úrovni servletu, nejvnější — kde žije Spring Security) a **Interceptory** (na úrovni Spring MVC, kolem controlleru). Znalost pořadí — filtry, DispatcherServlet, mapping, interceptor `preHandle`, navázání argumentů, controller, konverze zprávy, `afterCompletion` — vám řekne, kam umístit autentizaci vs. logování, proč Security filtr odmítne požadavek dřív, než se spustí jakýkoli interceptor nebo controller, a jak `@ControllerAdvice` centralizuje zpracování výjimek napříč celým tokem.

Fáze

Proč je to důležité

Související otázky