Miten pyynnön elinkaari toimii Spring Bootissa?

Question

IT Interview Practice · Accepted Answer

Spring Bootissa (Spring MVC) pyyntö kulkee **servlet-containerin**, **Filter**-ketjun, keskeisen **`DispatcherServlet`**in, sitten **interceptorien** ja sinun **`@Controller`**isi läpi, ja paluuarvo muunnetaan HTTP-responseksi.

## Vaiheet

```
Servlet-container (Tomcat)
   ▼
Filter-ketju  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── etsi @Controller-metodi
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolverit  ── bindaa @RequestBody / @PathVariable / @RequestParam
   ▼
Controller-metodi  ── logiikkasi → palauttaa objektin tai ResponseEntityn
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialisoi JSONiksi tai renderöi view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filterit** — Tomcat luovuttaa pyynnön `Filter`-ketjulle. Filterit (mukaan lukien Spring Security) ovat uloin kerros ja voivat blokata tai kietoa pyynnön ennen kuin MVC näkee sen.
2. **DispatcherServlet** — front controller, joka orkestroi kaiken allaolevan.
3. **HandlerMapping** — selvittää mikä controller-metodi käsittelee URLin + methodin.
4. **`preHandle`** — `HandlerInterceptor`it ajetaan ennen controlleria (auth-tarkistukset, logging, ajanotto); `false`n palauttaminen pysäyttää pyynnön.
5. **Argument-resolvointi** — `@PathVariable`, `@RequestParam` ja `@RequestBody` (`HttpMessageConverter`in kautta) bindataan ja validoidaan.
6. **Controller** — `@RestController`-metodisi ajaa liiketoimintalogiikan ja palauttaa objektin tai `ResponseEntity`n.
7. **`postHandle`**, sitten paluuarvo serialisoidaan `HttpMessageConverter`illa (JSON Jacksonin kautta) tai view renderöidään `ViewResolver`illa.
8. **`afterCompletion`** ajetaan sen jälkeen kun response on commitattu; `@ExceptionHandler`/`@ControllerAdvice` käsittelevät poikkeukset matkan varrella.

```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 = oikaisu
    }
}

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

## Miksi se on tärkeää

Springin elinkaaressa on kaksi erillistä laajennuskerrosta, joita haastattelijat rakastavat tutkia: **Filterit** (servlet-tasolla, uloimpana — missä Spring Security elää) ja **Interceptorit** (Spring MVC -tasolla, controllerin ympärillä). Järjestyksen tunteminen — filterit, DispatcherServlet, mapping, interceptorin `preHandle`, argumenttien bindaus, controller, message-konversio, `afterCompletion` — kertoo sinulle minne autentikointi vs. logging kuuluu, miksi Security-filter hylkää pyynnön ennen kuin yksikään interceptor tai controller ajetaan, ja miten `@ControllerAdvice` keskittää poikkeusten käsittelyn koko flow'n yli.

Vaiheet

Miksi se on tärkeää

Aiheeseen liittyvät kysymykset