Laravel Repository Pattern

Introduction

The Repository Pattern creates an abstraction layer between your application logic and data access. This makes your code more testable, maintainable, and flexible.

Benefits

• Abstraction - Decouple business logic from data access
• Testability - Easy to mock repositories for testing
• Flexibility - Change data sources without changing business logic
• Organization - Centralize data access logic

Implementation

// app/Repositories/UserRepository.php

namespace App\Repositories;

use App\Models\User;

class UserRepository
{
    protected $model;
    
    public function __construct(User $model)
    {
        $this->model = $model;
    }
    
    public function getAll()
    {
        return $this->model->all();
    }
    
    public function find($id)
    {
        return $this->model->find($id);
    }
    
    public function create(array $data)
    {
        return $this->model->create($data);
    }
    
    public function update($id, array $data)
    {
        $record = $this->find($id);
        $record->update($data);
        return $record;
    }
    
    public function delete($id)
    {
        return $this->model->destroy($id);
    }
}

Using Interfaces

// app/Repositories/Contracts/UserRepositoryInterface.php

namespace App\Repositories\Contracts;

interface UserRepositoryInterface
{
    public function getAll();
    public function find($id);
    public function create(array $data);
    public function update($id, array $data);
    public function delete($id);
}

// Binding in Service Provider
$this->app->bind(
    UserRepositoryInterface::class,
    UserRepository::class
);

Practical Examples

// Using in a Controller
class UserController extends Controller
{
    public function __construct(
        private UserRepositoryInterface $users
    ) {}
    
    public function index()
    {
        return view('users.index', [
            'users' => $this->users->getAll()
        ]);
    }
    
    public function store(Request $request)
    {
        $this->users->create($request->validated());
    }
}

Summary

The Repository Pattern provides a clean abstraction over your data layer. Use interfaces to define contracts and implement them with concrete classes for different data sources.

For more Laravel tutorials, see Service Container & DI.