Hvad er controllers i Laravel?

Question

Accepted Answer

**Controllers** grupperer relateret request-håndtering logik i klasser. I stedet for at placere al logik i route closures organiserer controllers en applikations handlinger (f.eks. alle brugerrelaterede operationer) i metoder — hvilket holder ruter rene og koden organiseret.

## En grundlæggende 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
    }
}
```

Generer en med Artisan: `php artisan make:controller UserController`. Hver metode håndterer en handling, og ruter peger på dem.

## Ressource controllers (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()
```

En **ressource controller** har standard CRUD-metoderne, parret med `Route::resource` til konventionel RESTful routing — minimal boilerplate for typiske CRUD-ressourcer.

## Dependency injection i controllers

```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 **injicerer automatisk** type-hinted afhængigheder i controller constructors og metoder (inklusive `Request`) — rent, testbar kode.

## Hold controllers tynde

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

## Hvorfor det betyder noget

Controllers er en kerneklodse i Laravel — de organiserer request-håndtering logik i sammenhængende klasser, hvilket er essentielt for enhver applikation ud over trivielle ruter.

At forstå hvordan man opretter controllers, mapper ruter til deres metoder, og især bruger **ressource controllers** med `Route::resource` (til konventionel RESTful CRUD med minimal boilerplate) er hverdagsviden for at bygge Laravel apps.

Et nøgle Laravel-feature er **automatisk dependency injection** ind i controllers via service container — type-hinted afhængigheder (tjenester, requestet, mailers) løses og injiceres automatisk, hvilket muliggør ren, testbar, løst-koblet kode.

Ligeledes vigtig er bedste praksis med at holde controllers **tynde** — håndtering af kun HTTP-bekymringer (validering, kald til tjenester, returnering af responses) og delegering af forretningslogik til tjenester/models, hvilket holder koden vedligeholdbar og testbar.

Controllers danner sammen med routing og models ryggraden i Laravels request-håndtering, hvilket gør dem fundamentale for at bygge velorganiserede, professionelle Laravel applikationer.