prinsip penyongsangan laravel

Laravel ialah rangka kerja PHP yang sangat popular Ia disukai secara meluas oleh pembangun kerana kesederhanaan, keanggunan dan kemudahan penggunaannya. Malah, ciri penting rangka kerja Laravel ialah suntikan kebergantungan (DI) dan penyongsangan kawalan (IoC), yang menjadikan Laravel lebih elegan dan lebih mudah apabila mengendalikan kebergantungan aplikasi. Dalam artikel ini, kami akan menyelam lebih mendalam tentang DI Laravel dan prinsip penyongsangan.

1. Apakah suntikan pergantungan?

Dalam aplikasi, kelas biasanya bergantung pada kelas atau objek lain untuk menyelesaikan tugasnya. Dalam model pengaturcaraan tradisional, kami biasanya membuat kebergantungan ini dalam kelas. Walaupun pendekatan ini mudah dan jelas, ia akan menggabungkan kelas dengan ketat dan kebergantungannya.

Suntikan kebergantungan ialah corak reka bentuk yang memisahkan kelas daripada objek yang bergantung padanya dan menghubungkannya melalui antara muka. Ketergantungan diserahkan kepada kelas dalam pembina, membenarkan kelas menggunakannya pada masa jalan. Oleh itu, suntikan pergantungan boleh menjadikan hubungan antara aplikasi dan kelas lebih fleksibel dan boleh diperluaskan.

2. Suntikan Ketergantungan Laravel

Dalam rangka kerja Laravel, suntikan kebergantungan dilaksanakan melalui bekas perkhidmatan dan pengikatan. Bekas perkhidmatan ialah bekas suntikan kebergantungan Laravel, yang membolehkan anda mengurus dan menyuntik kebergantungan.

Pengikatan ialah mengikat antara muka atau kelas kepada tika dalam bekas perkhidmatan. Setelah pengikatan selesai, anda boleh menggunakan penyelesai bekas untuk membuat instantiate objek ini daripada bekas.

Dalam rangka kerja Laravel, anda boleh menggunakan tiga jenis pengikatan: contoh pengikatan, konteks pengikatan, antara muka pengikatan atau kelas abstrak. Mari kita lihat mereka secara berasingan.

2.1 Contoh Mengikat

Menggunakan tika mengikat sangat berguna apabila anda perlu mendaftarkan objek ke bekas perkhidmatan. Keadaan ini biasanya timbul dalam pengawal kerana kita perlu menyuntik banyak objek yang berbeza ke dalamnya.

Sebagai contoh, katakan kita mempunyai kelas TaskController dan perlu menyuntik objek TaskRepository untuk mengendalikan tugas:

class TaskController extends Controller 
{
    protected $taskRepository;

    public function __constructor(TaskRepository $taskRepository) 
    {
        $this->taskRepository = $taskRepository;
    }
}

Kita boleh menggunakan suntikan kebergantungan untuk menyuntik kebergantungan TaskRepository. Untuk melakukan ini, kita perlu mengikat tika TaskRepository dalam bekas perkhidmatan:

$this->app->bind('TaskRepository', function($app) {
    return new TaskRepository();
});

Dalam contoh di atas, kami menggunakan tika $app untuk mencipta tika baharu TaskRepository dan kemudian mengembalikannya. Sebaik sahaja kami mengikat TaskRepository ke bekas, kami boleh menyuntiknya ke dalam pengawal menggunakan pembina TaskController.

2.2 Konteks pengikat

Konteks pengikatan membolehkan kami mengikat tika kelas dalam bekas perkhidmatan. Apabila kelas diselesaikan, bekas perkhidmatan mula-mula cuba mencari kelas dari konteks mengikat dan kemudian menyuntiknya jika perlu.

Sebagai contoh, berbilang objek TaskRepository boleh digunakan dalam aplikasi kami. Jika kita mengikat kesemuanya ke dalam bekas, maka setiap objek akan menduduki ruang memori, dan apabila kita menggunakan TaskRepository dalam pengawal, tidak ada cara untuk membezakan objek mana yang digunakan.

Untuk menyelesaikan masalah ini, kita boleh menggunakan pengikatan konteks. Ini membolehkan kami mengikat contoh TaskRepository yang berbeza kepada konteks bekas dan membezakan tika yang digunakan melalui nilai Kunci.

Contohnya:

$this->app->when('AppHttpControllersTaskController')
    ->needs('TaskRepository')
    ->give(function ($app) {
        if (session('useMock')) {
            return new TaskRepositoryMock();
        } else {
            return new TaskRepository();
        }
    });

Dalam kod di atas, kami menggunakan kaedah when() bagi bekas perkhidmatan Kaedah ini menerima nama kelas sebagai parameter, yang menunjukkan pembina kelas mana yang memerlukan kebergantungan Inject . Kaedah

needs() memberitahu bekas kebergantungan yang kita perlukan, manakala kaedah give() sebenarnya mengembalikan contoh yang kita perlukan.

2.3 Mengikat antara muka atau kelas abstrak

Dalam Laravel, kami biasanya menggunakan antara muka atau kelas abstrak untuk menentukan kebergantungan luaran. Dalam aplikasi, kami mengikat antara muka atau kelas abstrak ini kepada kelas pelaksanaan sebenar. Ini membolehkan kami menggunakan kebergantungan ini dalam pengawal atau kelas lain tanpa mengambil berat tentang pelaksanaan khusus mereka.

Sebagai contoh, kami mungkin mempunyai antara muka TaskRepository yang mengendalikan beberapa operasi pada tugasan. Kita boleh mengikat antara muka ini kepada kelas konkrit. Dengan cara ini, apabila kita memerlukan objek TaskRepository dalam pengawal, bekas perkhidmatan akan secara automatik mengembalikan contoh daripadanya.

$this->app->bind('TaskRepository', 'TaskRepositoryImpl');

Dalam kod di atas, kami mengikat antara muka TaskRepository ke kelas konkrit bernama TaskRepositoryImpl.

3. Penyongsangan Kawalan

Dalam suntikan pergantungan, Penyongsangan Kawalan (IoC) ialah konsep yang sangat penting. Dalam model pengaturcaraan tradisional, pembangun biasanya bertanggungjawab untuk mencipta objek dan menyelesaikan kebergantungan antara objek. Ini adalah aliran kawalan.

Dalam kawalan penyongsangan, aliran kawalan diterbalikkan. Aplikasi ini tidak lagi bertanggungjawab untuk mencipta dan mengurus objek, sebaliknya rangka kerja atau bekas menguruskan masalah ini. Semua kebergantungan dikendalikan oleh bekas dan bukannya diurus oleh pembangun.

Kelebihan kawalan penyongsangan ialah ia boleh mengurangkan gandingan dalam kod, menjadikan kod lebih fleksibel dan berskala. Ini menjadikan kod kami lebih mudah untuk diuji dan diselenggara.

4. Ringkasan

Dalam artikel ini, kami memperkenalkan suntikan pergantungan dan penyongsangan mekanisme kawalan rangka kerja Laravel. Dengan menggunakan mekanisme ini, kami boleh menjadikan aplikasi kami lebih fleksibel dan berskala, menjadikannya lebih mudah untuk diuji dan diselenggara. Memahami prinsip DI dan penyongsangan Laravel sangat membantu pembangun Jika anda sedang menggunakan Laravel untuk membangunkan aplikasi, anda berharap dapat memahami secara umum DI dan penyongsangan melalui artikel ini.

Atas ialah kandungan terperinci prinsip penyongsangan laravel. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!