Kepiye cara kerja request lifecycle ing Spring Boot?

Question

IT Interview Practice · Accepted Answer

Ing Spring Boot (Spring MVC), sawijining request ngliwati **servlet container**, sawijining rantai **Filter**, **`DispatcherServlet`** pusat, banjur **interceptor** lan **`@Controller`** sampeyan, lan nilai bali diowahi dadi HTTP response.

## Tahap-tahape

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

1. **Container + filter** — Tomcat masrahake request menyang rantai `Filter`. Filter (kalebu Spring Security) yaiku lapisan paling njaba lan bisa mblokir utawa mbungkus request sadurunge MVC ndeleng.
2. **DispatcherServlet** — front controller sing ngatur kabeh ing ngisore.
3. **HandlerMapping** — nemtokake method controller endi sing nangani URL + method.
4. **`preHandle`** — `HandlerInterceptor` mlaku sadurunge controller (mriksa auth, logging, timing); mbalekake `false` bakal nyetop request.
5. **Resolusi argument** — `@PathVariable`, `@RequestParam`, lan `@RequestBody` (liwat `HttpMessageConverter`) di-bind lan divalidasi.
6. **Controller** — method `@RestController` sampeyan nglakokake logika bisnis lan mbalekake sawijining object utawa `ResponseEntity`.
7. **`postHandle`**, banjur nilai bali diserialisasi dening sawijining `HttpMessageConverter` (JSON liwat Jackson) utawa sawijining view dirender dening sawijining `ViewResolver`.
8. **`afterCompletion`** mlaku sawise response di-commit; `@ExceptionHandler`/`@ControllerAdvice` nangani exception sadawane dalan.

```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 = medhot dalan
    }
}

// 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 menyang JSON
    }
}
```

## Kenapa iki penting

Lifecycle Spring duwe rong lapisan ekstensi sing beda sing seneng didhudhah dening pewawancara: **Filter** (level servlet, paling njaba — panggonane Spring Security) lan **Interceptor** (level Spring MVC, ngubengi controller). Ngerti urutane — filter, DispatcherServlet, mapping, interceptor `preHandle`, binding argument, controller, konversi message, `afterCompletion` — ngandhani sampeyan ngendi kudu nyelehake autentikasi vs. logging, kenapa sawijining Security filter nolak sawijining request sadurunge interceptor utawa controller apa wae mlaku, lan kepiye `@ControllerAdvice` musatake panangan exception ing saindhenging alur.

Tahap-tahape

Kenapa iki penting

Pitakon sing gegandhengan