Bagaimana Anda menstruktur service/arsitektur untuk aplikasi Laravel yang besar?

Question

Accepted Answer

Seiring pertumbuhan aplikasi Laravel, pendekatan default "fat controller / fat model" menjadi sulit untuk dipertahankan. Aplikasi yang lebih besar mendapat manfaat dari **lapisan arsitektur tambahan** — service classes, action classes, repositories, form requests, dan organisasi domain yang jelas — untuk menjaga business logic tetap terorganisir, dapat diuji, dan mudah dipelihara.

## Masalahnya: logic berakhir di tempat yang salah

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

## Service classes — enkapsulasi business logic

```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());
}
```

**Service classes** menyimpan business logic, membuat controllers tetap tipis (hanya menangani HTTP) dan models fokus pada data — dan membuat logic dapat digunakan kembali serta dapat diuji secara independen.

## Pola-pola lain yang berguna untuk aplikasi besar

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

## Prinsip-prinsip panduan

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

## Mengapa ini penting

Memahami cara menstruktur aplikasi Laravel yang besar adalah pengetahuan tingkat senior yang penting, karena konvensi yang bekerja untuk aplikasi kecil (logic di controllers dan models) tidak berfungsi pada skala besar — menghasilkan controllers yang membengkak, "god" models, logic yang duplikat, dan code yang sulit diuji dan dipertahankan.

Mengetahui lapisan arsitektur tambahan — terutama **service classes** (mengenkapsulasi business logic untuk menjaga controllers tetap tipis dan models fokus, sambil membuat logic dapat digunakan kembali dan dapat diuji), ditambah action classes, Form Requests (mengekstrak validasi/otorisasi), API Resources (mengontrol output), repository pattern (mengabstraksi akses data bila diperlukan), events (memisahkan side effects), dan **organisasi berbasis domain** (mengelompokkan berdasarkan fitur seiring pertumbuhan aplikasi) — adalah yang memungkinkan Anda membangun aplikasi yang mudah dipelihara dan scalable.

Prinsip-prinsip panduan penting: **thin controllers → services → models** layering, single responsibility, dan bergantung pada abstractions (interfaces) untuk testability dan loose coupling.

Sama pentingnya adalah pertimbangan untuk **tidak over-engineer** — menambahkan lapisan ketika kompleksitas benar-benar membenarkannya daripada secara prematur (default Laravel bagus untuk aplikasi yang lebih sederhana, dan secara refleks menambahkan repositories/abstractions menambah kompleksitas yang tidak perlu).

Memahami pola-pola arsitektur ini dan prinsip-prinsip (serta restrain) untuk menerapkannya berharga untuk membangun aplikasi Laravel yang besar dan bertahan lama yang tetap mudah dipelihara, dapat diuji, dan dapat dipahami seiring pertumbuhan — membedakan developer yang dapat merancang aplikasi scalable dari mereka yang aplikasinya yang berkembang runtuh menjadi code yang kusut dan sulit dipertahankan.

Pertimbangan arsitektur ini adalah ciri khas pengembangan Laravel senior dan kepedulian yang sering relevan untuk aplikasi yang serius dan berkembang.