Kaip veikia užklausos gyvavimo ciklas Spring Boot?

Question

IT Interview Practice · Accepted Answer

Spring Boot (Spring MVC) atveju užklausa praeina per **servlet container**, **Filter** grandinę, centrinį **`DispatcherServlet`**, tada **interceptor'ius** ir jūsų **`@Controller`**, o grąžinama reikšmė paverčiama HTTP atsakymu (response).

## Etapai

```
Servlet container (Tomcat)
   ▼
Filter grandinė  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── suranda @Controller metodą
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller metodas  ── jūsų logika → grąžina object arba ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializuoja į JSON arba renderina view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ klientas
```

1. **Container + filters** — Tomcat perduoda užklausą `Filter` grandinei. Filter'iai (įskaitant Spring Security) yra pats išorinis sluoksnis ir gali blokuoti ar apgaubti užklausą dar prieš MVC ją pamatant.
2. **DispatcherServlet** — front controller, orkestruojantis viską žemiau.
3. **HandlerMapping** — nustato, kuris controller metodas apdoroja URL + method.
4. **`preHandle`** — `HandlerInterceptor`'iai vykdomi prieš controller (auth patikros, logging, laiko matavimas); grąžinus `false` užklausa sustabdoma.
5. **Argument resolution** — `@PathVariable`, `@RequestParam` ir `@RequestBody` (per `HttpMessageConverter`) yra susiejami (bind) ir validuojami.
6. **Controller** — jūsų `@RestController` metodas vykdo verslo logiką ir grąžina object arba `ResponseEntity`.
7. **`postHandle`**, tada grąžinama reikšmė yra serializuojama `HttpMessageConverter` (JSON per Jackson) arba view renderinamas `ViewResolver`.
8. **`afterCompletion`** vykdomas po to, kai atsakymas įsipareigotas (committed); `@ExceptionHandler`/`@ControllerAdvice` apdoroja išimtis pakeliui.

```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 = nutraukti anksčiau
    }
}

// 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. serializuojama į JSON
    }
}
```

## Kodėl tai svarbu

Spring gyvavimo ciklas turi du atskirus išplėtimo sluoksnius, kuriuos interviuotojai mėgsta zonduoti: **Filter'iai** (servlet lygio, pats išorinis — kur glūdi Spring Security) ir **Interceptor'iai** (Spring MVC lygio, aplink controller). Žinant eiliškumą — filters, DispatcherServlet, mapping, interceptor `preHandle`, argumentų susiejimas (binding), controller, message konversija, `afterCompletion` — jums tampa aišku, kur dėti autentifikaciją ir kur logging, kodėl Security filter atmeta užklausą prieš įvykdant bet kokį interceptor ar controller, ir kaip `@ControllerAdvice` centralizuoja išimčių apdorojimą per visą srautą.

Etapai

Kodėl tai svarbu

Susiję klausimai