Mit jelent a controllers a Laravelben?

Question

Accepted Answer

**Controllers** a kapcsolódó kéréskezelő logikát osztályokba csoportosítja. Az összes logika route closures-be helyezése helyett a kontrollerek egy alkalmazás akcióit (pl. minden felhasználóhoz kapcsolódó operáció) metódusokba rendezik — így a route-okat tisztán és a kódot szervezetten tartva.

## Alapvető vezérlő

```php
<?php
class UserController extends Controller {
    public function index() {
        return User::all();              // list users
    }
    public function show(User $user) {   // route model binding — auto-fetch by id
        return $user;
    }
    public function store(Request $request) {
        $validated = $request->validate(['name' => 'required', 'email' => 'required|email']);
        return User::create($validated);  // create
    }
}
```

Generáljon egyet az Artisannel: `php artisan make:controller UserController`. Minden metódus egy akciót kezel, és az útvonalak rá mutatnak.

## Erőforrás-vezérlők (RESTful CRUD)

```php
// generate a controller with all 7 RESTful methods stubbed
// php artisan make:controller PostController --resource

Route::resource('posts', PostController::class);   // maps routes to the methods:
// index() create() store() show() edit() update() destroy()
```

Az **erőforrás-vezérlő** a szabványos CRUD metódusokkal rendelkezik, a `Route::resource` -hoz párosítva a hagyományos RESTful útválasztáshoz — minimális boilerplate a tipikus CRUD erőforrásokhoz.

## Függőséginjektálás vezérlőkben

```php
class OrderController extends Controller {
    // type-hinted dependencies are AUTO-INJECTED by Laravel's service container
    public function __construct(private OrderService $orders) {}

public function store(Request $request, Mailer $mailer) {   // method injection too
        // $request and $mailer are resolved & injected automatically
    }
}
```

A Laravel service container **automatikusan injektálja** a type-hinted függőségeket a vezérlő konstruktorokba és metódusokba (beleértve a `Request` -et) — tiszta, tesztelhető kód.

## Tartsa vékonynak a vezérlőket

```text
✓ Controllers should handle HTTP concerns (validate input, call services, return responses)
✗ Business logic belongs in SERVICES/models, not bloated controllers ("thin controllers")
```

## Miért fontos

A vezérlők a Laravel alapvető építőelemei — a kéréskezelő logikát koherens osztályokba rendezik, amely nélkülözhetetlen bármely triviális útvonalakat meghaladó alkalmazás számára.

A vezérlők létrehozása, az útvonalak mappolása metódusaikra, és különösen az **erőforrás-vezérlők** használata `Route::resource` -hoz (a hagyományos RESTful CRUD-hoz minimális boilerplate-tel) a Laravel alkalmazások létrehozásához szükséges mindennapi tudás.

A Laravel egyik kulcsfontosságú funkciója az **automatikus függőséginjektálás** a service container-en keresztül a vezérlőkbe — a type-hinted függőségek (szolgáltatások, kérés, levelezők) automatikusan feloldódnak és injektálódnak, lehetővé téve a tiszta, tesztelhető, lazán csatolt kódot.

Egyenlően fontos a vezérlők **vékonynak** tartása — csak a HTTP-kel kapcsolatos dolgok kezelése (validáció, szolgáltatások meghívása, válaszok visszaadása) és az üzleti logika delegálása a szolgáltatásokhoz/modellekhez, ami a kódot karbantarthatóvá és tesztelhetővé teszi.

A vezérlők, az útválasztás és a modellek mellett a Laravel kéréskezelésének gerincét képezik, ami alapvetővé teszi őket a jól szervezett, professzionális Laravel alkalmazások létrehozásához.