Suntikan ketergantungan (DI) dalam PHP meningkatkan modulariti kod, kesesuaian, dan kebolehkerjaan. 1) Ia membolehkan pertukaran komponen mudah, seperti yang dilihat dalam suis gerbang pembayaran. 2) DI boleh dilaksanakan secara manual atau melalui bekas, dengan bekas menambah kerumitan tetapi membantu projek yang lebih besar. 3) Ia memudahkan ujian dengan membolehkan pergantungan pergantungan, menjadikan ujian unit lebih cekap.

Apabila ia datang kepada suntikan ketergantungan (DI) dalam PHP, ia lebih daripada sekadar corak reka bentuk -itu adalah falsafah yang dapat mengubah cara anda membentuk dan mengekalkan kod anda. Suntikan pergantungan menggalakkan gandingan longgar, menjadikan aplikasi anda lebih modular, boleh diuji, dan lebih mudah untuk dikekalkan. Tetapi mengapa anda perlu mengambil berat tentang DI dalam PHP? Kerana ia bukan hanya tentang menulis kod bersih; Ini mengenai aplikasi kerajinan yang berdaya tahan untuk berubah dan lebih mudah untuk berkembang dari masa ke masa.

Mari kita menyelam ke dalam dunia suntikan pergantungan di PHP, di mana kita akan meneroka bukan hanya bagaimana tetapi mengapa dan apa-jika teknik yang kuat ini. Dari suntikan manual untuk menggunakan bekas, kami akan merangkumi semuanya, dengan taburan pengalaman peribadi dan beberapa pelajaran yang dipelajari di sepanjang jalan.

Dalam bidang pembangunan PHP, suntikan ketergantungan (DI) berdiri sebagai suar seni bina perisian moden. Ia adalah satu teknik yang saya sangat bergantung, terutamanya ketika bekerja pada projek berskala besar di mana kebolehpasaran dan kesesuaian tidak hanya bagus tetapi keperluan. DI dalam PHP bukan hanya mengenai suntikan kebergantungan; Ini mengenai mewujudkan sistem di mana komponen mudah dipancarkan, yang membawa kepada asas kod yang lebih fleksibel dan boleh disesuaikan.

Pertimbangkan ini: Anda sedang menjalankan projek, dan tiba -tiba, perubahan keperluan. Dengan DI, menukar satu pelaksanaan untuk yang lain menjadi angin. Saya masih ingat projek di mana kita terpaksa menukar gerbang pembayaran kami. Terima kasih kepada Di, ia adalah satu perkara yang mengubah beberapa baris konfigurasi dan bukannya mimpi buruk refactoring utama.

Mari kita lihat beberapa kod untuk melihat DI dalam tindakan:

 // tanpa DI
Kelas Userservice {
    Pangkalan data $ $ swasta;

    fungsi awam __construct () {
        $ this-> pangkalan data = mysqldatabase baru ();
    }

    fungsi awam getUser ($ id) {
        kembali $ this-> database-> query ("Pilih * dari pengguna di mana id =?", [$ id]);
    }
}

// dengan DI
Kelas Userservice {
    Pangkalan data $ $ swasta;

    Fungsi Awam __Construct (pangkalan data DatabaseInterface $) {
        $ this-> pangkalan data = $ pangkalan data;
    }

    fungsi awam getUser ($ id) {
        kembali $ this-> database-> query ("Pilih * dari pengguna di mana id =?", [$ id]);
    }
}

Dalam contoh DI, kami telah memusnahkan UserService dari pelaksanaan pangkalan data tertentu. Fleksibiliti ini adalah emas ketika datang ke ujian dan masa depan-bukti permohonan anda.

Tetapi DI bukan tanpa cabarannya. Satu perangkap biasa adalah lebih suntikan, di mana anda akhirnya melewati terlalu banyak kebergantungan, menjadikan pembina anda kelihatan seperti pokok Krismas dengan terlalu banyak perhiasan. Ia adalah keseimbangan, dan mencari tahap abstraksi yang betul boleh menjadi bentuk seni.

Ketika datang untuk melaksanakan DI, anda mempunyai pilihan. Anda boleh pergi dengan suntikan manual, yang mudah tetapi boleh menjadi rumit dalam aplikasi yang lebih besar. Atau anda boleh menggunakan bekas DI, yang mengautomasikan banyak proses tetapi memperkenalkan set kerumitannya sendiri. Berikut adalah contoh mudah menggunakan bekas:

 Gunakan psr \ container \ containerInterface;

Kelas Container Melaksanakan ContainerInterface {
    Perkhidmatan $ swasta = [];

    fungsi awam mendapatkan ($ id) {
        jika (! Isset ($ this-> Services [$ id])) {
            membuang baru \ pengecualian ("perkhidmatan {$ id} tidak dijumpai");
        }
        kembali $ this-> perkhidmatan [$ id];
    }

    Fungsi awam mempunyai ($ id) {
        kembali isset ($ this-> perkhidmatan [$ id]);
    }

    Set fungsi awam ($ id, $ perkhidmatan) {
        $ this-> Services [$ id] = $ Service;
    }
}

$ container = container baru ();
$ container-> set ('pangkalan data', mysqldatabase baru ());
$ container-> set ('userService', userService baru ($ container-> get ('Database'))));

$ userservice = $ container-> get ('userservice');
$ user = $ userservice-> getUser (1);

Menggunakan bekas boleh menjadi penukar permainan untuk projek yang lebih besar, tetapi penting untuk memahami perdagangan. Bekas menambah lapisan abstraksi, yang boleh menjadi berkat dan kutukan. Mereka membuat pengurusan ketergantungan lebih mudah, tetapi mereka juga boleh mengaburkan apa yang berlaku di bawah tudung, menjadikannya lebih sukar untuk memahami aliran permohonan anda sekilas.

Dari segi prestasi, DI boleh memperkenalkan sedikit overhead, terutamanya apabila menggunakan bekas. Tetapi dalam kebanyakan kes, faedah jauh melebihi kos. Hit prestasi sebenar datang dari penampilan yang lebih tinggi daripada persediaan DI anda, mewujudkan graf ketergantungan yang kompleks yang sukar untuk menavigasi dan mengoptimumkan.

Jadi, apakah pendekatan terbaik? Ia bergantung pada saiz dan kerumitan projek anda. Untuk projek yang lebih kecil, suntikan manual mungkin semua yang anda perlukan. Bagi yang lebih besar, bekas boleh menjimatkan banyak sakit kepala. Tetapi tanpa mengira kaedah, kunci adalah untuk memastikan kebergantungan anda jelas dan boleh diurus.

Dalam pengalaman saya, kelebihan terbesar DI adalah dalam ujian. Dengan DI, ujian unit menulis menjadi kegembiraan dan bukannya tugas. Anda boleh dengan mudah mengejek kebergantungan, menjadikan ujian anda lebih terfokus dan kurang rapuh. Berikut adalah contoh cepat bagaimana DI memudahkan ujian:

 Kelas UserserviceTest memanjangkan phpunit \ rangka kerja \ testcase {
    fungsi awam testgetuser () {
        $ mockDatabase = $ this-> createMock (DatabaseInterface :: class);
        $ mockDatabase-> menjangkakan ($ this-> once ())
                     -> Kaedah ('pertanyaan')
                     -> dengan ("Pilih * dari pengguna di mana id =?", [1])
                     -> willreturn (['id' => 1, 'name' => 'John Doe']);

        $ userservice = New userService ($ mockDatabase);
        $ user = $ userservice-> getUser (1);

        $ this-> AssertEquals (['id' => 1, 'name' => 'John Doe'], $ user);
    }
}

Dengan DI, anda bukan hanya menulis kod yang lebih baik; Anda menyediakan projek anda untuk berjaya dalam jangka masa panjang. Ini mengenai memeluk perubahan, menjadikan kod anda lebih berdaya tahan, dan pada akhirnya, lebih bersenang -senang sebagai pemaju.

Jadi, sama ada anda baru bermula dengan PHP atau anda seorang pro yang berpengalaman, memberikan suntikan pergantungan. Ia mungkin hanya mengubah cara anda berfikir tentang pengekodan.

Atas ialah kandungan terperinci Suntikan Ketergantungan di PHP: Panduan Ultimate. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!