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** — કયું controller method URL + method ને હેન્ડલ કરે છે તે ઉકેલે છે.
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 કરવામાં આવે છે અથવા એક view ને `ViewResolver` દ્વારા render કરવામાં આવે છે.
8. **`afterCompletion`** response commit થયા પછી ચાલે છે; `@ExceptionHandler`/`@ControllerAdvice` રસ્તામાં exceptions ને હેન્ડલ કરે છે.

```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-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 ને કેવી રીતે કેન્દ્રિત કરે છે.

તબક્કાઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો