How to implement the Repository design pattern in Laravel

In this article, I will show you how to implement the repository design pattern from scratch in Laravel. I will be using Laravel version 5.8.3, but Laravel version is not the most important. Before you start writing code, you need to know some information about repository design patterns.

repository Design patterns allow you to work with objects without knowing how those objects are persisted. Essentially, it is an abstraction of the data layer.

This means that your business logic does not need to know how to retrieve the data or what the data source is, the business logic relies on the repository to retrieve the correct data.

Regarding this pattern, I have seen some misunderstanding it as repository being used to create or update data. This is not what repository is supposed to do, repository is not supposed to create or update data, only to retrieve it.

Do you understand? Let’s write the code together

Since we are starting from scratch, let’s create a new Laravel project:

composer create-project --prefer-dist laravel/laravel repository

For this tutorial, we will build a small blogging application. Now that we have created a new Laravel project, we should create a controller and model for it.

php artisan make:controller BlogController

This will create the BlogController in the app/Http/Controllers directory.

php artisan make:model Models/Blog -m

Tip: The
-m option will create a corresponding database migration. You can find the generated migration in the *database/migrations directory. *

Now you should be able to find the newly generated model Blog in the app/Models directory. This is just a way I like to store my models.

Now that we have our controller and model, it’s time to look at the migration file we created. In addition to the default Laravel timestamp fields, our blog only requires the Title, Content, and UserID fields.

<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateBlogsTable extends Migration
{
    public function up()
    {
        Schema::create(&#39;blogs&#39;, function (Blueprint $table) {
            $table->bigIncrements(&#39;id&#39;);
            $table->string(&#39;title&#39;);
            $table->text(&#39;content&#39;);
            $table->integer(&#39;user_id&#39;);
            $table->timestamps();

            $table->foreign(&#39;user_id&#39;)
                  ->references(&#39;id&#39;)
                  ->on(&#39;users&#39;);
        });
    }

    public function down()
    {
        Schema::dropIfExists(&#39;blogs&#39;);
    }
}

Tips:
If you are using an old version below Laravel 5.8, please replace

$table->bigIncrements('id');

with:

$table->increments('id');

Setting up the database

I will use the MySQL database as an example, the first step is to create a new database.

mysql -u root -p 
create database laravel_repository;

The above command will create a new database called laravel_repository. Next we need to add database information to the .env file in the Laravel root directory.

DB_DATABASE=laravel_repositoryDB_USERNAME=rootDB_PASSWORD=secret

We need to clear the cache after you update the .env file:

php artisan config:clear

Run migration

Now that we have the database set up, we can start running the migration:

php artisan migrate

This will create the blogs table, containing the title# we declared in the migration ## , content and user_id fields.

##Implementationrepository Design patternEverything is ready, we can now start to implement the

design Styled. We will create the Repositories directory inside the app directory. The second directory we will create is the Interfaces directory, which is located within the Repositories directory. In the

file we will create a BlogRepositoryInterface interface that contains two methods.

Returns the
• all

  method of all blog posts

Returns the
• getByUser## of all the blog posts of a specific user # Method

  <?php
  
  namespace App\Repositories\Interfaces;
  
  use App\User;
  
  interface BlogRepositoryInterface
  {
      public function all();
  
      public function getByUser(User $user);
  }

  The last class we need to create is
BlogRepository

BlogRepositoryInterface, we will write the simplest implementation .

<?php

namespace App\Repositories;

use App\Models\Blog;
use App\User;
use App\Repositories\Interfaces\BlogRepositoryInterface;

class BlogRepository implements BlogRepositoryInterface
{
    public function all()
    {
        return Blog::all();
    }

    public function getByUser(User $user)
    {
        return Blog::where(&#39;user_id&#39;,$user->id)->get();
    }
}

app/└── Repositories/
    ├── BlogRepository.php
    └── Interfaces/
        └── BlogRepositoryInterface.php

repository.

Repository in a ControllerTo start using BlogRepository, we first need to Inject it into

. Thanks to Laravel's dependency injection, we can easily replace it with another one. This is what our controller looks like:

<?php

namespace App\Http\Controllers;


use App\Repositories\Interfaces\BlogRepositoryInterface;
use App\User;

class BlogController extends Controller
{
    private $blogRepository;

    public function __construct(BlogRepositoryInterface $blogRepository)
    {
        $this->blogRepository = $blogRepository;
    }

    public function index()
    {
        $blogs = $this->blogRepository->all();

        return view(&#39;blog&#39;)->withBlogs($blogs);
    }

    public function detail($id)
    {
        $user = User::find($id);
        $blogs = $this->blogRepository->getByUser($user);

        return view(&#39;blog&#39;)->withBlogs($blogs);
    }
}

methods are easily reusable.

repository 设计模式也使更改数据源变得更加容易。在这个例子中，我们使用 MySQL 数据库来检索我们的博客内容。我们使用 Eloquent 来完成查询数据库操作。但是假设我们在某个网站上看到了一个很棒的博客 API，我们想使用这个 API 作为数据源，我们所要做的就是重写 BlogRepository 来调用这个 API 替换 Eloquent 。

php artisan make:provider RepositoryServiceProvider

<?php

namespace App\Providers;

use App\Repositories\BlogRepository;
use App\Repositories\Interfaces\BlogRepositoryInterface;
use Illuminate\Support\ServiceProvider;

class RepositoryServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(
            BlogRepositoryInterface::class, 
            BlogRepository::class
        );
    }
}

'providers' => [
  \App\Providers\RepositoryServiceProvider::class
],

php artisan config:clear

The above is the detailed content of How to implement the Repository design pattern in Laravel. For more information, please follow other related articles on the PHP Chinese website!