Vad är controllers i Laravel?

Question

Accepted Answer

**Controllers** grupperar relaterad logik för hantering av förfrågningar i klasser. Istället för att placera all logik i route-closures organiserar controllers en applikations åtgärder (t.ex. alla användarrelaterade operationer) i metoder — vilket håller routes rena och koden organiserad.

## En grundläggande 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
    }
}
```

Generera en med Artisan: `php artisan make:controller UserController`. Varje metod hanterar en åtgärd, och routes pekar på dem.

## Resource 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 **resource controller** har standardmetoderna för CRUD, tillsammans med `Route::resource` för konventionell RESTful-routing — minimal boilerplate för typiska CRUD-resurser.

## 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 **injicerar automatiskt** beroenden som är typangivna in i controller-konstruktorer och metoder (inklusive `Request`) — ren, testbar kod.

## Håll controllers tunna

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

## Varför det spelar roll

Controllers är ett kärnblock i Laravel — de organiserar logik för hantering av förfrågningar i sammanhängande klasser, vilket är väsentligt för all applikation bortom triviala routes.

Att förstå hur man skapar controllers, mappar routes till deras metoder, och särskilt använder **resource controllers** med `Route::resource` (för konventionell RESTful CRUD med minimal boilerplate) är daglig kunskap för att bygga Laravel-appar.

En nyckelfunktion i Laravel är **automatisk dependency injection** in i controllers via service containern — beroenden som är typangivna (services, request, mailers) löses upp och injiceras automatiskt, vilket möjliggör ren, testbar, löst kopplad kod.

Lika viktigt är det bästa sättet att hålla controllers **tunna** — hantera endast HTTP-relaterade problem (validering, anrop av services, returning responses) och delegera affärslogik till services/models, vilket håller koden underhållbar och testbar.

Controllers tillsammans med routing och models utgör ryggraden i Laravels hantering av förfrågningar, vilket gör dem grundläggande för att bygga välorganiserade, professionella Laravel-applikationer.