Hur strukturerar du en service/arkitektur för en stor Laravel-app?

Question

Accepted Answer

När en Laravel-applikation växer blir standardansatsen "tjocka controllrar / tjocka modeller" svår att underhålla. Större appar gynnas av **ytterligare arkitekturlager** — serviceklasser, actionklasser, repositories, formförfrågningar och tydlig domänorganisation — för att hålla affärslogiken organiserad, testbar och underhållbar.

## Problemet: logik slutar på fel ställen

```text
Small apps: logic in controllers and models is fine.
Large apps: controllers get bloated, models become "god objects", logic is duplicated
→ hard to test, maintain, and reason about. Extract logic into dedicated layers.
```

## Serviceklasser — kapsla in affärslogik

```php
<?php
// move complex business logic out of controllers into a service
class OrderService {
    public function __construct(
        private PaymentGateway $payments,
        private InventoryService $inventory,
    ) {}

public function placeOrder(User $user, array $items): Order {
        // orchestrate the business process — reusable, testable, focused
        DB::transaction(function () use ($user, $items) { /* ... */ });
    }
}

// the controller stays THIN — just delegates
public function store(StoreOrderRequest $request, OrderService $orders) {
    return $orders->placeOrder($request->user(), $request->validated());
}
```

**Serviceklasser** innehåller affärslogik, vilket håller controllrar tunna (bara hantera HTTP) och modeller fokuserade på data — och gör logiken återanvändbar och oberoende testbar.

## Andra användbara mönster för stora appar

```text
✓ Action classes — a single class per use-case (e.g. CreateUserAction) — very focused
✓ Form Requests — extract validation + authorization out of controllers
✓ API Resources — control response shape, separate from models
✓ Repository pattern — abstract data access behind interfaces (when you need it;
  often Eloquent suffices, so don't add it reflexively)
✓ Events/listeners — decouple side effects from core logic
✓ Domain-oriented organization — group code by feature/domain, not just by type
  (e.g. a modules/ structure) as the app grows
✓ Dependency injection + interfaces — for loose coupling and testability
```

## De vägledande principerna

```text
✓ Thin controllers (HTTP only) → services/actions (business logic) → models (data)
✓ Single Responsibility — each class does one thing
✓ Depend on abstractions (interfaces) for testability and flexibility
✗ Don't over-engineer — add layers when complexity justifies them, not prematurely
```

## Varför det spelar roll

Att förstå hur man strukturerar en stor Laravel-applikation är viktig kunskap på seniornivå, eftersom de konventioner som fungerar för små appar (logik i controllrar och modeller) bryts ned i större skala — vilket leder till uppsvälld controllrar, "gudgubbe"-modeller, duplicerad logik och kod som är svår att testa och underhålla.

Att känna till de ytterligare arkitekturlagren — särskilt **serviceklasser** (kapsla in affärslogik för att hålla controllrar tunna och modeller fokuserade, samtidigt som logiken blir återanvändbar och testbar), plus actionklasser, Form Requests (extrahera validering/auktorisering), API Resources (kontrollera output), repository-mönstret (abstrahera dataåtkomst när det behövs), events (frånkopla bieffekter) och **domänorienterad organisation** (gruppera efter funktion när appen växer) — är det som gör att du kan bygga underhållbara, skalbara applikationer.

De vägledande principerna spelar roll: **tunna controllrar → services → modeller**-lagring, enkel ansvar och beroende på abstraktioner (interfaces) för testbarhet och löst koppling.

Lika viktigt är omdömet att **inte över-konstruera** — lägga till lager när komplexiteten genuint motiverar dem snarare än förebyggande (Laravels standardvärden fungerar bra för enklare appar, och reflexivt att lägga till repositories/abstraktioner lägger till onödig komplexitet).

Att förstå dessa arkitekturmönster och principerna (och återhållsamhet) för att tillämpa dem är värdefullt för att bygga stora, långvariga Laravel-applikationer som förblir underhållbara, testbara och förståbara när de växer — vilket skiljer utvecklare som kan arkitekturera skalbara applikationer från de vars växande appar kollapsar in i rörig, svår att underhålla kod.

Denna arkitektoniska omdöme är ett kännetecken för senior Laravel-utveckling och en ofta relevant angelägenhet för seriösa, växande applikationer.