Suntikan ketergantungan (DI) dalam PHP adalah corak reka bentuk yang menggalakkan gandingan longgar, kesesuaian, dan kebolehkerjaan dengan menguruskan kebergantungan objek secara luaran. 1) DI Mencapai penyongsangan kawalan dengan menyuntik kebergantungan melalui parameter pembina, setter, atau kaedah. 2) Menggunakan bekas DI seperti Pimple atau bekas terbina dalam Laravel boleh menguruskan graf pergantungan yang kompleks. 3) Amalan terbaik termasuk menjaga kebergantungan eksplisit dan menggunakan objek mengejek untuk ujian, meningkatkan kebolehbacaan kod dan kebolehpercayaan.

Ketika datang untuk memahami suntikan ketergantungan (DI) dalam PHP, kami menyelam ke dalam konsep yang bukan hanya tentang menulis kod bersih, tetapi secara asasnya mengubah cara kami mendekati reka bentuk perisian. Suntikan ketergantungan adalah corak reka bentuk yang membolehkan kita mencapai penyongsangan kawalan (IOC), di mana kawalan ke atas bagaimana objek dicipta dan berwayar bersama -sama dialihkan dari kod aplikasi ke rangka kerja luaran atau bekas. Peralihan ini boleh membawa kepada kod yang lebih fleksibel, boleh diuji, dan dikekalkan.

Sekarang, mari kita meneroka dunia DI di PHP, di mana saya akan berkongsi bukan hanya mekanik tetapi juga falsafah di belakangnya, bersama dengan beberapa pengalaman peribadi yang menyerlahkan kesannya terhadap pembangunan.

Suntikan ketergantungan, pada terasnya, adalah mengenai menguruskan kebergantungan antara objek. Daripada mempunyai kelas mewujudkan kebergantungannya sendiri, kebergantungan tersebut "disuntik" ke dalam kelas dari luar. Ini boleh dilakukan melalui pembina, setter, atau parameter kaedah.

Berikut adalah contoh mudah suntikan pembina:

 Logger Kelas {
    log fungsi awam ($ mesej) {
        Echo $ mesej. "\ n";
    }
}

Kelas Userservice {
    Swasta $ Logger;

    fungsi awam __construct (logger $ logger) {
        $ this-> logger = $ logger;
    }

    Fungsi Awam RegisterUser ($ nama pengguna) {
        $ this-> logger-> log ("pendaftaran pengguna: $ username");
        // logik pendaftaran pengguna
    }
}

$ logger = baru logger ();
$ userservice = New userService ($ logger);
$ userservice-> registerUser ("john_doe");

Dalam contoh ini, UserService bergantung kepada Logger . Daripada membuat Logger di dalam UserService , kami menyuntiknya melalui pembina. Pendekatan ini menghilangkan UserService dari pelaksanaan Logger tertentu, menjadikannya lebih mudah untuk menguji dan mengekalkan.

Keindahan DI terletak pada keupayaannya untuk menggalakkan gandingan longgar. Apabila saya mula menggunakan DI, saya kagum bagaimana ia mengubah asas kod saya. Kelas menjadi lebih tertumpu kepada tanggungjawab utama mereka, dan menukar kebergantungan untuk ujian atau pelaksanaan yang berbeza menjadi angin.

Walau bagaimanapun, DI bukan tanpa cabarannya. Satu perangkap biasa adalah mengatasi graf pergantungan. Saya telah melihat projek -projek di mana bilangan kebergantungan berkembang secara eksponen, yang membawa kepada mimpi ngeri konfigurasi. Adalah penting untuk menyerang keseimbangan dan hanya menyuntik apa yang benar -benar diperlukan.

Satu lagi aspek yang perlu dipertimbangkan ialah kesan prestasi. Walaupun kontena DI boleh menambah beberapa rangka kerja PHP moden seperti Laravel dan Symfony telah mengoptimumkan sistem DI mereka untuk menjadi sangat cekap. Namun, ia patut memaparkan permohonan anda untuk memastikan bahawa DI tidak menjadi hambatan.

Apabila melaksanakan DI, saya dapati bahawa menggunakan bekas DI boleh menjadi sangat bermanfaat. Bekas seperti Pimple atau bekas terbina dalam Laravel boleh menguruskan kerumitan penciptaan objek dan kitaran hayat, menjadikannya lebih mudah untuk menguruskan kebergantungan merentasi aplikasi yang besar.

Inilah contoh menggunakan jerawat:

 Gunakan jerawat \ container;

$ container = container baru ();

$ container ['logger'] = function ($ c) {
    mengembalikan logger baru ();
};

$ container ['user_service'] = function ($ c) {
    kembali pengguna baru ($ c ['logger']);
};

$ userservice = $ container ['user_service'];
$ userservice-> registerUser ("jane_doe");

Menggunakan bekas seperti ini dapat memudahkan proses menguruskan kebergantungan, terutama dalam aplikasi yang lebih besar. Walau bagaimanapun, penting untuk menggunakan bekas dengan bijak. Lebih bergantung pada bekas boleh membawa kepada situasi di mana permohonan itu ditambah dengan ketat kepada bekas itu sendiri, yang mengalahkan tujuan DI.

Dari segi amalan terbaik, saya telah belajar bahawa penting untuk menjaga kebergantungan eksplisit. Daripada menyuntik bekas perkhidmatan yang besar, suntikan hanya kebergantungan khusus yang diperlukan oleh kelas. Pendekatan ini bukan sahaja menjadikan kod lebih mudah dibaca tetapi juga membantu dalam mengenal pasti potensi yang bergantung kepada.

Ujian adalah satu lagi kawasan di mana DI bersinar. Dengan menyuntik objek mengejek, anda boleh mengasingkan unit yang anda uji, menjadikan ujian anda lebih dipercayai dan lebih cepat. Berikut adalah contoh mudah bagaimana anda boleh menggunakan phpunit untuk menguji UserService dengan logger mock:

 Gunakan phpunit \ rangka kerja \ testcase;
Gunakan phpunit \ rangka kerja \ mockoBject \ mockoBject;

Kelas UserserviceTest Extends TestCase {
    fungsi awam TestRegisterUser () {
        /** @var logger | mockobject $ logger*/
        $ logger = $ this-> createMock (logger :: class);
        $ logger-> menjangkakan ($ this-> sekali ())
               -> kaedah ('log')
               -> dengan ('pendaftaran pengguna: test_user');

        $ userservice = New userService ($ logger);
        $ userservice-> registerUser ('test_user');
    }
}

Ujian ini memastikan bahawa kaedah log dipanggil dengan mesej yang betul, tanpa benar -benar membuat contoh Logger .

Kesimpulannya, suntikan pergantungan dalam PHP adalah alat yang berkuasa yang dapat meningkatkan reka bentuk dan pemeliharaan aplikasi anda dengan ketara. Ia bukan hanya mengenai suntikan objek; Ini mengenai memeluk falsafah gandingan longgar dan kesesuaian. Walaupun ia datang dengan cabaran tersendiri, faedah jauh melebihi kos apabila dilaksanakan dengan bijak. Perjalanan saya dengan DI telah mengajar saya untuk sentiasa mempertimbangkan kesan yang lebih luas dari pilihan reka bentuk saya, dan saya harap penerokaan ini membantu anda di jalan anda untuk menulis lebih banyak kod PHP yang mantap dan fleksibel.

Atas ialah kandungan terperinci Memahami Suntikan Ketergantungan (DI) dalam PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!