Hogyan működik a kérés életciklusa a Spring Bootban?

Question

IT Interview Practice · Accepted Answer

A Spring Bootban (Spring MVC) egy kérés áthalad a **servlet containeren**, egy **Filter**-láncon, a központi **`DispatcherServlet`**-en, majd az **interceptorokon** és a te **`@Controller`**-eden, és a visszatérési érték HTTP response-zá alakul.

## A szakaszok

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── a front controller
   ▼
HandlerMapping  ── megkeresi a @Controller metódust
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bindeli a @RequestBody / @PathVariable / @RequestParam-ot
   ▼
Controller method  ── a logikád → object-et vagy ResponseEntity-t ad vissza
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── JSON-ba szerializál vagy view-t renderel
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filterek** — a Tomcat átadja a kérést a `Filter`-láncnak. A filterek (a Spring Securityt is beleértve) a legkülső réteg, és blokkolhatják vagy becsomagolhatják a kérést, mielőtt az MVC meglátná.
2. **DispatcherServlet** — a front controller, amely mindent koordinál alatta.
3. **HandlerMapping** — feloldja, melyik controller metódus kezeli az URL + method párost.
4. **`preHandle`** — a `HandlerInterceptor`-ok a controller előtt futnak (auth ellenőrzések, logging, időmérés); `false` visszaadása megállítja a kérést.
5. **Argument feloldás** — a `@PathVariable`, `@RequestParam` és `@RequestBody` (a `HttpMessageConverter`-en át) bindelődik és validálódik.
6. **Controller** — a te `@RestController` metódusod lefuttatja az üzleti logikát, és egy object-et vagy `ResponseEntity`-t ad vissza.
7. **`postHandle`**, majd a visszatérési értéket egy `HttpMessageConverter` szerializálja (JSON a Jacksonon át), vagy egy `ViewResolver` rendereli a view-t.
8. **`afterCompletion`** a response commitolása után fut; az `@ExceptionHandler`/`@ControllerAdvice` út közben kezeli a kivételeket.

```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 = rövidre zár
    }
}

// 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. JSON-ba szerializálva
    }
}
```

## Miért fontos

A Spring életciklusának két különálló bővítési rétege van, amelyeket az interjúztatók imádnak feszegetni: a **Filterek** (servlet-szintű, legkülső — ahol a Spring Security él) és az **Interceptorok** (Spring MVC-szintű, a controller körül). A sorrend ismerete — filterek, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message konverzió, `afterCompletion` — megmondja, hova tedd az authentikációt a logginghoz képest, miért utasít el egy Security filter egy kérést bármely interceptor vagy controller lefutása előtt, és hogyan központosítja a `@ControllerAdvice` a kivételkezelést az egész folyamaton át.

A szakaszok

Miért fontos

Kapcsolódó kérdések