Laravel ਵਿੱਚ request lifecycle ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?

Question

IT Interview Practice · Accepted Answer

ਹਰ Laravel request ਇੱਕ ਇਕੱਲੇ front controller, `public/index.php`, ਰਾਹੀਂ ਦਾਖਲ ਹੁੰਦਾ ਹੈ, **HTTP Kernel** ਦੁਆਰਾ ਇੱਕ **middleware** stack ਅਤੇ **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 (or closure)  ── ਤੁਹਾਡਾ logic → Response ਵਾਪਸ ਕਰਦਾ ਹੈ
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (ਜਿਵੇਂ session save, logging)
```

1. **Front controller** — `index.php` Composer autoload ਨੂੰ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ application container ਨੂੰ bootstrap ਕਰਦਾ ਹੈ।
2. **Kernel::handle** — HTTP Kernel `Request` ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ **bootstrappers** ਚਲਾਉਂਦਾ ਹੈ: env + config ਲੋਡ ਕਰੋ, service providers ਨੂੰ register ਅਤੇ **boot** ਕਰੋ (ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ framework ਅਤੇ ਤੁਹਾਡੇ bindings ਜੁੜਦੇ ਹਨ)।
3. **Global middleware** — ਹਰ request ਲਈ ਚੱਲਦਾ ਹੈ (CORS, maintenance mode, strings ਕੱਟਣਾ, proxy trust)।
4. **Routing** — router URI + verb ਨੂੰ ਇੱਕ route ਨਾਲ ਮੇਲ ਕਰਦਾ ਹੈ।
5. **Route/group middleware** — route ਜਾਂ ਇਸਦੇ group ਨੂੰ ਸੌਂਪਿਆ middleware (`auth`, `throttle`, `verified`) controller ਤੋਂ ਪਹਿਲਾਂ ਚੱਲਦਾ ਹੈ; ਹਰ ਇੱਕ short-circuit ਕਰ ਸਕਦਾ ਹੈ।
6. **Controller** — ਤੁਹਾਡਾ action (ਜਾਂ route closure) ਚੱਲਦਾ ਹੈ, models/services ਵਰਤਦਾ ਹੈ, ਅਤੇ ਇੱਕ `Response` (view, JSON, redirect) ਵਾਪਸ ਕਰਦਾ ਹੈ। Middleware ਦਾ "after" logic ਉਦੋਂ ਚੱਲਦਾ ਹੈ ਜਦੋਂ 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', '...');  // "after" logic
    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 ਦਾ lifecycle **service container** ਅਤੇ **middleware pipeline** ਦੁਆਲੇ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ ਕ੍ਰਮ ਜਾਣਨਾ — bootstrap/providers, ਫਿਰ global middleware, ਫਿਰ routing, ਫਿਰ route middleware, ਫਿਰ controller, ਫਿਰ `terminate` — ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ auth, rate limiting, CORS, ਅਤੇ cleanup ਬਿਲਕੁਲ ਕਿੱਥੇ ਹਨ। ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ ਇੱਕ service ਨੂੰ inject ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ provider ਵਿੱਚ bind ਕਿਉਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, `throttle` ਤੁਹਾਡੇ controller ਦੇ ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ request ਨੂੰ ਕਿਉਂ ਰੱਦ ਕਰਦਾ ਹੈ, ਅਤੇ ਹੌਲੀ ਕੰਮ ਨੂੰ terminable middleware ਵੱਲ ਕਿਵੇਂ ਮੁਲਤਵੀ ਕਰਨਾ ਹੈ ਤਾਂ ਜੋ user ਨੂੰ ਇੰਤਜ਼ਾਰ ਨਾ ਕਰਨਾ ਪਵੇ।

ਪੜਾਅ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ