Spring Boot లో request lifecycle ఎలా పనిచేస్తుంది?

Question

IT Interview Practice · Accepted Answer

Spring Boot (Spring MVC) లో, ఒక request **servlet container**, **Filters** గొలుసు, కేంద్ర **`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` గొలుసుకు అప్పగిస్తుంది. Filters (Spring Security తో సహా) బయటి పొర మరియు MVC చూడటానికి ముందు request ను block చేయవచ్చు లేదా చుట్టుముట్టవచ్చు.
2. **DispatcherServlet** — కింద ఉన్న ప్రతిదాన్ని నిర్వహించే front controller.
3. **HandlerMapping** — ఏ controller method URL + method ను నిర్వహిస్తుందో నిర్ధారిస్తుంది.
4. **`preHandle`** — `HandlerInterceptor` లు controller కు ముందు నడుస్తాయి (auth తనిఖీలు, logging, టైమింగ్); `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 లో interviewers పరిశీలించడానికి ఇష్టపడే రెండు విభిన్న extension పొరలు ఉన్నాయి: **Filters** (servlet-స్థాయి, బయటిది — Spring Security నివసించే చోటు) మరియు **Interceptors** (Spring MVC-స్థాయి, controller చుట్టూ). క్రమాన్ని తెలుసుకోవడం — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message conversion, `afterCompletion` — authentication ను logging కు వ్యతిరేకంగా ఎక్కడ ఉంచాలో, ఏదైనా interceptor లేదా controller నడవడానికి ముందు ఒక Security filter ఒక request ను ఎందుకు తిరస్కరిస్తుందో, మరియు మొత్తం flow అంతటా `@ControllerAdvice` exception handling ను ఎలా కేంద్రీకరిస్తుందో మీకు చెబుతుంది.

దశలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు