Spring Boot में request lifecycle कैसे काम करता है?

Question

IT Interview Practice · Accepted Answer

Spring Boot (Spring MVC) में, एक request **servlet container**, **Filters** की एक chain, केंद्रीय **`DispatcherServlet`**, फिर **interceptors** और आपके **`@Controller`** से होकर गुजरती है, और return value को HTTP response में बदल दिया जाता है.

## चरण

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── @Controller method खोजें
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── @RequestBody / @PathVariable / @RequestParam bind करें
   ▼
Controller method  ── आपका logic → object या ResponseEntity लौटाता है
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── JSON में serialize करें या view render करें
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat request को `Filter` chain को सौंपता है. Filters (Spring Security सहित) सबसे बाहरी layer हैं और MVC के देखने से पहले request को block या wrap कर सकते हैं.
2. **DispatcherServlet** — front controller जो नीचे की हर चीज़ को orchestrate करता है.
3. **HandlerMapping** — resolve करता है कि कौन-सा controller method URL + method को handle करता है.
4. **`preHandle`** — `HandlerInterceptor`s controller से पहले चलते हैं (auth checks, logging, timing); `false` लौटाने से request रुक जाती है.
5. **Argument resolution** — `@PathVariable`, `@RequestParam`, और `@RequestBody` (`HttpMessageConverter` के माध्यम से) bind और validate किए जाते हैं.
6. **Controller** — आपका `@RestController` method business logic चलाता है और एक object या `ResponseEntity` लौटाता है.
7. **`postHandle`**, फिर return value को एक `HttpMessageConverter` (Jackson के माध्यम से JSON) द्वारा serialize किया जाता है या एक `ViewResolver` द्वारा एक view render किया जाता है.
8. **`afterCompletion`** response के commit होने के बाद चलता है; `@ExceptionHandler`/`@ControllerAdvice` रास्ते में exceptions को handle करते हैं.

```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 = short-circuit
    }
}

// 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 में serialize
    }
}
```

## यह क्यों महत्वपूर्ण है

Spring के lifecycle में दो अलग-अलग extension layers हैं जिन्हें interviewers जाँचना पसंद करते हैं: **Filters** (servlet-स्तर, सबसे बाहरी — जहाँ Spring Security रहता है) और **Interceptors** (Spring MVC-स्तर, controller के इर्द-गिर्द). क्रम जानना — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message conversion, `afterCompletion` — आपको बताता है कि authentication बनाम logging कहाँ रखें, कोई Security filter किसी request को किसी भी interceptor या controller के चलने से पहले क्यों reject करता है, और `@ControllerAdvice` पूरे flow में exception handling को कैसे केंद्रीकृत करता है.

चरण

यह क्यों महत्वपूर्ण है

संबंधित प्रश्न