Kako deluje življenjski cikel zahteve v Spring Boot?

Question

IT Interview Practice · Accepted Answer

V Spring Boot (Spring MVC) zahteva potuje skozi **servlet container**, verigo **Filtrov**, osrednji **`DispatcherServlet`**, nato skozi **interceptorje** in tvoj **`@Controller`**, vrnjena vrednost pa se pretvori v HTTP-odgovor.

## Faze

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── poišči metodo @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── tvoja logika → vrne object ali ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializiraj v JSON ali izriši view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat preda zahtevo verigi `Filter`. Filtri (vključno s Spring Security) so najbolj zunanja plast in lahko blokirajo ali ovijejo zahtevo, preden jo vidi MVC.
2. **DispatcherServlet** — front controller, ki orkestrira vse spodaj.
3. **HandlerMapping** — razreši, katera metoda controllerja obravnava URL + metodo.
4. **`preHandle`** — `HandlerInterceptor`-ji tečejo pred controllerjem (preverjanja auth, logging, merjenje časa); vrnitev `false` ustavi zahtevo.
5. **Razreševanje argumentov** — `@PathVariable`, `@RequestParam` in `@RequestBody` (prek `HttpMessageConverter`) se povežejo (bind) in validirajo.
6. **Controller** — tvoja metoda `@RestController` izvede poslovno logiko in vrne objekt ali `ResponseEntity`.
7. **`postHandle`**, nato vrnjeno vrednost serializira `HttpMessageConverter` (JSON prek Jackson) ali pa view izriše `ViewResolver`.
8. **`afterCompletion`** teče po tem, ko je odgovor potrjen (commit); `@ExceptionHandler`/`@ControllerAdvice` obravnavata izjeme na poti.

```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 = prekini verigo
    }
}

// 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. serializirano v JSON
    }
}
```

## Zakaj je to pomembno

Življenjski cikel Springa ima dve ločeni razširitveni plasti, ki ju izpraševalci radi preverjajo: **Filtri** (na ravni servleta, najbolj zunanji — kjer živi Spring Security) in **Interceptorji** (na ravni Spring MVC, okoli controllerja). Poznavanje vrstnega reda — filtri, DispatcherServlet, mapping, interceptorjev `preHandle`, povezovanje argumentov, controller, pretvorba sporočila, `afterCompletion` — ti pove, kam postaviti avtentikacijo v primerjavi z logging, zakaj Security filter zavrne zahtevo, preden steče kateri koli interceptor ali controller, in kako `@ControllerAdvice` centralizira obravnavo izjem po celotnem toku.

Faze

Zakaj je to pomembno

Povezana vprašanja