Pengenalan terperinci kepada penggunaan suntikan pergantungan dalam Laravel

Laravel ialah rangka kerja timbunan penuh yang memberikan kami banyak fungsi dan alatan yang mudah, salah satunya ialah suntikan kebergantungan. Dalam pembangunan Laravel, menggunakan suntikan kebergantungan membolehkan kami mengatur kod dengan lebih baik, mengurangkan gandingan kod, dan juga menjadikan ujian unit lebih mudah.

Sekarang, mari kita perkenalkan penggunaan suntikan pergantungan dalam Laravel secara terperinci.

1. Definisi Suntikan Ketergantungan

Suntikan Ketergantungan, secara ringkasnya, mencipta objek baharu dengan menghantar objek kebergantungan secara luaran. Dalam istilah orang awam, ini bermakna kebergantungan yang diperlukan oleh objek dibina dari luar dan kemudian dihantar ke objek dalam bentuk parameter pembina, sifat atau parameter kaedah.

Suntikan kebergantungan ialah idea pengaturcaraan, terutamanya digunakan untuk menyelesaikan masalah pergantungan yang kompleks antara modul. Dalam Laravel, suntikan kebergantungan digunakan secara meluas, terutamanya dalam pengawal dan bekas perkhidmatan.

2. Kelebihan Suntikan Ketergantungan

1. Mengurangkan gandingan kod

Suntikan Ketergantungan menjadikan kod lebih berskala dan boleh diganti dengan lebih mudah A kelas tertentu tanpa menjejaskan kod lain. Dengan cara ini, kod yang kami tulis mempunyai kebolehselenggaraan yang lebih baik.

2. Elakkan pertindihan kod

Suntikan kebergantungan boleh mengurangkan pertindihan kod dan mengelakkan lebihan kod yang tidak perlu Jika komponen perlu digunakan beberapa kali, Kami boleh merangkumnya dan hanya memanggilnya apabila diperlukan, dengan itu mengelakkan penulisan kod berulang.

3. Memudahkan ujian unit

Suntikan kebergantungan boleh memudahkan kod untuk ujian unit, kerana kita boleh menyuntik objek bergantung ke dalam objek yang diuji dalam bentuk antara muka , yang memudahkan ujian kami dan boleh mempercepatkan ujian.

3. Cara melaksanakan suntikan pergantungan

Dalam Laravel, terdapat tiga cara untuk melaksanakan suntikan pergantungan: suntikan pembina, suntikan kaedah panggilan dan suntikan atribut.

1. Suntikan konstruktor

Suntikan konstruktor ialah kaedah suntikan pergantungan yang paling biasa. Dalam Laravel, apabila kelas perlu bergantung pada kelas lain, kita boleh mengisytiharkan pergantungan antara mereka dalam pembina.

Contohnya:

class UserController extends BaseController
{
    protected $userService;
 
    public function __construct(UserService $userService)
    {
        $this->userService = $userService;
    }
 
    public function index()
    {
        $users = $this->userService->getAllUsers();
 
        return view('users.index', compact('users'));
    }
}

Dalam contoh di atas, kami mengisytiharkan kebergantungan $userService dalam pembina UserController, dan $userService ialah contoh UserService. UserService di sini ialah perkhidmatan yang kami daftarkan dalam bekas Laravel.

2. Suntikan panggilan kaedah

Suntikan panggilan kaedah membolehkan kami mentakrifkan kaedah dalam kelas yang memerlukan suntikan pergantungan ke dalam beberapa keadaan untuk menyelesaikan beberapa operasi.

Contohnya:

class PostController extends Controller
{
    public function update(PostRequest $request, Post $post)
    {
        $this->postService->update($request, $post)
        return redirect()->route('posts.index');
    }
 
    public function create(PostRequest $request)
    {
        $this->postService->store($request);
        return redirect()->route('posts.index');
    }
 
    protected function postService(PostService $postService)
    {
        $this->postService = $postService;
    }
}

Dalam contoh di atas, kami mentakrifkan dua kaedah bernama kemas kini dan cipta, yang kedua-duanya bergantung pada kejadian PostRequest dan Post. Kami melaksanakan suntikan pergantungan dengan menyuntik PostService ke dalam kaedah melalui suntikan kaedah.

3. Suntikan atribut

Suntikan atribut adalah serupa dengan suntikan kaedah, kecuali objek yang diperlukan disuntik melalui atribut.

Contohnya:

class OrderController extends Controller
{
    /**
     * @var OrderService
     */
    protected $orderService;
 
    /**
     * OrderController constructor.
     * @param OrderService $orderService
     */
    public function __construct(OrderService $orderService)
    {
        $this->orderService = $orderService;
    }
 
    /**
     * @param OrderRequest $request
     * @return \Illuminate\Http\RedirectResponse
     */
    public function store(OrderRequest $request)
    {
        $this->orderService->createOrder($request->all());
        return redirect()->back();
    }
}

Dalam contoh di atas, kami mengisytiharkan harta $orderService dalam kelas OrderController, dan kemudian menyuntik contoh objek OrderService ke dalam harta dalam pembina, Ini membolehkan suntikan atribut.

4. Ringkasan

Suntikan ketergantungan dalam Laravel menyediakan kami cara yang mudah untuk mengurus dan mencipta kebergantungan antara kelas. Dalam pembangunan sebenar, menggunakan suntikan kebergantungan membolehkan kami mengatur kod dengan lebih baik dan meningkatkan kebolehbacaan dan kebolehselenggaraan kod. Oleh itu, sebagai pembangun Laravel, adalah penting untuk menguasai penggunaan suntikan pergantungan.

Atas ialah kandungan terperinci Pengenalan terperinci kepada penggunaan suntikan pergantungan dalam Laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!