Alasan untuk menggunakan suntikan ketergantungan (DI) ialah ia menggalakkan gandingan longgar, kesesuaian, dan pemeliharaan kod. 1) Gunakan pembina untuk menyuntik kebergantungan, 2) Elakkan menggunakan pencari perkhidmatan, 3) Gunakan bekas suntikan ketergantungan untuk menguruskan kebergantungan, 4) meningkatkan kesesuaian melalui kebergantungan suntikan, 5) Elakkan kebergantungan over-suntikan, 6) Pertimbangkan kesan DI terhadap prestasi.

Ketika datang ke suntikan ketergantungan (DI) dalam PHP, persoalannya sering timbul: Kenapa saya harus berdua dengannya? Nah, suntikan ketergantungan bukan sekadar kata kunci mewah; Ia adalah corak reka bentuk yang kuat yang menggalakkan gandingan longgar, kesesuaian, dan pemeliharaan kod anda. Dengan menggunakan DI, anda boleh dengan mudah menukar kebergantungan, menjadikan aplikasi anda lebih fleksibel dan lebih mudah untuk diuji. Tetapi mari kita menyelam lebih mendalam ke dunia DI dalam PHP dan meneroka beberapa amalan terbaik yang benar -benar dapat meningkatkan permainan pengekodan anda.

Mari kita bercakap tentang intipati suntikan pergantungan terlebih dahulu. Bayangkan anda sedang membina sebuah rumah, dan bukannya mempunyai semua alat dan bahan yang tetap tetap di tempat, anda mempunyai sistem di mana anda boleh dengan mudah menukar alat atau menukar bahan berdasarkan apa yang diperlukan pada masa ini. Itulah yang dilakukan oleh di kod anda. Ia membolehkan anda menyuntik kebergantungan ke dalam kelas anda dan bukannya mempunyai kod keras, menjadikan kod anda lebih modular dan boleh disesuaikan.

Berikut adalah contoh mudah bagaimana anda boleh melaksanakan DI dalam php:

 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 , ia menerimanya melalui pembangunnya. Pendekatan ini menjadikan UserService lebih fleksibel kerana anda boleh dengan mudah menghidupkan logger dengan pelaksanaan yang berbeza jika diperlukan.

Sekarang, mari kita meneroka beberapa amalan terbaik untuk melaksanakan suntikan ketergantungan di PHP yang melampaui asas -asas:

Gunakan suntikan pembina apabila mungkin

Suntikan pembinaan adalah cara yang paling biasa dan disyorkan untuk menyuntik kebergantungan. Ia menjelaskan apa kebergantungan yang diperlukan oleh kelas dari awal. Berikut adalah cara anda dapat memperbaiki contoh sebelumnya:

 Kelas Userservice {
    Swasta $ Logger;

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

    // ... selebihnya kelas
}

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

Kelas Consolelogger melaksanakan LoggerInterface {
    log fungsi awam ($ mesej) {
        Echo "Konsol:". $ mesej. "\ n";
    }
}

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

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

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

Dengan menggunakan antara muka, LoggerInterface , anda menyahpasang UserService dari pelaksanaan spesifik logger. Pendekatan ini membolehkan anda dengan mudah menukar antara mekanisme pembalakan yang berbeza tanpa mengubah kelas UserService .

Elakkan pencari perkhidmatan

Pencari perkhidmatan boleh kelihatan seperti cara yang mudah untuk mengakses kebergantungan, tetapi mereka sering membawa kepada kod yang digabungkan dengan ketat dan boleh menyembunyikan kebergantungan, menjadikan kod anda lebih sukar untuk menguji dan mengekalkan. Daripada menggunakan pencari perkhidmatan, berpegang pada suntikan ketergantungan yang jelas. Inilah contoh apa yang harus dielakkan:

 kelas baduserservice {
    Fungsi Awam RegisterUser ($ nama pengguna) {
        $ logger = ServiceLocator :: getLogger ();
        $ logger-> log ("pendaftaran pengguna:". $ username);
        // logik pendaftaran pengguna di sini
    }
}

Pendekatan ini menjadikannya lebih sukar untuk melihat apa kebergantungan BadUserService , dan ia boleh membawa kepada isu -isu semasa ujian atau apabila anda ingin menghidupkan logger.

Leverage Container Suntikan Ketergantungan

Bagi aplikasi yang lebih besar, kebergantungan menguruskan secara manual boleh menjadi rumit. Di sinilah bekas suntikan pergantungan berguna. Mereka membantu anda menguruskan dan menaikkan kebergantungan anda secara automatik. PHP DI CONTONERS POPULAR termasuk komponen DependencyInjection Symfony dan PHP-DI. Inilah pandangan yang cepat bagaimana anda boleh menggunakan php-di:

 Gunakan di \ container;

$ container = container baru ();

$ container-> set ('logger', fungsi () {
    mengembalikan ConsoleLogger baru ();
});

$ container-> set ('user_service', function (container $ c) {
    kembali pengguna baru ($ c-> get ('logger'));
});

$ userservice = $ container-> Get ('user_service');
$ userservice-> registerUser ("john_doe");

Menggunakan bekas DI boleh memudahkan pengurusan ketergantungan anda dengan ketara, terutamanya dalam aplikasi besar. Walau bagaimanapun, berhati -hati untuk tidak terlalu banyak menggunakan bekas, kerana mereka boleh memperkenalkan kerumitan jika tidak diuruskan dengan betul.

Keseluruhan dan mengejek

Salah satu kelebihan terbesar DI adalah kesesuaian yang lebih baik. Dengan menyuntik kebergantungan, anda boleh dengan mudah mengejeknya dalam ujian anda. Berikut adalah cara anda boleh menguji UserService menggunakan phpunit dan mengejek:

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

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

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

Ujian ini memastikan bahawa kaedah log logger dipanggil tepat sekali dengan mesej yang betul, tanpa benar -benar log masuk apa -apa.

Elakkan lebih suntikan

Walaupun DI adalah kuat, kebergantungan yang lebih suntikan boleh membawa kepada kelas yang terlalu kompleks dan sukar difahami. Sekiranya kelas mempunyai terlalu banyak kebergantungan, ia mungkin menjadi tanda bahawa kelas melakukan terlalu banyak dan harus dipecah menjadi kelas yang lebih kecil dan lebih fokus. Inilah contoh apa yang harus dielakkan:

 kelas overloadedService {
    Swasta $ Logger;
    Pangkalan data $ $ swasta;
    $ mailer peribadi;
    Cache $ swasta;
    // ... banyak lagi kebergantungan

    Fungsi Awam __Construct (LoggerInterface $ Logger, Pangkalan Data $ Pangkalan Data, Mailer $ Mailer, Cache $ Cache, / * ... * /) {
        $ this-> logger = $ logger;
        $ this-> pangkalan data = $ pangkalan data;
        $ this-> mailer = $ mailer;
        $ this-> cache = $ cache;
        // ... banyak lagi tugasan
    }

    // ... kaedah menggunakan semua kebergantungan ini
}

Sebaliknya, cuba pastikan kelas anda fokus dan suntikan hanya apa yang diperlukan.

Pertimbangkan kesan prestasi

Walaupun DI umumnya meningkatkan kualiti kod, ia boleh memberi sedikit kesan prestasi disebabkan oleh ketidakpuasan tambahan. Dalam kebanyakan kes, kesan ini boleh diabaikan, tetapi dalam aplikasi kritikal prestasi, anda mungkin ingin mengukur kesan DI dan mempertimbangkan mengoptimumkan jika perlu. Sebagai contoh, anda mungkin cache yang sering digunakan objek atau menggunakan pemuatan malas untuk kebergantungan yang tidak selalu diperlukan.

Kesimpulan

Suntikan pergantungan dalam PHP adalah lebih daripada sekadar teknik; Ia adalah minda yang menggalakkan reka bentuk perisian yang lebih baik. Dengan mengikuti amalan terbaik ini, anda boleh membuat kod anda lebih modular, boleh diuji, dan dikekalkan. Ingat, kunci adalah untuk memastikan kelas anda terfokus, menggunakan antara muka untuk menentukan kebergantungan, dan memanfaatkan bekas untuk aplikasi yang lebih besar. Dan sentiasa mengawasi prestasi, memastikan penggunaan DI anda tidak memperkenalkan overhead yang tidak perlu. Dengan prinsip -prinsip ini, anda akan berada dalam perjalanan untuk menulis kod PHP yang lebih bersih dan lebih mantap.

Atas ialah kandungan terperinci Amalan terbaik untuk suntikan ketergantungan dalam php. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!