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 (અથવા closure)  ── તમારી logic → Response પરત કરે છે
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (દા.ત. session save, logging)
```

1. **Front controller** — `index.php` Composer autoload ને load કરે છે અને application container ને bootstrap કરે છે.
2. **Kernel::handle** — HTTP Kernel `Request` મેળવે છે અને **bootstrappers** ચલાવે છે: env + config load કરો, service providers ને register અને **boot** કરો (આ એ છે જ્યાં framework અને તમારા bindings wire up થાય છે).
3. **Global middleware** — દરેક request માટે ચાલે છે (CORS, maintenance mode, strings trimming, proxy trust).
4. **Routing** — router URI + verb ને એક route સાથે મેચ કરે છે.
5. **Route/group middleware** — route અથવા તેના group ને assign કરેલ middleware (`auth`, `throttle`, `verified`) controller પહેલાં ચાલે છે; દરેક short-circuit કરી શકે છે.
6. **Controller** — તમારો action (અથવા route closure) ચાલે છે, models/services નો ઉપયોગ કરે છે, અને એક `Response` (view, JSON, redirect) પરત કરે છે. Response પાછો બહાર આવે તેમ middleware ની "after" logic ચાલે છે.
7. **terminate** — response મોકલાયા પછી, `Kernel::terminate` deferred work માટે 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);          // આગળના layer / 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 ને નકારે છે, અને ધીમા work ને terminable middleware પર કેવી રીતે defer કરવું જેથી user ને રાહ ન જોવી પડે.

તબક્કાઓ

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો