Spring Boot'ta request lifecycle nasıl çalışır?

Question

IT Interview Practice · Accepted Answer

Spring Boot'ta (Spring MVC), bir request **servlet container**'dan, bir **Filters** zincirinden, merkezi **`DispatcherServlet`**'ten, sonra **interceptor**'lardan ve sizin **`@Controller`**'ınızdan geçer ve dönen değer HTTP response'a dönüştürülür.

## Aşamalar

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── @Controller metodunu bul
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── @RequestBody / @PathVariable / @RequestParam bind et
   ▼
Controller method  ── mantığınız → object veya ResponseEntity döndürür
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── JSON'a serialize et veya view render et
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat request'i `Filter` zincirine devreder. Filters (Spring Security dahil) en dıştaki katmandır ve MVC görmeden önce request'i engelleyebilir veya sarabilir.
2. **DispatcherServlet** — altındaki her şeyi düzenleyen front controller.
3. **HandlerMapping** — hangi controller metodunun URL + method'u işlediğini çözer.
4. **`preHandle`** — `HandlerInterceptor`'lar controller'dan önce çalışır (auth kontrolleri, logging, zaman ölçümü); `false` döndürmek request'i durdurur.
5. **Argument resolution** — `@PathVariable`, `@RequestParam` ve `@RequestBody` (`HttpMessageConverter` aracılığıyla) bind edilir ve validate edilir.
6. **Controller** — `@RestController` metodunuz iş mantığını çalıştırır ve bir object veya `ResponseEntity` döndürür.
7. **`postHandle`**, ardından dönen değer bir `HttpMessageConverter` (Jackson aracılığıyla JSON) tarafından serialize edilir veya bir view bir `ViewResolver` tarafından render edilir.
8. **`afterCompletion`** response commit edildikten sonra çalışır; `@ExceptionHandler`/`@ControllerAdvice` yol boyunca istisnaları işler.

```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 = kısa devre
    }
}

// 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'a serialize edilir
    }
}
```

## Neden önemli

Spring'in lifecycle'ında görüşmecilerin incelemeyi sevdiği iki ayrı genişletme katmanı vardır: **Filters** (servlet düzeyi, en dıştaki — Spring Security'nin yaşadığı yer) ve **Interceptors** (Spring MVC düzeyi, controller çevresinde). Sırayı bilmek — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message conversion, `afterCompletion` — kimlik doğrulamayı logging'e karşı nereye koyacağınızı, bir Security filter'ının herhangi bir interceptor veya controller çalışmadan önce bir request'i neden reddettiğini ve `@ControllerAdvice`'ın tüm akış boyunca istisna işlemeyi nasıl merkezileştirdiğini size söyler.

Aşamalar

Neden önemli

İlgili sorular