Laravel లో request lifecycle ఎలా పనిచేస్తుంది?

Question

IT Interview Practice · Accepted Answer

ప్రతి Laravel request ఒకే 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)  ── మీ logic → ఒక Response ను తిరిగి ఇస్తుంది
   ▼
Response ──▶ client
   ▼
Kernel::terminate  ── terminable middleware (ఉదా. session సేవ్, 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 ను trim చేయడం, proxy నమ్మకం).
4. **Routing** — router URI + verb ను ఒక route కు సరిపోల్చుతుంది.
5. **Route/group middleware** — route కు లేదా దాని group కు కేటాయించిన middleware (`auth`, `throttle`, `verified`) controller కు ముందు నడుస్తుంది; ప్రతి ఒక్కటి ముందుగానే ఆపవచ్చు.
6. **Controller** — మీ action (లేదా route closure) నడుస్తుంది, models/services ను ఉపయోగిస్తుంది, మరియు ఒక `Response` (view, JSON, redirect) ను తిరిగి ఇస్తుంది. response తిరిగి బయటికి వచ్చేటప్పుడు middleware యొక్క "after" logic నడుస్తుంది.
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);          // తదుపరి 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 చేయాలో, మీ controller నడవడానికి ముందు `throttle` ఒక request ను ఎందుకు తిరస్కరిస్తుందో, మరియు వినియోగదారు వేచి ఉండకుండా నెమ్మదైన పనిని terminable middleware కు ఎలా వాయిదా వేయాలో ఇది వివరిస్తుంది.

దశలు

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు