Anda harus mengambil berat tentang suntikan ketergantungan (DI) kerana ia menjadikan kod anda lebih jelas dan lebih mudah untuk dijaga. 1) Di menjadikannya lebih modular dengan decoupling kelas, 2) meningkatkan kemudahan ujian dan fleksibiliti kod, 3) menggunakan bekas DI untuk menguruskan kebergantungan kompleks, tetapi memberi perhatian kepada kesan prestasi dan kebergantungan bulat, 4) Amalan terbaik adalah bergantung kepada antara muka abstrak untuk mencapai gandingan longgar.

Ketika datang untuk memahami suntikan ketergantungan (DI) dalam PHP, anda mungkin tertanya -tanya, "Kenapa saya harus mengambil berat tentang corak ini?" Nah, beritahu saya, DI bukan sekadar istilah mewah yang dibuang dalam kalangan perisian; Ia adalah penukar permainan untuk menulis kod yang lebih bersih, lebih terawat. Dengan merobohkan kelas anda dan menjadikannya lebih modular, anda akan mendapati bahawa ujian menjadi angin, dan kod anda menjadi lebih fleksibel. Tetapi, seperti mana -mana alat yang berkuasa, ia bukan tanpa cabarannya. Mari kita menyelam ke dunia Di dalam PHP, meneroka nuansa, berkongsi beberapa pengalaman peribadi, dan memberi anda asas yang kukuh untuk bermula dengan.

Sekarang, mari kita dapatkan tangan kita dengan kod. Bayangkan anda sedang menjalankan projek di mana anda perlu menghantar e -mel. Tanpa DI, kelas anda mungkin kelihatan seperti ini:

 Kelas E -melService {
    fungsi awam SendeMail ($ to, $ subjek, $ body) {
        // Logik menghantar e -mel hardcoded
        mel ($ to, $ subjek, $ body);
    }
}

Kelas UserController {
    Fungsi Awam RegisterUser ($ e -mel) {
        $ e -melService = baru e -melService ();
        $ e-melService-> SendeMail ($ e-mel, 'selamat datang!', 'Terima kasih kerana mendaftar!');
    }
}

Pendekatan ini ketat dan tidak fleksibel. Bagaimana jika anda ingin menukar perkhidmatan e -mel atau menguji UserController tanpa menghantar e -mel? Itulah di mana Di masuk, menawarkan cara untuk menyuntik kebergantungan dan bukannya mengasah mereka.

Berikut adalah contoh mudah bagaimana DI dapat mengubah kod anda:

 Interface EmailServiceInterface {
    fungsi awam SendeMail ($ to, $ subjek, $ body);
}

Kelas e -melservice melaksanakan e -melServiceInterface {
    fungsi awam SendeMail ($ to, $ subjek, $ body) {
        // Logik menghantar e -mel
        mel ($ to, $ subjek, $ body);
    }
}

Kelas UserController {
    Private $ EmailService;

    Fungsi Awam __Construct (EmailServiceInterface $ EmailService) {
        $ this-> emailService = $ e-melService;
    }

    Fungsi Awam RegisterUser ($ e -mel) {
        $ this-> EmailService-> SendeMail ($ e-mel, 'selamat datang!', 'Terima kasih kerana mendaftar!');
    }
}

// Penggunaan
$ e -melService = baru e -melService ();
$ usercontroller = new UserController ($ e -melService);
$ usercontroller-> registeruser ('user@example.com ');

Dalam versi yang disemak semula ini, UserController tidak lagi mewujudkan EmailService itu sendiri. Sebaliknya, ia disuntik melalui pembina. Pemisahan kebimbangan ini menjadikan kod anda lebih dapat diuji dan fleksibel. Anda boleh dengan mudah menukar EmailService untuk objek mengejek dalam ujian unit atau menggantikannya dengan pelaksanaan yang berbeza jika diperlukan.

Sekarang, mari kita bercakap tentang beberapa nuansa dan potensi perangkap DI. Satu cabaran biasa ialah menguruskan kerumitan graf ketergantungan. Apabila aplikasi anda berkembang, anda mungkin mendapati diri anda menyesuaikan diri dengan banyak kebergantungan, yang boleh membawa kepada fenomena yang dikenali sebagai "pembina overjection." Inilah contoh apa yang harus dielakkan:

 kelas overIrectedClass {
    fungsi awam __construct (
        Dependensi $ DePa,
        Ketergantungan $ depb,
        Ketergantungan $ depc,
        DependencyD $ DEPD,
        // ... lebih banyak kebergantungan
    ) {
        // ...
    }
}

Ini boleh menjadikan kelas anda sukar difahami dan dikekalkan. Untuk mengurangkan ini, pertimbangkan untuk menggunakan bekas DI, yang boleh menguruskan kebergantungan ini untuk anda. Inilah contoh mudah menggunakan bekas:

 bekas kelas {
    swasta $ contoh = [];

    fungsi awam mendapatkan ($ className) {
        jika (! isset ($ this-> instances [$ className])) {
            $ this-> contoh [$ className] = new $ className ();
        }
        kembali $ this-> contoh [$ classname];
    }
}

$ container = container baru ();
$ e-melService = $ container-> Get (EmailService :: Class);
$ usercontroller = new UserController ($ e -melService);

Menggunakan bekas membantu kebergantungan pengurusan, tetapi ia memperkenalkan cabarannya sendiri. Anda mungkin mendapati diri anda berurusan dengan kebergantungan bulat atau bergelut dengan konfigurasi bekas. Nasihat saya? Mulakan mudah. Gunakan manual di jika mungkin, dan hanya memperkenalkan bekas apabila kerumitan aplikasi anda membenarkannya.

Satu lagi aspek yang perlu dipertimbangkan ialah kesan prestasi DI. Walaupun manfaat fleksibiliti dan kesesuaian adalah jelas, terdapat overhead kecil yang berkaitan dengan suntikan suntikan. Dalam kebanyakan kes, overhead ini boleh diabaikan, tetapi ia patut disedari, terutamanya dalam aplikasi berprestasi tinggi.

Dari segi amalan terbaik, sentiasa bertujuan untuk gandingan longgar. Kelas anda bergantung kepada abstraksi (antara muka) dan bukannya pelaksanaan konkrit. Ini menjadikannya lebih mudah untuk menukar atau menggantikan komponen tanpa menjejaskan seluruh sistem anda. Di samping itu, pertimbangkan untuk menggunakan suntikan setter untuk ketergantungan pilihan, yang boleh berguna apabila anda perlu mengkonfigurasi objek selepas ia dibuat.

Akhirnya, izinkan saya berkongsi pengalaman peribadi. Pada awal karier saya, saya bekerja di projek di mana kami tidak menggunakan DI, dan ia menjadi mimpi ngeri untuk menguji dan mengekalkan. Setiap perubahan diperlukan menyentuh pelbagai kelas, dan suite ujian kami rapuh. Selepas refactoring untuk menggunakan DI, perbezaannya adalah malam dan siang. Kod kami menjadi modular, dan ujian kami lebih mantap. Ia adalah pelajaran yang saya bawa dengan saya sejak itu.

Oleh itu, di sana anda memilikinya -panduan pemula untuk suntikan ketergantungan di PHP, lengkap dengan contoh kod dan pandangan tentang kebaikan dan keburukannya. Merangkul DI, tetapi gunakan dengan bijak, dan anda akan mendapati kod anda menjadi lebih mudah diurus dan berskala. Selamat pengekodan!

Atas ialah kandungan terperinci Suntikan Ketergantungan dalam PHP: Contoh Kod untuk Pemula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!