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, பராமரிப்பு முறை, 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);          // அடுத்த அடுக்கு / 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-க்கு எப்படி ஒத்திவைப்பது என்பதை இது விளக்குகிறது.

நிலைகள்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்