Corak repositori Laravel yang popular baru-baru ini (Repositori)

Lajur tutorial Corak repositori Laravel yang popular baru-baru ini (Repositori) akan memperkenalkan anda kepada mod repositori Corak repositori Laravel yang popular baru-baru ini (Repositori) (Repositori).

                                                                                                               

• 1. Corak repositori (Repositori) dalam Corak repositori Laravel yang popular baru-baru ini (Repositori)
• 2. Mengapa menggunakan corak repositori dalam Corak repositori Laravel yang popular baru-baru ini (Repositori) ( Repositori)?

Dalam kebanyakan aplikasi web, mengakses pangkalan data mengambil kira sebahagian besar pangkalan kod. Untuk mengelakkan kekacauan logik aplikasi kami dengan pertanyaan SQL, kami bergantung pada abstraksi, yang menyembunyikan mekanisme capaian data di sebalik kaedah PHP.

Terdapat beberapa mod untuk akses data berstruktur, "Rekod Aktif" dan "Repositori" adalah dua yang paling terkenal. Dalam catatan blog ini, saya akan menerangkannya secara khusus dalam konteks rangka kerja Corak repositori Laravel yang popular baru-baru ini (Repositori). Perbincangan tentang kebaikan dan keburukan menggunakan corak Repositori akan dibincangkan dalam catatan blog yang berasingan.

Rekod Aktif

Secara lalai, Corak repositori Laravel yang popular baru-baru ini (Repositori) menggunakan mod Rekod Aktif. Setiap pengaturcara Corak repositori Laravel yang popular baru-baru ini (Repositori) menggunakannya secara intuitif kerana ia dilaksanakan dalam kelas asas Model abstrak, yang mana model biasanya diwarisi. Mari lihat contoh:

use Illuminate\Database\Eloquent\Model;

/**
 * @property int    $id
 * @property string $first_name
 * @property string $last_name
 */
class Person extends Model {
}

// --- 使用：

$person = new Person();
$person->first_name = 'Jack';
$person->last_name = 'Smith';
$person->save();

Sudah tentu, anda boleh membaca dan menulis sifat yang anda buat pada Person. Tetapi untuk menyimpan model, anda juga boleh memanggil kaedah terus pada model. Tidak ada keperluan untuk objek lain - model sudah menyediakan semua kaedah untuk mengakses jadual pangkalan data yang sepadan.

Ini bermakna model domain menggabungkan sifat dan kaedah tersuai anda dengan semua kaedah akses data dalam kelas yang sama. Bahagian kedua dicapai dengan mewarisi Model.

Isi penting:

• Rekod Aktif menggabungkan model domain dengan fungsi akses data.
• Corak repositori Laravel yang popular baru-baru ini (Repositori) menggunakan corak Rekod Aktif dan melaksanakannya melalui kelas Model.

Repositori

Corak repositori ialah alternatif kepada corak Rekod Aktif. Ia juga menyediakan abstraksi untuk mengendalikan capaian data. Tetapi secara lebih luas, ia boleh dilihat sebagai repositori konseptual atau koleksi objek domain.

Bertentangan dengan corak rekod aktif, corak storan memisahkan akses pangkalan data daripada model domain. Ia menyediakan antara muka peringkat tinggi di mana anda boleh membuat, membaca, mengemas kini dan memadam model domain tanpa perlu memikirkan stor data asas yang sebenar.

Repositori asas boleh mengakses pangkalan data dengan membina dan melaksanakan pertanyaan SQL, mengakses sistem jauh melalui REST API atau hanya mengurus struktur data dalam memori yang mengandungi semua model domain. Ini berguna untuk ujian. Bahagian utama corak repositori ialah antara muka peringkat tinggi yang disediakannya kepada kod yang lain.

Isi Penting:

• Repositori mewakili koleksi objek domain berkonsepkan.
• Ia hanya bertanggungjawab untuk merangkum akses data dengan antara muka peringkat tinggi.
• Corak repositori Laravel yang popular baru-baru ini (Repositori) tidak menyediakan pembantu khusus untuk melaksanakan corak Repositori

Apabila ia datang untuk melaksanakan corak Repositori dalam Corak repositori Laravel yang popular baru-baru ini (Repositori), saya melihat terutamanya dua variasi.

Variasi 1: Kaedah Khusus

Dalam varian pertama, kaedah repositori difokuskan dan khusus. Nama menerangkan perkara yang pemanggil dapat dan pilihan untuk parameterkan pertanyaan asas adalah terhad.

class InvoiceRepository {

    public function findAllOverdue(Carbon $since, int $limit = 10): Collection {
        return Invoice::where('overdue_since', '>=', $since)
            ->limit($limit)
            ->orderBy('overdue_since')
            ->get();
    }

    public function findInvoicedToCompany(string $companyId): Collection {
        return Invoice::where('company_id', $companyId)
            ->orderByDesc('created_at')
            ->get();
    }
}

Kelebihan kaedah ini terletak pada ekspresi kaedah. Apabila membaca kod, jelas perkara yang diharapkan daripada kaedah dan cara memanggilnya. Ini mengakibatkan lebih sedikit ralat. Kaedah repositori mudah diuji kerana ia mempunyai parameter yang terhad.

Satu kelemahan pendekatan ini ialah anda mungkin akhirnya menggunakan sejumlah besar kaedah dalam repositori. Memandangkan kaedah tidak boleh digunakan semula dengan mudah, kaedah tambahan mesti ditambah untuk kes penggunaan baharu.

Isi Utama:

• Corak storan boleh dilaksanakan dengan menyediakan kelas dengan kaedah tertentu
• Setiap kaedah membungkus pertanyaan, mendedahkan hanya Parameter yang diperlukan
• Kelebihan:Kebolehbacaan dan kebolehujian
• Kelemahan:Kekurangan fleksibiliti dan kebolehgunaan semula yang lebih rendah

Variasi 2: Kaedah umum

Pendekatan sebaliknya menyediakan kaedah umum. Ini membawa kepada pengurangan kaedah. Tetapi kaedah ini mempunyai permukaan API yang besar memandangkan setiap kaedah boleh dipanggil dengan gabungan parameter yang berbeza.

Isu utama ialah perwakilan parameter. Perwakilan ini harus membimbing pemanggil dalam memahami tandatangan kaedah dan mengelakkan input tidak sah. Untuk melakukan ini, anda boleh memperkenalkan kelas khas, contohnya menggunakan corak Objek Pertanyaan.

但是我在实践中经常看到的是标量参数和 PHP 数组的混合。调用方可以传递完全无效的输入，仅类型数据并不能说明要传递什么。但是如果使用得当，这种轻量级的方法可以避免更繁琐的抽象。

class InvoiceRepository {

    public function find(array $conditions, string $sortBy = 'id', string $sortOrder = 'asc', int $limit = 10): Collection {
        return Invoice::where($conditions)
            ->orderBy($sortBy, $sortOrder)
            ->limit($limit)
            ->get();
    }
}

// --- 使用:

$repo = new InvoiceRepository();
$repo->find(['overdue_since', '>=', $since], 'overdue_since', 'asc');
$repo->find(['company_id', '=', $companyId], 'created_at', 'asc', 100);

这种方法减轻了第一种方法的问题：你可以得到更少的 Repository 方法，这些方法更灵活，并且可以更频繁地重用。

从消极的方面看，Repository 变得更加难以测试，因为有更多的案例需要覆盖。方法签名更难理解，正因为如此，调用者可能会犯更多错误。此外，还将引入某种查询对象表示形式。无论它是显式的还是隐式的（比如数组），您的 Repository 实现及其调用者都将与它耦合。

要点:

• 存储库模式可以通过提供通用方法的类实现。
• 难点在于方法参数的表示。
• 优点: 更大的灵活性和更高的可复用性。
• 缺点: 更难测试，可读性差，与参数表示耦合。

当然，这两种方法可以结合起来使用。也许你想要一些特定的方法用于复杂的查询，而一些通用的方法用于简单的 where 查询。

实现

现在，我们来谈谈如何实现方法体。

在上面的例子中，我使用了 Model 类的方法来获得对 Eloquent 查询构造器的访问。所以 Repository 的实现实际上使用了 Active Record 模式作为实现。

你不需要这样做。你可以使用 DB facade 来获得一个查询构建器，同时避免使用 Model 类。或者你可以直接编写 SQL 查询：

class InvoiceRepository {

    public function findAllOverdue(Carbon $since, int $limit = 10): Collection {
        return DB::table('invoices')
            ->where('overdue_since', '>=', $since)
            ->limit($limit)
            ->orderBy('overdue_since')
            ->get();
    }

    public function findInvoicedToCompany(string $companyId): Collection {
        return DB::select('SELECT * FROM invoices
                           WHERE company_id = ?
                           ORDER BY created_at
                           LIMIT 100', [$companyId]);
    }
}

存储模式的优点是，实现可以是任何东西，只要它满足接口。你还可以管理内存中的对象或者包（和缓存）一个 API。

但是最常见的是，底层数据存储是一个 SQL 数据库。要访问它，你可以根据每个方法选择最佳实现。对于性能关键的或者复杂的查询，你可能希望直接使用 SQL 语句。更简单的查询可以使用 Eloquent 查询生成器。

当你没有使用 模型 类来实现你的 Repository ，你可能会考虑在模型中不继承它。但是这个方法违反了很多内置的 Corak repositori Laravel yang popular baru-baru ini (Repositori) 魔术方法，在我看来并不是一个好的方法。

要点:

• 存储库模式很灵活，允许使用各种实现技术。
• 在 Corak repositori Laravel yang popular baru-baru ini (Repositori) 中，当访问数据库时，Eloquent 查询构建器是一个实用的选择。

接口

你的另一个选择是，是否要引入一个接口。上面的例子可以用一个接口和一个或多个实现来分隔：

// --- 接口:

public interface InvoiceRepositoryInterface {

    public function findAllOverdue(Carbon $since, int $limit = 10): Collection;

    public function findInvoicedToCompany(string $companyId): Collection;
}

// --- 具体的类，实现了该接口

class InvoiceRepository implements InvoiceRepositoryInterface {

    public function findAllOverdue(Carbon $since, int $limit = 10): Collection {
        // 实现
    }

    public function findInvoicedToCompany(string $companyId): Collection {
        // 实现
    }
}

添加接口是一种额外的间接方法，并不一定是好的。如果您的应用程序是 Repository 的唯一用户，并且您不希望它有多个实现，那么我不认为引入接口有什么意义。对于测试，Repository 可以用 PHPUnit 模拟，只要它不被标记为 final。

如果你知道你将有多个实现，你应该使用一个接口。如果你正在编写一个将在多个项目中使用的 包。或者你想要测试一个特殊的 Repository 实现，那么可能会发生不同的实现。

为了从 Corak repositori Laravel yang popular baru-baru ini (Repositori) 的依赖注入中获益，你必须将具体的实现绑定到接口上。这必须在服务提供者的注册方法中完成。

use Illuminate\Support\ServiceProvider;

class RepositoryServiceProvider extends ServiceProvider {

    public function register(): void {
        $this->app->bind(InvoiceRepositoryInterface::class, InvoiceRepository::class);
    }
}

要点:

• 一个接口可以进一步 解耦 从代码的其余部分获取代码库。
•  当您期望有多个具体类实现它时，使用 Repository 接口。
• 在 Corak repositori Laravel yang popular baru-baru ini (Repositori) 中，将具体类绑定到服务提供者中的接口。

原文地址：https://dev.to/davidrjenni/repository-pattern-in-laravel-1pph

译文地址：https://learnku.com/laravel/t/62587

Atas ialah kandungan terperinci Corak repositori Laravel yang popular baru-baru ini (Repositori). Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!