Si funksionon cikli i jetës së një kërkese në Spring Boot?

Question

IT Interview Practice · Accepted Answer

Në Spring Boot (Spring MVC), një kërkesë kalon nëpër **servlet container**, një zinxhir **Filters**, **`DispatcherServlet`**-in qendror, pastaj nëpër **interceptors** dhe **`@Controller`**-in tënd, dhe vlera e kthyer konvertohet në përgjigjen HTTP.

## Fazat

```
Servlet container (Tomcat)
   ▼
Filter chain  ── (CharacterEncoding, Security, CORS, ...)
   ▼
DispatcherServlet  ── front controller-i
   ▼
HandlerMapping  ── gjej metodën @Controller
   ▼
HandlerInterceptor.preHandle
   ▼
Argument resolvers  ── bind @RequestBody / @PathVariable / @RequestParam
   ▼
Controller method  ── logjika jote → kthen object ose ResponseEntity
   ▼
HandlerInterceptor.postHandle
   ▼
HttpMessageConverter / ViewResolver  ── serializo në JSON ose rendero view
   ▼
HandlerInterceptor.afterCompletion → Response ──▶ client
```

1. **Container + filters** — Tomcat ia dorëzon kërkesën zinxhirit `Filter`. Filters (përfshirë Spring Security) janë shtresa më e jashtme dhe mund ta bllokojnë ose ta mbështjellin kërkesën para se MVC ta shohë.
2. **DispatcherServlet** — front controller-i që orkestron gjithçka poshtë.
3. **HandlerMapping** — përcakton cila metodë controller-i trajton URL-n + metodën.
4. **`preHandle`** — `HandlerInterceptor`-ët ekzekutohen para controller-it (kontrolle auth, logging, matje kohe); kthimi i `false` e ndalon kërkesën.
5. **Zgjidhja e argumenteve** — `@PathVariable`, `@RequestParam` dhe `@RequestBody` (përmes `HttpMessageConverter`) lidhen (bind) dhe validohen.
6. **Controller** — metoda jote `@RestController` ekzekuton logjikën e biznesit dhe kthen një objekt ose `ResponseEntity`.
7. **`postHandle`**, pastaj vlera e kthyer serializohet nga një `HttpMessageConverter` (JSON përmes Jackson) ose një view renderohet nga një `ViewResolver`.
8. **`afterCompletion`** ekzekutohet pasi përgjigja është konfirmuar (commit); `@ExceptionHandler`/`@ControllerAdvice` trajtojnë përjashtimet gjatë rrugës.

```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 = ndërpret zinxhirin
    }
}

// 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. serializuar në JSON
    }
}
```

## Pse ka rëndësi

Cikli i jetës i Spring ka dy shtresa zgjerimi të dallueshme që intervistuesit adhurojnë t'i hetojnë: **Filters** (në nivel servleti, më të jashtmet — ku ndodhet Spring Security) dhe **Interceptors** (në nivel Spring MVC, rreth controller-it). Njohja e rendit — filters, DispatcherServlet, mapping, `preHandle`-i i interceptor-it, binding-u i argumenteve, controller, konvertimi i mesazhit, `afterCompletion` — të thotë ku të vendosësh autentikimin kundrejt logging, pse një Security filter refuzon një kërkesë para se të ekzekutohet ndonjë interceptor ose controller, dhe si `@ControllerAdvice` e centralizon trajtimin e përjashtimeve në të gjithë rrjedhën.

Fazat

Pse ka rëndësi

Pyetje të ngjashme