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  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
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 ਸਮੇਤ) ਸਭ ਤੋਂ ਬਾਹਰੀ ਪਰਤ ਹਨ ਅਤੇ MVC ਦੇ ਦੇਖਣ ਤੋਂ ਪਹਿਲਾਂ request ਨੂੰ block ਜਾਂ wrap ਕਰ ਸਕਦੇ ਹਨ।
2. **DispatcherServlet** — front controller ਜੋ ਹੇਠਾਂ ਸਭ ਕੁਝ orchestrate ਕਰਦਾ ਹੈ।
3. **HandlerMapping** — resolve ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ controller method URL + method ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
4. **`preHandle`** — `HandlerInterceptor` 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 ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਜਾਂ ਇੱਕ view ਨੂੰ ਇੱਕ `ViewResolver` ਦੁਆਰਾ render ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
8. **`afterCompletion`** response commit ਹੋਣ ਤੋਂ ਬਾਅਦ ਚੱਲਦਾ ਹੈ; `@ExceptionHandler`/`@ControllerAdvice` ਰਾਹ ਵਿੱਚ ਅਪਵਾਦਾਂ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ।

```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 = ਜਲਦੀ ਰੋਕੋ
    }
}

// 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 ਪਰਤਾਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ interviewers ਬਹੁਤ ਪੁੱਛਣਾ ਪਸੰਦ ਕਰਦੇ ਹਨ: **Filters** (servlet-level, ਸਭ ਤੋਂ ਬਾਹਰੀ — ਜਿੱਥੇ Spring Security ਰਹਿੰਦੀ ਹੈ) ਅਤੇ **Interceptors** (Spring MVC-level, controller ਦੇ ਦੁਆਲੇ)। ਕ੍ਰਮ ਜਾਣਨਾ — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message conversion, `afterCompletion` — ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ authentication ਬਨਾਮ logging ਕਿੱਥੇ ਰੱਖਣੀ ਹੈ, ਕਿਉਂ ਇੱਕ Security filter ਕਿਸੇ ਵੀ interceptor ਜਾਂ controller ਦੇ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ request ਨੂੰ ਰੱਦ ਕਰਦਾ ਹੈ, ਅਤੇ ਕਿਵੇਂ `@ControllerAdvice` ਪੂਰੇ flow ਵਿੱਚ exception handling ਨੂੰ ਕੇਂਦਰਿਤ ਕਰਦਾ ਹੈ।

ਪੜਾਅ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ