Kaip veikia užklausos gyvavimo ciklas Laravel?

Question

IT Interview Practice · Accepted Answer

Kiekviena Laravel užklausa įeina per vieną front controller, `public/index.php`, yra valdoma **HTTP Kernel** per **middleware** krūvą ir **router** iki **controller**, ir grąžina `Response` — po ko įvykdomas **terminable** middleware.

## Etapai

```
public/index.php  ── autoload + bootstrap programą
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── suderina route
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (arba closure)  ── jūsų logika → grąžina Response
   ▼
Response ──▶ klientas
   ▼
Kernel::terminate  ── terminable middleware (pvz. session įrašymas, logging)
```

1. **Front controller** — `index.php` įkelia Composer autoload ir bootstrap'ina programos konteinerį.
2. **Kernel::handle** — HTTP Kernel gauna `Request` ir vykdo **bootstrapper'ius**: įkelia env + config, register ir **boot** service provider'ius (čia framework ir jūsų binding'ai yra sujungiami).
3. **Global middleware** — vykdomas kiekvienai užklausai (CORS, priežiūros režimas, eilučių apkarpymas, proxy pasitikėjimas).
4. **Routing** — router suderina URI + verb su route.
5. **Route/group middleware** — route arba jo grupei priskirtas middleware (`auth`, `throttle`, `verified`) vykdomas prieš controller; kiekvienas gali nutraukti anksčiau.
6. **Controller** — jūsų action (arba route closure) įvykdomas, naudoja modelius/servisus ir grąžina `Response` (view, JSON, redirect). Middleware „po" logika vykdoma, kai atsakymas burbuliuoja atgal į išorę.
7. **terminate** — po to, kai atsakymas išsiųstas, `Kernel::terminate` vykdo terminable middleware atidėtam darbui.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // perduoda kitam sluoksniui / controller
    $response->headers->set('X-Time', '...');  // „po" logika
    return $response;
}

// routes/web.php  → 4. routing (+ middleware)
Route::get('/items/{id}', [ItemController::class, 'show'])->middleware('auth');

// app/Http/Controllers/ItemController.php  → 6. controller
public function show(int $id)
{
    return response()->json(Item::findOrFail($id));
}
```

## Kodėl tai svarbu

Laravel gyvavimo ciklas yra pastatytas aplink **service container** ir **middleware pipeline**, todėl žinant eiliškumą — bootstrap/providers, tada global middleware, tada routing, tada route middleware, tada controller, tada `terminate` — jums tampa aišku, kur tiksliai priklauso auth, dažnio ribojimas (rate limiting), CORS ir valymas. Tai paaiškina, kodėl servisas turi būti susietas (bound) provider'yje prieš jį įterpiant (inject), kodėl `throttle` atmeta užklausą prieš įvykdant jūsų controller, ir kaip atidėti lėtą darbą į terminable middleware, kad vartotojas nebūtų verčiamas laukti.

Etapai

Kodėl tai svarbu

Susiję klausimai