Yaya rayuwar request (request lifecycle) ke aiki a Spring Boot?

Question

IT Interview Practice · Accepted Answer

A Spring Boot (Spring MVC), request na wucewa ta cikin **servlet container**, sarƙar **Filters**, **`DispatcherServlet`** ta tsakiya, sannan **interceptors** da **`@Controller`** ɗinka, sannan a mayar da ƙimar da aka mayar zuwa cikin HTTP response.

## Matakan

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller
   ▼
HandlerMapping  ── nemo method ɗin @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── logic ɗinka → na mayar da object ko ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialize zuwa JSON ko render view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat na miƙa request ga sarƙar `Filter`. Filters (haɗe da Spring Security) su ne layer na waje ƙwarai kuma suna iya toshewa ko naɗe request kafin MVC ya gan shi.
2. **DispatcherServlet** — front controller da ke tsara komai a ƙasa.
3. **HandlerMapping** — na warware wace controller method ce ke sarrafa URL + method.
4. **`preHandle`** — `HandlerInterceptor`s na gudana kafin controller (bincike auth, logging, auna lokaci); mayar da `false` na dakatar da request.
5. **Argument resolution** — ana bind sannan validate `@PathVariable`, `@RequestParam`, da `@RequestBody` (ta hanyar `HttpMessageConverter`).
6. **Controller** — method ɗin `@RestController` ɗinka na gudanar da business logic sannan ya mayar da object ko `ResponseEntity`.
7. **`postHandle`**, sannan ana serialize ƙimar da aka mayar ta hanyar `HttpMessageConverter` (JSON ta Jackson) ko a render view ta `ViewResolver`.
8. **`afterCompletion`** na gudana bayan an commit response; `@ExceptionHandler`/`@ControllerAdvice` na sarrafa exceptions a hanya.

```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 = toshewa da wuri
    }
}

// 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. an serialize zuwa JSON
    }
}
```

## Me ya sa yake da muhimmanci

Rayuwar Spring na da layers biyu na fadaɗawa daban-daban da masu tambayoyin hira ke son bincika: **Filters** (matakin servlet, na waje ƙwarai — inda Spring Security ke zama) da **Interceptors** (matakin Spring MVC, kewaye da controller). Sanin tsari — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, message conversion, `afterCompletion` — na gaya maka inda za a sanya authentication a kwatanta da logging, dalilin da ya sa Security filter ke ƙin request kafin kowane interceptor ko controller ya gudana, da yadda `@ControllerAdvice` ke tattara sarrafa exception a duk faɗin gudanuwar.

Matakan

Me ya sa yake da muhimmanci

Tambayoyi masu alaƙa