Bagaimana cara kerja request lifecycle di Spring Boot?

Question

IT Interview Practice · Accepted Answer

Di Spring Boot (Spring MVC), sebuah request melewati **servlet container**, sebuah rantai **Filter**, **`DispatcherServlet`** pusat, lalu **interceptor** dan **`@Controller`** Anda, dan nilai kembalian diubah menjadi HTTP response.

## Tahapannya

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── temukan method @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── logika Anda → mengembalikan object atau ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialisasi ke JSON atau render view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filter** — Tomcat menyerahkan request ke rantai `Filter`. Filter (termasuk Spring Security) adalah lapisan terluar dan bisa memblokir atau membungkus request sebelum MVC melihatnya.
2. **DispatcherServlet** — front controller yang mengorkestrasi semua yang di bawahnya.
3. **HandlerMapping** — menentukan method controller mana yang menangani URL + method.
4. **`preHandle`** — `HandlerInterceptor` berjalan sebelum controller (pemeriksaan auth, logging, timing); mengembalikan `false` menghentikan request.
5. **Resolusi argument** — `@PathVariable`, `@RequestParam`, dan `@RequestBody` (via `HttpMessageConverter`) di-bind dan divalidasi.
6. **Controller** — method `@RestController` Anda menjalankan logika bisnis dan mengembalikan sebuah object atau `ResponseEntity`.
7. **`postHandle`**, lalu nilai kembalian diserialisasi oleh sebuah `HttpMessageConverter` (JSON via Jackson) atau sebuah view di-render oleh sebuah `ViewResolver`.
8. **`afterCompletion`** berjalan setelah response di-commit; `@ExceptionHandler`/`@ControllerAdvice` menangani exception sepanjang jalan.

```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 = memutus jalur
    }
}

// 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. diserialisasi ke JSON
    }
}
```

## Mengapa ini penting

Lifecycle Spring punya dua lapisan ekstensi berbeda yang suka digali pewawancara: **Filter** (level servlet, terluar — tempat Spring Security tinggal) dan **Interceptor** (level Spring MVC, di sekitar controller). Mengetahui urutannya — filter, DispatcherServlet, mapping, interceptor `preHandle`, binding argument, controller, konversi message, `afterCompletion` — memberi tahu Anda di mana menempatkan autentikasi vs. logging, kenapa sebuah Security filter menolak sebuah request sebelum interceptor atau controller mana pun berjalan, dan bagaimana `@ControllerAdvice` memusatkan penanganan exception di seluruh alur.

Tahapannya

Mengapa ini penting

Pertanyaan terkait