Melaksanakan suntikan ketergantungan (DI) dalam PHP boleh dilakukan dengan suntikan manual atau menggunakan bekas DI. 1) Suntikan manual melepasi kebergantungan melalui pembina, seperti kelas penyuntik kelas pengguna. 2) Gunakan kontena DI untuk menguruskan kebergantungan secara automatik, seperti kelas kontena untuk menguruskan Logger dan UserService. Melaksanakan DI boleh meningkatkan fleksibiliti dan kesesuaian kod, tetapi anda perlu memberi perhatian kepada perangkap seperti overinjection dan anti-mode pencari perkhidmatan.

Ketika datang untuk melaksanakan suntikan ketergantungan (DI) dalam PHP, ia bukan hanya tentang menulis kod yang lebih bersih, lebih banyak dikekalkan; Ini mengenai memeluk falsafah yang dapat mengubah cara anda mendekati pembangunan perisian. Suntikan ketergantungan adalah corak reka bentuk yang membolehkan anda meremehkan penciptaan kebergantungan dari kod yang menggunakannya, yang membawa kepada aplikasi yang lebih fleksibel dan boleh diuji. Tetapi mengapa anda perlu mengambil berat tentang DI dalam PHP? Mari kita menyelam dan meneroka bukan hanya bagaimana, tetapi kenapa dan apa-jika melaksanakan DI dalam projek PHP anda.

Mari kita mulakan dengan memahami apa suntikan ketergantungan benar -benar bermakna dalam konteks PHP. Bayangkan anda sedang membina aplikasi yang kompleks dengan pelbagai komponen. Setiap komponen mungkin perlu berinteraksi dengan orang lain, seperti sambungan pangkalan data atau perkhidmatan pembalakan. Secara tradisinya, anda mungkin menghidupkan kod ini secara langsung ke dalam kelas anda, yang boleh membawa kepada gandingan yang ketat dan menjadikan kod anda lebih sukar untuk menguji dan mengekalkan. Suntikan ketergantungan membalikkan skrip ini dengan membolehkan anda lulus kebergantungan ini ke dalam kelas anda dari luar, dan bukannya membuatnya secara dalaman.

Berikut adalah contoh mudah untuk menggambarkan konsep:

 Logger Kelas {
    log fungsi awam ($ mesej) {
        echo "pembalakan: $ 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 di sini
    }
}

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

Dalam contoh ini, UserService bergantung kepada Logger , tetapi bukannya membuat contoh Logger di dalam UserService , kami menyuntiknya melalui pembina. Pendekatan ini menjadikan UserService lebih fleksibel kerana kita dapat dengan mudah menukar pelaksanaan Logger yang berbeza tanpa menukar UserService .

Sekarang, mari kita bincangkan cara yang berbeza untuk melaksanakan DI dalam PHP. Anda boleh melakukannya secara manual, seperti yang ditunjukkan di atas, atau menggunakan bekas DI. Kontena DI adalah alat yang mengautomasikan proses mencipta dan menguruskan kebergantungan. Berikut adalah cara anda boleh menggunakan bekas Di Container:

 bekas kelas {
    Perkhidmatan $ swasta = [];

    Set Fungsi Awam ($ Nama, $ Perkhidmatan) {
        $ this-> Services [$ name] = $ Service;
    }

    fungsi awam dapatkan ($ nama) {
        jika (! Isset ($ this-> Services [$ name])) {
            Buang pengecualian baru ("Perkhidmatan $ Nama Tidak Ditemui");
        }
        kembali $ this-> perkhidmatan [$ name];
    }
}

$ container = container baru ();
$ container-> set ('logger', logger baru ());
$ container-> set ('userservice', userService baru ($ container-> get ('logger'))));

$ userservice = $ container-> get ('userservice');
$ userservice-> registerUser ("jane_doe");

Menggunakan bekas DI boleh memudahkan pengurusan kebergantungan, terutamanya dalam aplikasi yang lebih besar. Walau bagaimanapun, penting untuk mempertimbangkan perdagangan. Walaupun bekas boleh membuat kod anda lebih mudah diurus, mereka juga boleh memperkenalkan kerumitan dan overhead. Anda perlu menimbang manfaat menggunakan bekas terhadap kesederhanaan suntikan manual.

Apabila melaksanakan DI, anda mungkin menghadapi beberapa perangkap biasa. Salah satu suntikan, di mana anda menyuntik terlalu banyak kebergantungan ke dalam kelas, menjadikannya sukar untuk difahami dan dikekalkan. Satu lagi ialah corak pencari perkhidmatan, di mana bukannya menyuntik kebergantungan, anda menyuntik bekas dan menggunakannya untuk mengambil kebergantungan, yang boleh menyebabkan kebergantungan tersembunyi dan menjadikan kod anda kurang telus.

Untuk mengelakkan perangkap ini, ikuti amalan terbaik ini:

• Pastikan kelas anda memberi tumpuan kepada satu tanggungjawab untuk meminimumkan bilangan kebergantungan.
• Gunakan antara muka untuk menentukan kebergantungan, yang membolehkan penukaran pelaksanaan yang lebih mudah.
• Elakkan menggunakan corak pencari perkhidmatan; Sebaliknya, suntikan kebergantungan secara langsung.

Mari lihat contoh menggunakan antara muka dengan DI:

 Interface LoggerInterface {
    log fungsi awam ($ mesej);
}

Kelas Consolelogger melaksanakan LoggerInterface {
    log fungsi awam ($ mesej) {
        echo "Console: $ mesej \ n";
    }
}

Kelas FileLogger melaksanakan LoggerInterface {
    log fungsi awam ($ mesej) {
        file_put_contents ('log.txt', $ mesej. "\ n", file_append);
    }
}

Kelas Userservice {
    Swasta $ Logger;

    Fungsi awam __Construct (loggerInterface $ logger) {
        $ this-> logger = $ logger;
    }

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

$ consoleLogger = consolelogger baru ();
$ fileLogger = new FileLogger ();

$ userserviceWithConsole = New userService ($ consoleLogger);
$ userserviceWithFile = New userService ($ fileLogger);

$ userserviceWithConsole-> registerUser ("Alice");
$ userserviceWithFile-> RegisterUser ("Bob");

Dalam contoh ini, UserService bergantung kepada LoggerInterface , yang membolehkan kita menggunakan pelaksanaan Logger yang berbeza tanpa menukar UserService . Pendekatan ini meningkatkan fleksibiliti dan menjadikan kod anda lebih dapat diuji.

Apabila ia datang kepada prestasi, DI boleh mempunyai kesan positif dan negatif. Di sisi positif, DI dapat meningkatkan prestasi dengan membolehkan anda menggunakan caching ketergantungan dan pemuatan malas. Di sisi negatif, overhead mencipta dan mengurus bekas DI boleh memberi kesan kepada prestasi, terutamanya dalam aplikasi trafik tinggi. Ia kejam untuk memaparkan aplikasi anda dan memahami implikasi prestasi strategi DI anda.

Kesimpulannya, melaksanakan suntikan pergantungan dalam PHP bukan sekadar latihan teknikal; Ini adalah peralihan bagaimana anda berfikir dan menyusun kod anda. Dengan memeluk DI, anda boleh membuat aplikasi yang lebih modular, boleh diuji, dan dikekalkan. Walau bagaimanapun, penting untuk menyedari potensi perangkap dan pertimbangan prestasi. Semasa anda mengintegrasikan DI ke dalam projek PHP anda, ingatlah bahawa matlamatnya adalah untuk meningkatkan kualiti dan fleksibiliti kod anda, bukan hanya untuk mengikuti trend.

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