როგორ მუშაობს მოთხოვნის სასიცოცხლო ციკლი Laravel-ში?

Question

IT Interview Practice · Accepted Answer

ყოველი Laravel მოთხოვნა შემოდის ერთი front controller-ის, `public/index.php`-ის გავლით, მას **HTTP Kernel** მართავს **middleware** სტეკისა და **router**-ის გავლით **controller**-მდე, და აბრუნებს `Response`-ს — რის შემდეგაც **terminable** middleware სრულდება.

## ეტაპები

```
public/index.php  ── autoload + app-ის bootstrap
   ▼
HTTP Kernel::handle($request)
   ▼
Bootstrappers  ── env, config, providers (register + boot)
   ▼
Global middleware  ── (TrustProxies, HandleCors, ...)
   ▼
Router dispatch  ── ამთხვევს route-ს
   ▼
Route / group middleware  ── (auth, throttle, verified, ...)
   ▼
Controller (ან closure)  ── თქვენი ლოგიკა → აბრუნებს Response-ს
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (მაგ. session შენახვა, logging)
```

1. **Front controller** — `index.php` ტვირთავს Composer autoload-ს და bootstrap-ს უკეთებს აპლიკაციის container-ს.
2. **Kernel::handle** — HTTP Kernel იღებს `Request`-ს და უშვებს **bootstrapper**-ებს: ტვირთავს env + config-ს, არეგისტრირებს და **boot**-ავს service provider-ებს (აქ ერთმანეთს უკავშირდება framework და თქვენი binding-ები).
3. **Global middleware** — სრულდება ყოველი მოთხოვნისთვის (CORS, სარემონტო რეჟიმი, სტრიქონების trimming, proxy-ს ნდობა).
4. **Routing** — router ამთხვევს URI + verb-ს route-თან.
5. **Route/group middleware** — route-ზე ან მის ჯგუფზე მინიჭებული middleware (`auth`, `throttle`, `verified`) სრულდება controller-ამდე; თითოეულს შეუძლია გზა შეაჩეროს.
6. **Controller** — თქვენი action (ან route closure) სრულდება, იყენებს model/service-ს, და აბრუნებს `Response`-ს (view, JSON, redirect). middleware-ის „შემდგომი" ლოგიკა სრულდება, როცა response უკან, გარეთ ამოდის.
7. **terminate** — response-ის გაგზავნის შემდეგ, `Kernel::terminate` უშვებს terminable middleware-ს გადავადებული სამუშაოსთვის.

```php
// app/Http/Middleware/Timing.php  → 3/5. middleware
public function handle($request, Closure $next)
{
    $request->attributes->set('started', microtime(true));
    $response = $next($request);          // გადასცემს შემდეგ ფენას / controller-ს
    $response->headers->set('X-Time', '...');  // „შემდგომი" ლოგიკა
    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));
}
```

## რატომ არის ეს მნიშვნელოვანი

Laravel-ის სასიცოცხლო ციკლი აგებულია **service container**-სა და **middleware pipeline**-ის გარშემო, ამიტომ თანმიმდევრობის ცოდნა — bootstrap/provider, შემდეგ global middleware, შემდეგ routing, შემდეგ route middleware, შემდეგ controller, შემდეგ `terminate` — გეუბნებათ ზუსტად, სად ეკუთვნის auth, rate limiting, CORS და გაწმენდა. ის ხსნის, თუ რატომ უნდა იყოს service provider-ში bind-ული, სანამ inject-დება, რატომ უარყოფს `throttle` მოთხოვნას controller-ის გაშვებამდე, და როგორ გადაავადოთ ნელი სამუშაო terminable middleware-ზე ისე, რომ მომხმარებელს არ ალოდინოთ.

ეტაპები

რატომ არის ეს მნიშვნელოვანი

დაკავშირებული კითხვები