Cara menggunakan suntikan kebergantungan laravel

Dependency Injection ialah corak reka bentuk yang boleh mengurangkan kerumitan kod dan meningkatkan kebolehselenggaraan dan kebolehujian kod Ia merupakan teknologi penting dalam pembangunan aplikasi PHP moden. Laravel ialah rangka kerja PHP popular yang disertakan dengan bekas suntikan kebergantungan yang boleh membantu kami mengurus penciptaan dan pelepasan objek dengan lebih baik. Dalam artikel ini, kita akan belajar cara menggunakan ciri suntikan kebergantungan Laravel.

1. Apakah suntikan pergantungan Laravel?

Suntikan ketergantungan ialah corak pengaturcaraan yang boleh mengurangkan gandingan dengan menghantar kebergantungan satu objek kepada objek lain yang memanggilnya. Dalam pengaturcaraan berorientasikan objek, terdapat kebergantungan antara pelbagai bahagian yang membentuk objek Setiap objek perlu bergantung pada contoh objek lain untuk berfungsi dengan baik. Tujuan suntikan kebergantungan adalah untuk memisahkan kebergantungan ini dari dalam objek, supaya kebergantungan objek diuruskan oleh bekas luaran.

Untuk aplikasi PHP, proses suntikan kebergantungan secara amnya dibahagikan kepada langkah berikut:

1. Tentukan kebergantungan: Tentukan objek atau nilai lain yang bergantung pada setiap objek.
2. Konfigurasikan bekas: Daftarkan tika objek yang diperlukan ke dalam bekas.
3. Selesaikan kebergantungan: Apabila kaedah sesuatu objek perlu dipanggil, bekas itu secara automatik menyelesaikan kejadian objek lain yang bergantung padanya.

Bekas suntikan kebergantungan Laravel ialah alat yang sangat berkuasa yang boleh menyelesaikan masalah pengurusan kebergantungan dengan mudah.

2. Penggunaan suntikan pergantungan dalam Laravel

Mari lihat cara menggunakan suntikan pergantungan dalam Laravel.

1. Mendaftarkan tika objek

Dalam Laravel, kita boleh menggunakan kaedah bind bekas untuk mendaftarkan tika objek. Sebagai contoh, kami ingin mendaftarkan objek UserService dan menambah kod berikut dalam pembekal perkhidmatan:

public function register()
{
    $this->app->bind(UserService::class, function($app) {
        return new UserService($app->make(UserRepository::class));
    });
}

Di sini kami menggunakan kaedah bind untuk mendaftarkan UserService ke dalam bekas dan menentukan fungsi penutupan untuk mencipta contoh objek. Dalam fungsi penutupan, kami menggunakan kaedah buat bekas untuk mendapatkan objek UserRepository yang bergantung kepada UserService.

2. Menggunakan Suntikan Ketergantungan

Sekarang kita telah mendaftarkan objek UserService dalam bekas, bagaimana untuk menggunakannya dalam pengawal? Ia sangat mudah, kita hanya perlu menentukan parameter UserService dalam pembina pengawal. Contohnya:

use App\Services\UserService;

class UserController extends Controller
{
    private $user;

    public function __construct(UserService $user)
    {
        $this->user = $user;
    }
}

Di sini kami mentakrifkan parameter objek UserService dalam pembina UserController. Kami tidak perlu mencipta objek UserService secara manual, Laravel secara automatik akan menyuntiknya ke dalam parameter pembina.

3. Selesaikan kebergantungan secara automatik

Bekas suntikan kebergantungan Laravel boleh menyelesaikan kebergantungan secara automatik, membolehkan kami menggunakan suntikan kebergantungan dengan mudah. Sebagai contoh, kami mendaftarkan kod berikut dalam pembekal perkhidmatan:

public function register()
{
    $this->app->bind(UserService::class, function($app) {
        return new UserService($app->make(UserRepository::class));
    });
}

Kemudian kami boleh menggunakan UserService terus dalam pembina UserController:

use App\Services\UserService;

class UserController extends Controller
{
    private $user;

    public function __construct(UserService $user)
    {
        $this->user = $user;
    }
}

Apabila kami membina objek UserController , Laravel secara automatik akan mengesan bahawa ia memerlukan objek UserService, dan kemudian secara automatik mencipta objek UserService dan menyuntiknya ke dalam UserController.

4. Pass parameter

Kadangkala kita perlu lulus parameter semasa penciptaan objek Contohnya, apabila kita mencipta objek UserService, kita perlu menghantar objek UserRepository.

Kita boleh mencapai fungsi ini dengan menghantar parameter apabila mengikat objek. Contohnya:

public function register()
{
    $this->app->bind(UserService::class, function($app, $parameters) {
        return new UserService($parameters['userRepository']);
    });
}

$userService = app(UserService::class, ['userRepository' => new UserRepository()]);

Ini mencipta objek UserService dan memberikannya objek UserRepository baharu.

5. Kebergantungan diwarisi

Kadangkala berbilang kelas bergantung pada kelas yang sama dan kami boleh menggunakan warisan untuk memudahkan kod suntikan kebergantungan. Contohnya:

class BaseService
{
    protected $repository;

    public function __construct(BaseRepository $repository)
    {
        $this->repository = $repository;
    }
}

class UserService extends BaseService
{
    public function __construct(UserRepository $userRepository)
    {
        parent::__construct($userRepository);
    }
}

Di sini kami mentakrifkan kelas BaseService untuk mengurus kebergantungan objek BaseRepository dan mewarisi kelas BaseService dalam kelas UserService. Dengan cara ini, objek BaseRepository boleh digunakan secara langsung dalam UserService.

3. Ringkasan

Bekas suntikan kebergantungan Laravel ialah alat yang sangat berkuasa yang boleh menyelesaikan masalah pengurusan pergantungan dengan mudah. Apabila menggunakan suntikan kebergantungan Laravel, anda perlu memberi perhatian kepada beberapa butiran:

1. Tentukan kebergantungan: Tentukan objek atau nilai lain yang bergantung pada setiap objek, dan gunakan kaedah bind untuk mendaftarkannya dalam pembekal perkhidmatan ke dalam bekas.
2. Gunakan suntikan kebergantungan: Tentukan parameter objek dalam pengawal dan tempat lain di mana tika objek perlu digunakan secara automatik akan menyelesaikan kebergantungan dan menyuntik objek semasa pelaksanaan.
3. Parameter lulus: Anda boleh menggunakan parameter untuk menghantar objek bergantung semasa penciptaan objek.
4. Kebergantungan diwarisi: Warisan boleh digunakan untuk memudahkan kod suntikan kebergantungan.

Atas ialah kandungan terperinci Cara menggunakan suntikan kebergantungan laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!