使用倉儲模式是為了將數據訪問邏輯與業務邏輯分離，1. 定義倉儲接口明確數據操作方法；2. 創建基於Eloquent的具體實現類封裝數據庫查詢；3. 在控制器中通過依賴注入使用倉儲接口；4. 在服務提供者中綁定接口與實現類；最終實現代碼解耦、提高可測試性與可維護性，適用於中大型應用或需靈活切換數據源的場景。

The Repository Pattern in Laravel is a design pattern used to abstract the logic for accessing and interacting with data from the database. It sits between your controllers and the Eloquent models (or other data sources), helping you write cleaner, more maintainable, and testable code by decoupling business logic from data access logic.

Why Use the Repository Pattern?

In a typical Laravel app, you might directly call Eloquent models in your controller like this:

 public function index()
{
    $users = User::where('active', 1)->get();
    return view('users.index', compact('users'));
}

This works fine for small apps, but as your application grows, repeating complex queries across controllers or having database logic mixed with HTTP logic becomes messy. The Repository Pattern helps solve this.

How the Repository Pattern Works

Instead of querying the database directly in the controller, you define an interface (or class) that represents a set of data operations. Then, you implement that interface with a concrete class—usually using Eloquent under the hood.

1. Define a Repository Interface

 // App/Repositories/UserRepositoryInterface.php
namespace App\Repositories;

interface UserRepositoryInterface
{
    public function getActiveUsers();
    public function findById($id);
    public function create(array $data);
}

2. Create the Eloquent Repository Implementation

 // App/Repositories/EloquentUserRepository.php
namespace App\Repositories;

use App\Models\User;

class EloquentUserRepository implements UserRepositoryInterface
{
    public function getActiveUsers()
    {
        return User::where('active', 1)->get();
    }

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

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

3. Use It in a Controller

 // App/Http/Controllers/UserController.php
namespace App\Http\Controllers;

use App\Repositories\UserRepositoryInterface;

class UserController extends Controller
{
    protected $userRepository;

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

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

Laravel's service container automatically resolves the interface to the concrete implementation if you bind it properly (more on that below).

Benefits of Using the Repository Pattern

• Separation of Concerns : Keeps data access logic out of controllers.
• Reusability : Common queries can be reused across different parts of the app.
• Testability : You can mock the repository in tests instead of hitting the database.
• Flexibility : You can swap out Eloquent for another data source (eg, API, cache, file storage) without changing the controller.

For example, during testing:

 $this->instance(UserRepositoryInterface::class, Mockery::mock(UserRepositoryInterface::class, function ($mock) {
    $mock->shouldReceive('getActiveUsers')->andReturn(collect([...]));
}));

Binding the Repository in Laravel

You need to tell Laravel which class to inject when the interface is type-hinted. This is usually done in a service provider (like AppServiceProvider ):

 use App\Repositories\UserRepositoryInterface;
use App\Repositories\EloquentUserRepository;

public function register()
{
    $this->app->bind(UserRepositoryInterface::class, EloquentUserRepository::class);
}

Now, whenever UserRepositoryInterface is type-hinted, Laravel injects EloquentUserRepository .

When Should You Use It?

• Medium to large applications where maintainability matters.
• Teams working on complex business logic.
• Apps that may change data sources in the future.
• Projects where testing is a priority.

For small apps or simple CRUD, it might be overkill—Laravel's Eloquent is already expressive and clean.

Final Notes

The Repository Pattern isn't built into Laravel—it's a design choice you implement yourself. While Laravel doesn't enforce it, many developers use it alongside service providers and dependency injection to build scalable applications.

It's not always necessary, but knowing when and how to use it gives you more control over your app's architecture.

Basically: Repository = Cleaner controllers Better testing Easier refactoring.

以上是的詳細內容。更多資訊請關注PHP中文網其他相關文章！