Suntikan ketergantungan (DI) adalah corak reka bentuk yang membolehkan gandingan longgar dengan membenarkan kebergantungan disediakan secara luaran. Daripada kelas yang mewujudkan kebergantungannya sendiri, mereka diluluskan, menjadikan kod lebih fleksibel, boleh diuji, dan dipelihara. DI memudahkan pertukaran pelaksanaan mudah tanpa mengubah logik teras, menyokong ujian unit dengan objek mock, dan sangat berguna dalam aplikasi besar atau arsitektur berlapis. Terdapat tiga kaedah biasa: 1) suntikan pembina, 2) suntikan setter, dan 3) suntikan berasaskan antara muka. Rangka kerja moden seperti musim bunga, teras ASP.NET, dan sokongan sudut secara asli, sering memilih suntikan pembina untuk kejelasan dan kebolehubahan. Walaupun tidak semestinya diperlukan untuk projek -projek kecil, DI menjadi berharga apabila menguruskan kitar semula objek kompleks, perubahan pelaksanaan yang kerap, atau pengasingan komponen. Alat seperti Spring, Dagger, dan Injector Ketergantungan Automate DI, membolehkan pendaftaran dan resolusi ketergantungan tanpa lulus manual setiap kali. Walau bagaimanapun, berlebihan boleh merumitkan kebolehbacaan kod, jadi memohon DI di mana ia menambah nilai sebenar adalah kunci.

Suntikan ketergantungan (DI) adalah corak reka bentuk yang biasa digunakan dalam pembangunan perisian untuk mencapai gandingan longgar antara kelas dan kebergantungan mereka. Daripada kelas yang mewujudkan kebergantungannya sendiri secara langsung, mereka disediakan (atau disuntik) dari luar. Ini menjadikan kod lebih fleksibel, boleh diuji, dan dikekalkan.

Mengapa suntikan kebergantungan

Bayangkan anda sedang membina aplikasi yang menghantar pemberitahuan. Sekiranya kelas NotificationService anda mencipta EmailService sendiri secara dalaman, ia menjadi ketat untuk pelaksanaan khusus itu. Kemudian, jika anda ingin beralih ke SMS atau kaedah lain, anda perlu menukar NotificationService itu sendiri - yang tidak sesuai.

Dengan DI, EmailService (atau mana -mana perkhidmatan yang melaksanakan antara muka yang sama) diluluskan ke dalam NotificationService , menjadikannya mudah untuk menukar pelaksanaan tanpa mengubah logik teras.

Fleksibiliti ini amat berguna apabila menulis ujian unit - anda boleh menyuntik objek mengejek dan bukannya yang sebenar, mengasingkan apa yang anda uji.

Bagaimana Suntikan Ketergantungan Berfungsi

Terdapat tiga cara biasa untuk melakukan suntikan pergantungan:

• Suntikan Pembina: Ketergantungan disediakan melalui pembina kelas.
• Suntikan setter: Ketergantungan diberikan melalui kaedah setter selepas penciptaan objek.
• Suntikan berasaskan antara muka: Kurang biasa sekarang, tetapi melibatkan penggunaan antara muka untuk menentukan bagaimana kebergantungan harus disuntik.

Rangka kerja yang paling moden seperti Spring (Java), Asp.net Core (.NET), atau Sudut (TypeScript) Sokongan DI Out of the Box, sering memihak suntikan pembina untuk kejelasan dan kebolehubahan.

Contohnya:

 Kelas E -melService {
  void hantar (mesej rentetan) {
    System.out.println ("Menghantar E -mel:" Mesej);
  }
}

Kelas NotificationService {
  E -melService EmailService Private;

  // suntikan pembina
  NOTIFICATIONSERVICE (e -melService e -melService) {
    this.emailservice = e -melService;
  }

  void notify (string msg) {
    EmailService.Send (MSG);
  }
}

Dengan cara ini, NotificationService tidak peduli bagaimana e -mel dihantar - hanya bahawa ia boleh menghubungi send() pada perkhidmatan yang disediakan.

Bila Menggunakan Suntikan Ketergantungan

Anda tidak selalu memerlukan DI - skrip kecil atau aplikasi mudah mungkin tidak banyak memberi manfaat. Tetapi dalam aplikasi yang lebih besar di mana:

• Anda mahu memisahkan kebimbangan
• Anda perlu menguji komponen secara berasingan
• Anda mengharapkan perubahan kerap dalam butiran pelaksanaan (seperti pangkalan data atau pelanggan API)

... Kemudian DI menjadi sangat berharga.

Juga, jika anda bekerja dengan seni bina berlapis (contohnya, MVC, perkhidmatan, repositori), DI membantu menguruskan hayat objek dan menggalakkan kebolehgunaan semula.

Perlu diingat bahawa sementara DI meningkatkan reka bentuk, terlalu banyak atau menyuntik terlalu banyak kebergantungan dapat membuat kod lebih sukar untuk dibaca. Jadi gunakannya di mana ia menambah nilai sebenar.

Alat dan kerangka yang membantu dengan DI

Banyak bahasa mempunyai alat terbina dalam atau pihak ketiga untuk mengendalikan DI secara automatik:

• Java: Rangka Kerja Spring, Dagger
• .NET: Built-in Di Container di Asp.net Core
• Python: Penyuntik Ketergantungan, Fastapi telah dibakar
• JavaScript/typescript: sudut, nestjs

Alat ini biasanya membolehkan anda mendaftarkan kebergantungan sekali dan kemudian menyelesaikannya secara automatik apabila diperlukan - tiada lulus manual yang diperlukan setiap kali anda membuat objek.

Ada yang membiarkan anda menentukan skop seperti singleton, sementara, atau scoped, supaya anda dapat mengawal bagaimana keadaan digunakan semula.

Jika anda tidak menggunakan rangka kerja, anda masih boleh melakukan di secara manual dengan melepaskan diri sendiri. Ia lebih mudah daripada bunyi dan berfungsi dengan baik walaupun dalam projek yang lebih kecil.

Pada asasnya, suntikan pergantungan adalah tentang membiarkan orang lain bimbang tentang kebergantungan objek anda dan bukannya mengasahnya di dalamnya. Ia tidak rumit, tetapi ia mengambil sedikit peralihan minda apabila anda mula -mula bermula.

Atas ialah kandungan terperinci Apakah konsep suntikan ketergantungan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!