Kako funkcionira životni ciklus zahtjeva u Spring Bootu?

Question

IT Interview Practice · Accepted Answer

U Spring Bootu (Spring MVC) zahtjev prolazi kroz **servlet container**, lanac **Filtera**, središnji **`DispatcherServlet`**, zatim **interceptore** i tvoj **`@Controller`**, a povratna vrijednost se pretvara u HTTP response.

## Faze

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── pronađi @Controller metodu
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bindaj @RequestBody / @PathVariable / @RequestParam
   ▼
Controller metoda  ── tvoja logika → vraća object ili ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serijaliziraj u JSON ili renderiraj view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ klijent
```

1. **Container + filteri** — Tomcat predaje zahtjev lancu `Filter`. Filteri (uključujući Spring Security) su najvanjskiji sloj i mogu blokirati ili omotati zahtjev prije nego što ga MVC vidi.
2. **DispatcherServlet** — front controller koji orkestrira sve ispod.
3. **HandlerMapping** — razrješava koja controller metoda obrađuje URL + method.
4. **`preHandle`** — `HandlerInterceptor`i se izvršavaju prije controllera (provjere autha, logging, mjerenje vremena); vraćanje `false` zaustavlja zahtjev.
5. **Argument resolution** — `@PathVariable`, `@RequestParam` i `@RequestBody` (preko `HttpMessageConverter`) se bindaju i validiraju.
6. **Controller** — tvoja `@RestController` metoda izvršava poslovnu logiku i vraća object ili `ResponseEntity`.
7. **`postHandle`**, zatim se povratna vrijednost serijalizira preko `HttpMessageConverter` (JSON putem Jacksona) ili view renderira `ViewResolver`.
8. **`afterCompletion`** se izvršava nakon što je response commitan; `@ExceptionHandler`/`@ControllerAdvice` obrađuju iznimke usput.

```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 = presijeci tok
    }
}

// 6. controller
@RestController
class ItemController {
    @GetMapping("/items/{id}")            // 3. mapping
    ResponseEntity<Item> show(@PathVariable Long id) {  // 5. argument resolution
        return ResponseEntity.ok(service.find(id));      // 7. serijalizirano u JSON
    }
}
```

## Zašto je to važno

Springov životni ciklus ima dva različita sloja proširenja koja ispitivači vole propitivati: **Filtere** (na razini servleta, najvanjskije — gdje živi Spring Security) i **Interceptore** (na razini Spring MVC-a, oko controllera). Poznavanje redoslijeda — filteri, DispatcherServlet, mapping, interceptor `preHandle`, bindanje argumenata, controller, konverzija poruke, `afterCompletion` — govori ti gdje staviti autentikaciju naspram logginga, zašto Security filter odbija zahtjev prije nego što se ijedan interceptor ili controller pokrene te kako `@ControllerAdvice` centralizira obradu iznimki kroz cijeli tok.

Faze

Zašto je to važno

Povezana pitanja