Hur fungerar request-livscykeln i Spring Boot?

Question

IT Interview Practice · Accepted Answer

I Spring Boot (Spring MVC) passerar en request genom **servlet-containern**, en kedja av **Filters**, den centrala **`DispatcherServlet`**, sedan **interceptors** och din **`@Controller`**, och returvärdet omvandlas till HTTP-responsen.

## Stegen

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controllern
   ▼
HandlerMapping  ── hitta @Controller-metoden
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── binda @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── din logik → returnerar object eller ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialisera till JSON eller rendera view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat lämnar över requesten till `Filter`-kedjan. Filters (inklusive Spring Security) är det yttersta lagret och kan blockera eller omsluta requesten innan MVC ser den.
2. **DispatcherServlet** — front controllern som orkestrerar allt nedanför.
3. **HandlerMapping** — avgör vilken controller-metod som hanterar URL + metod.
4. **`preHandle`** — `HandlerInterceptor`s körs före controllern (auth-kontroller, logging, tidmätning); att returnera `false` stoppar requesten.
5. **Argumentupplösning** — `@PathVariable`, `@RequestParam` och `@RequestBody` (via `HttpMessageConverter`) binds och valideras.
6. **Controller** — din `@RestController`-metod kör affärslogiken och returnerar ett object eller `ResponseEntity`.
7. **`postHandle`**, sedan serialiseras returvärdet av en `HttpMessageConverter` (JSON via Jackson) eller så renderas en view av en `ViewResolver`.
8. **`afterCompletion`** körs efter att responsen har committats; `@ExceptionHandler`/`@ControllerAdvice` hanterar undantag längs vägen.

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

// 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. serialiseras till JSON
    }
}
```

## Varför det är viktigt

Springs livscykel har två distinkta utökningslager som intervjuare älskar att undersöka: **Filters** (servlet-nivå, ytterst — där Spring Security bor) och **Interceptors** (Spring MVC-nivå, runt controllern). Att känna till ordningen — filters, DispatcherServlet, mapping, interceptor `preHandle`, argumentbindning, controller, meddelandekonvertering, `afterCompletion` — talar om var du ska placera autentisering kontra logging, varför ett Security-filter avvisar en request innan någon interceptor eller controller körs, och hur `@ControllerAdvice` centraliserar undantagshantering genom hela flödet.

Stegen

Varför det är viktigt

Relaterade frågor