Panduan Lengkap Laravel Repository Pattern: Implementasi & Best Practices

Panduan Lengkap Laravel Repository Pattern: Implementasi & Best Practices

12/18/2025 • Web Development • By Tech Writers
LaravelRepository PatternPHPClean ArchitectureDesign PatternsWeb Development

Daftar Isi

Pengenalan Repository Pattern

Repository Pattern adalah salah satu design pattern yang berfungsi sebagai layer abstraksi antara domain logic aplikasi dan layer akses data. Secara sederhana, Repository adalah komponen yang membungkus logic pengaksesan data.

Dengan pattern ini, “consumer” atau klien dari repository (seperti Controller atau Service) tidak perlu tahu apakah data berasal dari Eloquent ORM, API eksternal, cache, atau flat file. Konsumer hanya perlu tahu metode apa saja yang tersedia di dalam interface repository tersebut.

Mengapa Menggunakan Repository Pattern?

Meskipun Eloquent di Laravel sudah sangat powerful, menggunakan Repository Pattern memberikan beberapa keuntungan signifikan:

  1. Decoupling (Pemisahan Ketergantungan): Logic aplikasi tidak terikat langsung pada ORM tertentu. Jika suatu saat Kamu ingin mengganti model data atau sumber data, Kamu hanya perlu mengubah implementasi repository-nya.
  2. Centralized Logic (Logic Terpusat): Query-query database yang kompleks tidak lagi tersebar di berbagai Controller, melainkan terpusat di satu tempat yang mudah dikelola.
  3. Testability: Memudahkan unit testing karena Kamu bisa melakukan ‘mocking’ terhadap repository interface dengan mudah tanpa harus berinteraksi langsung dengan database.
  4. Clean Code: Menjaga Controller tetap “skinny” (tipis) karena logic query sudah dipindahkan ke layer repository.

Perbandingan Arsitektur

Berikut adalah gambaran perbedaan antara alur MVC tradisional Laravel dengan alur yang menggunakan Repository Pattern:

graph TD
    subgraph "Standard MVC Laravel"
        C1[Controller] --> M1[Eloquent Model]
        M1 --> DB1[(Database)]
    end
    
    subgraph "Repository Pattern Architecture"
        C2[Controller] --> I[Repository Interface]
        I --> R[Repository Implementation]
        R --> M2[Eloquent Model]
        M2 --> DB2[(Database)]
    end

Langkah-langkah Implementasi

Mari kita praktekkan dengan studi kasus sederhana: User Management.

1. Membuat Model dan Migration

Pastikan Kamu sudah memiliki model User.

php artisan make:model User -m

2. Membuat Repository Interface

Interface mendefinisikan kontrak atau metode apa saja yang harus tersedia. Buat di folder app/Repositories/Interfaces/UserRepositoryInterface.php.

<?php

namespace App\Repositories\Interfaces;

interface UserRepositoryInterface
{
    public function all();
    public function findById($id);
    public function create(array $details);
    public function update($id, array $newDetails);
    public function delete($id);
}

3. Membuat Repository Implementation

Implementasi ini akan menggunakan Eloquent untuk berinteraksi dengan database. Buat di app/Repositories/Eloquent/UserRepository.php.

<?php

namespace App\Repositories\Eloquent;

use App\Models\User;
use App\Repositories\Interfaces\UserRepositoryInterface;

class UserRepository implements UserRepositoryInterface
{
    public function all()
    {
        return User::all();
    }

    public function findById($id)
    {
        return User::findOrFail($id);
    }

    public function create(array $details)
    {
        return User::create($details);
    }

    public function update($id, array $newDetails)
    {
        return User::whereId($id)->update($newDetails);
    }

    public function delete($id)
    {
        User::destroy($id);
    }
}

4. Registrasi di Service Provider

Agar Laravel tahu implementasi mana yang harus dipakai saat interface dipanggil (Dependency Injection), kita perlu melakukan binding di AppServiceProvider.php.

public function register()
{
    $this->app->bind(
        \App\Repositories\Interfaces\UserRepositoryInterface::class,
        \App\Repositories\Eloquent\UserRepository::class
    );
}

5. Penggunaan di Controller

Sekarang, Controller tidak lagi memanggil User::all(), melainkan melalui Interface.

use App\Repositories\Interfaces\UserRepositoryInterface;

class UserController extends Controller
{
    private $userRepository;

    public function __construct(UserRepositoryInterface $userRepository)
    {
        $this->userRepository = $userRepository;
    }

    public function index()
    {
        $users = $this->userRepository->all();
        return view('users.index', compact('users'));
    }
}

Improvement: Base Repository (Generic)

Untuk aplikasi besar, Kamu tidak ingin menulis metode CRUD yang sama berulang kali untuk setiap repository. Kamu bisa membuat Base Repository.

classDiagram
    class BaseRepositoryInterface {
        <<interface>>
        +all()
        +find(id)
        +create(data)
    }
    class EloquentBaseRepository {
        #model
        +all()
        +find(id)
    }
    class UserRepository {
        +findActiveUsers()
    }
    
    BaseRepositoryInterface <|-- EloquentBaseRepository
    EloquentBaseRepository <|-- UserRepository

BaseRepository.php:

abstract class BaseRepository implements BaseRepositoryInterface {
    protected $model;

    public function __construct(Model $model) {
        $this->model = $model;
    }

    public function all() {
        return $this->model->all();
    }
    // ... metode lainnya
}

Kapan Harus Menggunakan Pattern Ini?

✅ Gunakan Jika:

  • Project Kamu berskala besar dan kompleks.
  • Kamu berencana menggunakan Unit Testing secara intensif.
  • Ada kemungkinan sumber data berubah (misal: migrasi dari SQL ke NoSQL).
  • Kamu ingin memisahkan domain logic dengan data access logic secara ketat.

❌ Hindari Jika (YAGNI - You Ain’t Gonna Need It):

  • Project Kamu kecil atau berupa MVP sederhana.
  • Kamu hanya melakukan operasi CRUD standar tanpa logic yang rumit.
  • Kamu ingin development speed yang sangat cepat tanpa overhead file tambahan.

Kesimpulan

Repository Pattern adalah alat yang hebat untuk membangun aplikasi Laravel yang maintainable dan testable. Dengan memisahkan layer akses data, Kamu membuat kode Kamu lebih fleksibel terhadap perubahan di masa depan. Namun, selalu pertimbangkan kompleksitas project Kamu sebelum memutuskan untuk menggunakannya.

Sudah mencoba Repository Pattern di project Kamu? Atau menurut Kamu merepotkan? Yuk diskusi di kolom komentar! 💬

Resources

Artikel Terkait: