Conas a oibríonn saolré an request in Spring Boot?

Question

IT Interview Practice · Accepted Answer

In Spring Boot (Spring MVC), gabhann request trí an **servlet container**, slabhra de **Filters**, an **`DispatcherServlet`** lárnach, ansin **interceptors** agus do **`@Controller`**, agus tiontaítear an luach a fhilltear isteach sa response HTTP.

## Na céimeanna

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── an front controller
   ▼
HandlerMapping  ── faigh an method @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── do loighic → filleann object nó ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serialize go JSON nó rindreáil view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — tugann Tomcat an request don slabhra `Filter`. Is iad na Filters (lena n-áirítear Spring Security) an ciseal is forimeallaí agus is féidir leo an request a bhlocáil nó a fhilleadh sula bhfeiceann MVC é.
2. **DispatcherServlet** — an front controller a chomhordaíonn gach rud thíos.
3. **HandlerMapping** — réitíonn sé cén controller method a láimhseálann an URL + method.
4. **`preHandle`** — ritheann na `HandlerInterceptor`s roimh an controller (seiceálacha auth, logging, uainiú); stopann `false` a fhilleadh an request.
5. **Argument resolution** — bind-áiltear agus validate-áiltear `@PathVariable`, `@RequestParam`, agus `@RequestBody` (trí `HttpMessageConverter`).
6. **Controller** — ritheann do method `@RestController` an loighic ghnó agus filleann sé object nó `ResponseEntity`.
7. **`postHandle`**, ansin serialize-áiltear an luach a fhilltear ag `HttpMessageConverter` (JSON trí Jackson) nó rindreáiltear view ag `ViewResolver`.
8. **`afterCompletion`** ritheann sé tar éis an response a chur i bhfeidhm; láimhseálann `@ExceptionHandler`/`@ControllerAdvice` eisceachtaí feadh na slí.

```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 = ciorcadghearradh
    }
}

// 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. serialize-áilte go JSON
    }
}
```

## Cén fáth a bhfuil sé tábhachtach

Tá dhá chiseal shínithe ar leith ag saolré Spring a bhfuil an-dúil ag agallóirí iad a scrúdú: **Filters** (leibhéal servlet, is forimeallaí — an áit a gcónaíonn Spring Security) agus **Interceptors** (leibhéal Spring MVC, timpeall an controller). Nuair a bhíonn a fhios agat an t-ord — filters, DispatcherServlet, mapping, interceptor `preHandle`, argument binding, controller, tiontú message, `afterCompletion` — insíonn sé duit cá gcuirfidh tú fíordheimhniú i gcomparáid le logging, cén fáth a ndiúltaíonn Security filter request roimh aon interceptor nó controller a rith, agus conas a láraíonn `@ControllerAdvice` láimhseáil eisceachtaí ar fud an tsreafa iomláin.

Na céimeanna

Cén fáth a bhfuil sé tábhachtach

Ceisteanna gaolmhara