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 ஆராய விரும்பும் இரண்டு தனித்துவமான நீட்டிப்பு அடுக்குகள் உள்ளன: **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` விதிவிலக்கு கையாளுதலை எவ்வாறு மையப்படுத்துகிறது என்பதைச் சொல்கிறது.

நிலைகள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்