Pilih Suntikan Ketergantungan (DI) Untuk aplikasi besar, pencari perkhidmatan sesuai untuk projek kecil atau prototaip. 1) DI meningkatkan kesesuaian dan modulariti kod melalui suntikan pembina. 2) Pencari perkhidmatan memperoleh perkhidmatan melalui pendaftaran pusat, yang mudah tetapi boleh menyebabkan peningkatan gandingan kod.

Apabila ia datang untuk menguruskan kebergantungan dalam aplikasi PHP, dua corak popular sering dimainkan: Suntikan Ketergantungan (DI) dan Pencari Perkhidmatan. Jadi, mana yang harus anda pilih? Mari kita menyelam topik ini dengan sedikit bakat dan pengalaman peribadi.

Suntikan ketergantungan, pada pandangan saya, seperti mempunyai koki peribadi yang menyiapkan makanan anda tepat untuk citarasa anda. Anda memberitahu mereka apa yang anda perlukan, dan mereka menyerahkannya ke pinggan anda. Sebaliknya, corak pencari perkhidmatan terasa lebih seperti pergi ke bufet. Anda pergi ke kaunter, dan anda memilih apa yang anda perlukan dari pelbagai pilihan. Kedua -duanya mempunyai daya tarikan mereka, tetapi mereka juga datang dengan cabaran dan faedah mereka sendiri.

Mari kita meneroka suntikan pergantungan terlebih dahulu. Ini semua mengenai suntikan kebergantungan ke dalam kelas anda dan bukannya membiarkan mereka mengambil sendiri. Inilah contoh mudah menggunakan PHP:

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

Kelas Pengguna Kelas
{
    Swasta $ Logger;

    Fungsi Awam __Construct (Logger $ Logger)
    {
        $ this-> logger = $ logger;
    }

    GetUser Fungsi Awam ($ ID)
    {
        $ this-> logger-> log ("mengambil pengguna dengan id: $ id");
        // Ambil logik pengguna di sini
    }
}

$ logger = baru logger ();
$ userservice = New userService ($ logger);
$ userservice-> getUser (1);

Dalam contoh ini, UserService bergantung kepada Logger , dan kami menyuntiknya melalui pembina. Pendekatan ini menggalakkan gandingan longgar dan menjadikan kod anda lebih dapat diuji. Anda boleh dengan mudah menukar Logger dengan mengejek dalam ujian unit anda. Walau bagaimanapun, menubuhkan semua kebergantungan ini kadang -kadang boleh merasakan seperti teka -teki, terutamanya dalam aplikasi yang lebih besar.

Sekarang, mari kita lihat corak pencari perkhidmatan. Ia seperti mempunyai pendaftaran pusat di mana anda boleh mengambil sebarang perkhidmatan yang anda perlukan. Inilah cara anda melaksanakannya:

 Servicelocator kelas
{
    statik peribadi $ perkhidmatan = [];

    Set Fungsi Statik Awam ($ Key, $ Perkhidmatan)
    {
        self :: $ perkhidmatan [$ key] = $ service;
    }

    Fungsi statik awam GET ($ KEY)
    {
        jika (! Isset (self :: $ perkhidmatan [$ key])) {
            Buang pengecualian baru ("Perkhidmatan tidak dijumpai: $ kunci");
        }
        kembali diri :: $ perkhidmatan [$ key];
    }
}

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

Kelas Pengguna Kelas
{
    GetUser Fungsi Awam ($ ID)
    {
        $ logger = serviceLocator :: get ('logger');
        $ logger-> log ("mengambil pengguna dengan id: $ id");
        // Ambil logik pengguna di sini
    }
}

$ logger = baru logger ();
ServiceLocator :: set ('logger', $ logger);

$ userservice = new userService ();
$ userservice-> getUser (1);

Dengan pencari perkhidmatan, anda tidak perlu lulus kebergantungan di sekitar. Anda boleh mengambilnya dari tempat tengah. Ia mudah, terutamanya apabila anda berurusan dengan banyak perkhidmatan. Tetapi, ia boleh membawa kepada gandingan yang lebih ketat, dan ia mungkin menjadikan kod anda lebih sukar untuk diuji kerana ia kurang jelas tentang apa yang diperlukan.

Dari pengalaman saya, suntikan ketergantungan bersinar dalam aplikasi yang lebih besar dan lebih kompleks di mana anda ingin menyimpan segala -galanya modular dan boleh diuji. Saya telah bekerja pada projek -projek di mana menubuhkan bekas di Container yang betul seperti membina istana LEGO, tetapi ia terbayar dalam jangka masa panjang dengan penyelenggaraan yang lebih mudah dan liputan ujian yang lebih baik.

Sebaliknya, pencari perkhidmatan boleh menjadi penyelesaian cepat untuk aplikasi atau prototaip yang lebih kecil. Ia seperti makanan segera pengurusan ketergantungan - cepat dan mudah tetapi tidak selalunya pilihan yang paling sihat untuk asas anda.

Apabila memilih antara keduanya, pertimbangkan yang berikut:

• KESELAMATAN : Suntikan ketergantungan menjadikannya lebih mudah untuk menulis ujian unit kerana anda boleh dengan mudah mengejek kebergantungan. Pencari perkhidmatan boleh menyembunyikan kebergantungan, menjadikannya lebih sukar untuk diuji secara berasingan.

• Fleksibiliti : DI membolehkan anda mengubah kebergantungan pada masa runtime dengan lebih mudah. Dengan pencari perkhidmatan, anda mungkin perlu menukar pendaftaran, yang boleh menjadi lebih rumit.

• Kerumitan : DI mungkin memerlukan lebih banyak persediaan pendahuluan, terutamanya dengan bekas DI, tetapi ia dibayar dalam jangka masa panjang. Pencari perkhidmatan boleh menjadi lebih mudah untuk dilaksanakan tetapi mungkin membawa kepada kod yang lebih kompleks dari masa ke masa.

• Pembacaan Kod : DI Jelaskan apa yang dikehendaki oleh kebergantungan kelas. Pencari perkhidmatan boleh mengaburkan kebergantungan ini, menjadikannya lebih sukar untuk memahami keperluan kelas sekilas.

Satu perangkap yang saya temui dengan suntikan ketergantungan adalah lebih banyak kejuruteraan. Kadang -kadang, dalam usaha untuk modulariti yang sempurna, anda berakhir dengan konfigurasi DI yang lebih kompleks daripada aplikasi itu sendiri. Adalah penting untuk mencari keseimbangan dan tidak pergi ke laut dengan bekas dan abstraksi.

Dengan Pencari Perkhidmatan, perangkap utama adalah kebergantungan tersembunyi. Saya pernah bekerja di sebuah projek di mana pencari perkhidmatan digunakan secara meluas, dan ia menjadi mimpi ngeri untuk debug kerana sukar untuk mengesan di mana perkhidmatan sedang digunakan.

Kesimpulannya, kedua -dua suntikan pergantungan dan pencari perkhidmatan mempunyai tempat mereka dalam pembangunan PHP. DI adalah saya pergi untuk aplikasi yang lebih besar, lebih terawat, manakala pencari perkhidmatan boleh berguna untuk prototaip cepat atau projek yang lebih kecil. Kuncinya adalah untuk memahami perdagangan dan memilih corak yang paling sesuai dengan keperluan projek anda dan pengalaman pasukan anda. Ingat, matlamatnya adalah untuk menulis kod yang bersih dan terawat yang menjadi ujian masa.

Atas ialah kandungan terperinci Suntikan ketergantungan berbanding pencari perkhidmatan di php. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!