Membawa anda langkah demi langkah untuk memahami suntikan pergantungan dalam laravel

1. Apakah Suntikan Ketergantungan

Suntikan Ketergantungan ialah corak reka bentuk yang mencapai penyahgandingan objek dengan menghantar objek bergantung kepada objek. Dalam erti kata lain, suntikan kebergantungan ialah teknologi yang menghantar objek bergantung melalui pembina, sifat atau kaedah, menjadikan hubungan antara kelas lebih longgar dan mengurangkan gandingan kod.

Dalam rangka kerja Laravel, suntikan kebergantungan ialah konsep yang sangat penting. Ia adalah asas untuk melaksanakan Penyongsangan Kawalan dalam Laravel.

2. Cara Laravel melaksanakan suntikan pergantungan

Rangka kerja Laravel menggunakan kelas Refleksi terbina dalam PHP untuk melaksanakan suntikan pergantungan. Kelas Refleksi digunakan terutamanya untuk mendapatkan pelbagai maklumat tentang kelas, termasuk kaedah kelas, atribut, anotasi, dll.

1. Prinsip suntikan kebergantungan

Dalam rangka kerja Laravel, suntikan kebergantungan dilaksanakan melalui bekas perkhidmatan (Service Container). Bekas perkhidmatan ialah komponen penting rangka kerja Laravel Ia adalah bekas suntikan pergantungan yang digunakan untuk membuat instantiate dan mengurus objek kelas.

Dalam rangka kerja Laravel, pembangun boleh melaksanakan suntikan kebergantungan dengan cara berikut:

• Isytihar kebergantungan dalam pembina pengawal
• Dalam kaedah pengawal Isytiharkan kebergantungan
• Gunakan fungsi penutupan untuk menjana objek

Di bawah ini kami akan menerangkan prinsip pelaksanaan ketiga-tiga kaedah ini satu demi satu.

2. Isytiharkan kebergantungan dalam pembina pengawal

Dalam rangka kerja Laravel, pengawal biasanya dilaksanakan melalui suntikan kebergantungan. Dalam pengawal, kita boleh mengisytiharkan kebergantungan menggunakan pembina, dan rangka kerja Laravel secara automatik akan membuat seketika objek kebergantungan yang diperlukan melalui mekanisme pantulan.

Sebagai contoh, kami mempunyai kelas UserController yang perlu bergantung pada kelas UserService, yang boleh dicapai dengan cara berikut:

use App\Services\UserService;

class UserController extends Controller
{
    protected $userService;

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

    public function getUser($id)
    {
        $user = $this->userService->getUser($id);
        return view('user', compact('user'));
    }
}

Dalam kod di atas, kami mengisytiharkan kebergantungan melalui Object $userService pembina. Apabila kelas UserController dijadikan instantiated, rangka kerja Laravel secara automatik menyuntik contoh UserService yang diperlukan.

3. Isytiharkan kebergantungan dalam kaedah pengawal

Dalam beberapa senario khas, kita mungkin perlu mengisytiharkan kebergantungan dalam kaedah pengawal. Sebagai contoh, apabila kita perlu menggunakan beberapa perpustakaan kelas tambahan, kita boleh mencapainya melalui suntikan kaedah.

Sebagai contoh, kami mempunyai kelas UserController yang perlu menggunakan perpustakaan cache, yang boleh dilaksanakan dengan cara berikut:

use Illuminate\Cache\Repository;

class UserController extends Controller
{
    public function getUser($id, Repository $cache)
    {
        $user = $cache->get('user_' . $id, function() use($id) {
            $userService = app(UserService::class);
            return $userService->getUser($id);
        });

        return view('user', compact('user'));
    }
}

Dalam kod di atas, kami mengisytiharkannya melalui parameter dalam kaedah getUser Objek bergantung $cache dicipta. Apabila kaedah getUser dipanggil, rangka kerja Laravel secara automatik menyuntik contoh Repositori yang diperlukan.

4. Gunakan fungsi penutupan untuk menjana objek

Selain dua kaedah sebelumnya, kami juga boleh menjana objek melalui fungsi penutupan dan menyerahkan objek kepada rangka kerja Laravel untuk pengurusan. Pendekatan ini biasanya digunakan untuk menyelesaikan beberapa kebergantungan khas, seperti kelas pelaksanaan antara muka dan kelas abstrak.

Sebagai contoh, kami mempunyai kelas UserController yang perlu menggunakan antara muka, yang boleh dilaksanakan dengan cara berikut:

use App\Repositories\UserRepository;
use App\Services\UserService;
use Illuminate\Contracts\Container\Container;

class UserController extends Controller
{
    protected $container;

    public function __construct(Container $container)
    {
        $this->container = $container;
    }

    public function getUser($id)
    {
        $userService = $this->container->make(UserService::class, [
            'userRepository' => $this->container->make(UserRepository::class),
        ]);

        $user = $userService->getUser($id);
        return view('user', compact('user'));
    }
}

Dalam kod di atas, kami menyuntik objek Container dalam pembina, Kemudian objek UserService dijana melalui kaedah make, dan objek UserRepository diserahkan kepada kaedah make sebagai parameter.

Melalui kaedah di atas, kami boleh melaksanakan suntikan pergantungan dalam rangka kerja Laravel untuk menjadikan kod lebih fleksibel dan berskala.

3. Ringkasan

Suntikan kebergantungan ialah konsep yang sangat penting dalam rangka kerja Laravel Ia mencapai tujuan penyahgandingan objek dengan menghantar objek bergantung kepada objek. Rangka kerja Laravel menggunakan kelas refleksi terbina dalam PHP untuk melaksanakan suntikan pergantungan, menjadikan hubungan antara kelas lebih longgar dan mengurangkan gandingan kod.

Dalam rangka kerja Laravel, kami boleh melaksanakan suntikan pergantungan melalui pembina pengawal, kaedah pengawal dan fungsi penutupan. Kaedah yang berbeza sesuai untuk senario yang berbeza, dan pembangun boleh memilih kaedah yang sesuai untuk pelaksanaan berdasarkan keperluan sebenar.

Atas ialah kandungan terperinci Membawa anda langkah demi langkah untuk memahami suntikan pergantungan dalam laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!