Cum funcționează ciclul de viață al unei cereri în Spring Boot?

Question

IT Interview Practice · Accepted Answer

În Spring Boot (Spring MVC), o cerere trece prin **servlet container**, un lanț de **Filters**, **`DispatcherServlet`**-ul central, apoi prin **interceptors** și **`@Controller`**-ul tău, iar valoarea returnată este convertită în răspunsul HTTP.

## Etapele

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller-ul
   ▼
HandlerMapping  ── găsește metoda @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── logica ta → returnează object sau ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializează în JSON sau randează view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat predă cererea lanțului de `Filter`. Filtrele (inclusiv Spring Security) sunt stratul cel mai exterior și pot bloca sau înveli cererea înainte ca MVC să o vadă.
2. **DispatcherServlet** — front controller-ul care orchestrează tot ce e dedesubt.
3. **HandlerMapping** — determină care metodă de controller gestionează URL-ul + metoda.
4. **`preHandle`** — `HandlerInterceptor`-ele rulează înainte de controller (verificări auth, logging, măsurarea timpului); returnarea lui `false` oprește cererea.
5. **Rezolvarea argumentelor** — `@PathVariable`, `@RequestParam` și `@RequestBody` (prin `HttpMessageConverter`) sunt legate (bind) și validate.
6. **Controller** — metoda ta `@RestController` rulează logica de business și returnează un obiect sau un `ResponseEntity`.
7. **`postHandle`**, apoi valoarea returnată este serializată de un `HttpMessageConverter` (JSON prin Jackson) sau un view este randat de un `ViewResolver`.
8. **`afterCompletion`** rulează după ce răspunsul este confirmat (commit); `@ExceptionHandler`/`@ControllerAdvice` gestionează excepțiile pe parcurs.

```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 = oprește lanțul
    }
}

// 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. serializat în JSON
    }
}
```

## De ce contează

Ciclul de viață al Spring are două straturi de extensie distincte pe care intervievatorii adoră să le exploreze: **Filters** (la nivel de servlet, cele mai exterioare — unde se află Spring Security) și **Interceptors** (la nivel de Spring MVC, în jurul controller-ului). Cunoașterea ordinii — filters, DispatcherServlet, mapping, `preHandle`-ul interceptorului, binding-ul argumentelor, controller, conversia mesajului, `afterCompletion` — îți spune unde să pui autentificarea față de logging, de ce un filtru Security respinge o cerere înainte ca vreun interceptor sau controller să ruleze, și cum `@ControllerAdvice` centralizează gestionarea excepțiilor în tot fluxul.

Etapele

De ce contează

Întrebări conexe