Hvordan fungerer request-livssyklusen i Spring Boot?

Question

IT Interview Practice · Accepted Answer

I Spring Boot (Spring MVC) passerer en request gjennom **servlet-containeren**, en kjede av **Filters**, den sentrale **`DispatcherServlet`**, deretter **interceptors** og din **`@Controller`**, og returverdien konverteres til HTTP-responsen.

## Stegene

```
Servlet-container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controlleren
   ▼
HandlerMapping  ── finn @Controller-metoden
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller-metode  ── logikken din → returnerer objekt eller ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialiser til JSON eller rendr view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ klient
```

1. **Container + filters** — Tomcat overleverer requesten til `Filter`-kjeden. Filters (inkludert Spring Security) er det ytterste laget og kan blokkere eller pakke inn requesten før MVC ser den.
2. **DispatcherServlet** — front controlleren som orkestrerer alt under.
3. **HandlerMapping** — bestemmer hvilken controller-metode som håndterer URL + method.
4. **`preHandle`** — `HandlerInterceptor`-er kjører før controlleren (auth-sjekker, logging, tidtaking); å returnere `false` stopper requesten.
5. **Argument resolution** — `@PathVariable`, `@RequestParam` og `@RequestBody` (via `HttpMessageConverter`) blir bundet og validert.
6. **Controller** — din `@RestController`-metode kjører forretningslogikken og returnerer et objekt eller `ResponseEntity`.
7. **`postHandle`**, deretter serialiseres returverdien av en `HttpMessageConverter` (JSON via Jackson) eller et view rendres av en `ViewResolver`.
8. **`afterCompletion`** kjører etter at responsen er committet; `@ExceptionHandler`/`@ControllerAdvice` håndterer exceptions underveis.

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

// 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. serialisert til JSON
    }
}
```

## Hvorfor det er viktig

Springs livssyklus har to distinkte utvidelseslag som intervjuere elsker å grave i: **Filters** (servlet-nivå, ytterst — der Spring Security bor) og **Interceptors** (Spring MVC-nivå, rundt controlleren). Å kjenne rekkefølgen — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument-binding, controller, message-konvertering, `afterCompletion` — forteller deg hvor du skal plassere autentisering kontra logging, hvorfor et Security-filter avviser en request før noen interceptor eller controller kjører, og hvordan `@ControllerAdvice` sentraliserer exception-håndtering på tvers av hele flyten.

Stegene

Hvorfor det er viktig

Relaterte spørsmål