Was sind Controller in Laravel?

Question

Accepted Answer

**Controller** gruppieren verwandte Request-Handling-Logik in Klassen. Anstatt alle Logik in Route-Closures zu platzieren, organisieren Controller die Aktionen einer Anwendung (z. B. alle benutzerbezogenen Operationen) in Methoden — wodurch Routes sauber und Code organisiert bleiben.

## Ein grundlegender Controller

```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
    }
}
```

Erstellen Sie einen mit Artisan: `php artisan make:controller UserController`. Jede Methode handhabt eine Aktion, und Routes verweisen auf sie.

## Resource Controller (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()
```

Ein **Resource Controller** hat die Standard-CRUD-Methoden, gekoppelt mit `Route::resource` für konventionelles RESTful Routing — minimaler Boilerplate für typische CRUD-Ressourcen.

## Dependency Injection in Controllern

```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
    }
}
```

Laravels Service Container **injiziert automatisch** typ-deklarierte Abhängigkeiten in Controller-Konstruktoren und Methoden (einschließlich `Request`) — sauberer, testbarer Code.

## Halten Sie Controller schlank

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

## Warum es wichtig ist

Controller sind ein Kernbaustein von Laravel — sie organisieren Request-Handling-Logik in kohärente Klassen, was für jede Anwendung über triviale Routes hinaus erforderlich ist.

Zu verstehen, wie man Controller erstellt, Routes auf ihre Methoden abbildet und besonders **Resource Controller** mit `Route::resource` verwendet (für konventionelles RESTful CRUD mit minimalem Boilerplate), ist tägliches Wissen für den Aufbau von Laravel-Apps.

Ein Schlüssel-Laravel-Feature ist **automatische Dependency Injection** in Controller über den Service Container — typ-deklarierte Abhängigkeiten (Services, Request, Mailer) werden automatisch aufgelöst und injiziert, was sauberen, testbaren, lose gekoppelten Code ermöglicht.

Gleich wichtig ist die Best Practice, Controller **schlank** zu halten — nur HTTP-Concerns zu handhaben (Validierung, Service-Aufrufe, Responses zurückgeben) und Geschäftslogik an Services/Models zu delegieren, was Code wartbar und testbar hält.

Controller bilden zusammen mit Routing und Models das Rückgrat von Laravels Request-Handling und machen sie grundlegend für den Aufbau gut organisierter, professioneller Laravel-Anwendungen.