Inversi Kontrol vs Injeksi Ketergantungan

Menurut makalah yang ditulis oleh Martin Fowler , inversi kontrol adalah prinsip di mana aliran kontrol suatu program terbalik: alih-alih programmer mengendalikan aliran program, sumber eksternal (kerangka kerja, layanan, komponen lain) mengambil kendali Itu. Sepertinya kita memasukkan sesuatu ke sesuatu yang lain. Dia menyebutkan contoh tentang EJB 2.0:

Misalnya antarmuka Session Bean mendefinisikan ejbRemove, ejbPassivate (disimpan ke penyimpanan sekunder), dan ejbActivate (dipulihkan dari keadaan pasif). Anda tidak bisa mengendalikan ketika metode ini dipanggil, hanya apa yang mereka lakukan. Wadah itu memanggil kami, kami tidak menyebutnya.

Ini mengarah ke perbedaan antara kerangka kerja dan perpustakaan:

Inversion of Control adalah bagian penting dari apa yang membuat kerangka kerja berbeda dengan perpustakaan. Pustaka pada dasarnya adalah serangkaian fungsi yang dapat Anda panggil, hari ini biasanya diatur ke dalam kelas. Setiap panggilan berfungsi dan mengembalikan kontrol ke klien.

Saya pikir, sudut pandang bahwa DI adalah IOC, berarti ketergantungan suatu objek terbalik: alih-alih mengendalikan dependensinya sendiri, siklus hidup ... sesuatu yang lain melakukannya untuk Anda. Tapi, seperti yang Anda katakan tentang DI dengan tangan, DI belum tentu IOC. Kami masih bisa memiliki DI dan tidak ada IOC.

Namun, dalam makalah ini (dari pococapsule, Kerangka kerja IOC lain untuk C / C ++), ini menunjukkan bahwa karena IOC dan DI, wadah IOC dan kerangka kerja DI jauh lebih unggul daripada J2EE, karena J2EE mencampur kode kerangka kerja ke dalam komponen , dengan demikian tidak membuatnya menjadi Plain Old Java / C ++ Object (POJO / POCO).

Pembalikan Kontain Kontrol selain dari pola Injeksi Ketergantungan (Archive link)

Bacaan tambahan untuk memahami apa masalahnya dengan Kerangka Pengembangan Berbasis Komponen yang lama, yang mengarah ke makalah kedua di atas: Mengapa dan bagaimana dengan Inversion of Control (tautan Arsip)

Pertanyaan Saya : Apa sebenarnya IOC dan DI? Saya bingung. Berdasarkan pococapsule, IOC adalah sesuatu yang lebih penting daripada hanya inversi kontrol antara objek atau programmer dan kerangka kerja.

IoC adalah makna istilah umum daripada meminta aplikasi memanggil metode dalam suatu framework, framework memanggil implementasi yang disediakan oleh aplikasi.

DI adalah bentuk IoC, di mana implementasi dilewatkan ke objek melalui konstruktor / setter / layanan pencarian, yang objek akan 'bergantung' untuk berperilaku dengan benar.

IoC tanpa menggunakan DI , misalnya akan menjadi pola Templat karena implementasinya hanya dapat diubah melalui subklasifikasi.

Kerangka DI dirancang untuk memanfaatkan DI dan dapat mendefinisikan antarmuka (atau Anotasi di Jawa) agar mudah dilewatkan dalam implementasi.

IoC Containers adalah kerangka kerja DI yang dapat bekerja di luar bahasa pemrograman. Di beberapa Anda dapat mengkonfigurasi implementasi yang digunakan dalam file metadata (misalnya XML) yang kurang invasif. Dengan beberapa Anda dapat melakukan IoC yang biasanya tidak mungkin seperti menyuntikkan implementasi di pointcuts .

Lihat juga artikel Martin Fowler ini .

Singkatnya, IoC adalah istilah yang jauh lebih luas yang mencakup, tetapi tidak terbatas pada, DI

Istilah Inversion of Control (IoC) awalnya berarti segala jenis gaya pemrograman di mana kerangka kerja keseluruhan atau run-time mengontrol aliran program

Sebelum DI memiliki nama, orang-orang mulai merujuk pada kerangka kerja yang mengelola Ketergantungan sebagai Pembalikan Wadah Kontrol, dan segera, makna IoC perlahan-lahan melayang ke makna tertentu: Pembalikan Kontrol atas Ketergantungan.

Inversion of Control (IoC) berarti bahwa objek tidak membuat objek lain di mana mereka bergantung untuk melakukan pekerjaan mereka. Sebagai gantinya, mereka mendapatkan objek yang mereka butuhkan dari sumber luar (misalnya, file konfigurasi xml).

Dependency Injection (DI) berarti bahwa ini dilakukan tanpa intervensi objek, biasanya oleh komponen kerangka kerja yang melewati parameter konstruktor dan mengatur properti.

sumber

IOC ( Saya nVersi o f C ontrol): - Ini adalah istilah generik dan diimplementasikan dalam beberapa cara (peristiwa, delegasi dll).

DI ( D ependency I njection): - DI adalah sub-jenis IOC dan dilaksanakan oleh injeksi konstruktor, injeksi setter atau Antarmuka injeksi .

Tapi, Spring hanya mendukung dua jenis berikut:

• Setter Injection
  • DI berbasis Setter direalisasikan dengan memanggil metode setter pada kacang pengguna setelah memanggil konstruktor tanpa argumen atau metode pabrik statis tanpa argumen untuk membuat instance kacang mereka.
• Injeksi Konstruktor
  • DI berbasis konstruktor diwujudkan dengan memanggil konstruktor dengan sejumlah argumen, masing-masing mewakili kolaborator. Menggunakan ini kita dapat memvalidasi bahwa kacang yang disuntikkan tidak nol dan gagal cepat (gagal pada waktu kompilasi dan tidak pada saat run-time), jadi saat memulai aplikasi itu sendiri kita dapatkan NullPointerException: bean does not exist. Injeksi konstruktor adalah praktik terbaik untuk menyuntikkan dependensi.

DI adalah subset dari IoC

• IoC berarti bahwa objek tidak membuat objek lain di mana mereka bergantung untuk melakukan pekerjaan mereka. Sebagai gantinya, mereka mendapatkan objek yang mereka butuhkan dari layanan luar (misalnya, file xml atau layanan aplikasi tunggal). 2 implementasi IoC, saya gunakan, adalah DI dan ServiceLocator.
• DI berarti prinsip IoC untuk mendapatkan objek dependen dilakukan tanpa menggunakan objek konkret tetapi abstraksi (antarmuka). Ini membuat semua rantai komponen dapat diuji, karena komponen tingkat yang lebih tinggi tidak tergantung pada komponen tingkat yang lebih rendah, hanya dari antarmuka. Mocks menerapkan antarmuka ini.

Berikut adalah beberapa teknik lain untuk mencapai IOC .

IOC (Inversion Of Control) : Memberi kontrol ke wadah untuk mendapatkan instance objek disebut Inversion of Control, berarti alih-alih Anda membuat objek menggunakan operator baru, biarkan wadah melakukan itu untuk Anda.

DI (Dependency Injection) : Cara menyuntikkan properti ke suatu objek disebut Dependency Injection .

Kami memiliki tiga jenis Injeksi Ketergantungan :

1. Injeksi Konstruktor
2. Setter / Getter Injection
3. Injeksi Antarmuka

Spring hanya mendukung Constructor Injection dan Setter / Getter Injection .

Karena semua jawaban menekankan pada teori saya ingin menunjukkan dengan contoh pendekatan pertama:

Misalkan kita sedang membangun aplikasi yang berisi fitur untuk mengirim pesan konfirmasi SMS setelah pesanan telah dikirim. Kami akan memiliki dua kelas, satu bertanggung jawab untuk mengirim SMS (Layanan SMS), dan lainnya bertanggung jawab untuk mengambil input pengguna (UIHandler), kode kami akan terlihat seperti di bawah ini:

public class SMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
    }
}

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        SMSService _SMSService = new SMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

Implementasi di atas tidak salah tetapi ada beberapa masalah:
-) Misalkan pada lingkungan pengembangan, Anda ingin menyimpan SMS yang dikirim ke file teks daripada menggunakan SMS gateway, untuk mencapai ini; kami pada akhirnya akan mengubah implementasi konkret (SMSService) dengan implementasi lain, kami kehilangan fleksibilitas dan dipaksa untuk menulis ulang kode dalam kasus ini.
-) Kita akan berakhir dengan memadukan tanggung jawab kelas, (UIHandler) kita seharusnya tidak pernah tahu tentang implementasi konkret dari (Layanan SMS), ini harus dilakukan di luar kelas menggunakan "Antarmuka". Ketika ini diterapkan, itu akan memberi kita kemampuan untuk mengubah perilaku sistem dengan menukar (SMSService) yang digunakan dengan layanan tiruan lain yang mengimplementasikan antarmuka yang sama, layanan ini akan menyimpan SMS ke file teks daripada mengirim ke nomor ponsel.

Untuk memperbaiki masalah di atas kami menggunakan Antarmuka yang akan diimplementasikan oleh (SMSService) kami dan yang baru (MockSMSService), pada dasarnya Antarmuka baru (ISMSService) akan memaparkan perilaku yang sama dari kedua layanan seperti kode di bawah ini:

public interface ISMSService
{
    void SendSMS(string phoneNumber, string body);
}

Kemudian kami akan mengubah implementasi (SMSService) kami untuk mengimplementasikan antarmuka (ISMSService):

public class SMSService : ISMSService
{
    public void SendSMS(string mobileNumber, string body)
    {
        SendSMSUsingGateway(mobileNumber, body);
    }

    private void SendSMSUsingGateway(string mobileNumber, string body)
    {
        /*implementation for sending SMS using gateway*/
        Console.WriteLine("Sending SMS using gateway to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

Sekarang kita akan dapat membuat layanan mock up baru (MockSMSService) dengan implementasi yang sama sekali berbeda menggunakan antarmuka yang sama:

public class MockSMSService :ISMSService
{
    public void SendSMS(string phoneNumber, string body)
    {
        SaveSMSToFile(phoneNumber,body);
    }

    private void SaveSMSToFile(string mobileNumber, string body)
    {
        /*implementation for saving SMS to a file*/
        Console.WriteLine("Mocking SMS using file to mobile: 
        {0}. SMS body: {1}", mobileNumber, body);
    }
}

Pada titik ini, kita dapat mengubah kode di (UIHandler) untuk menggunakan implementasi konkret dari layanan (MockSMSService) dengan mudah seperti di bawah ini:

public class UIHandler
{
    public void SendConfirmationMsg(string mobileNumber)
    {
        ISMSService _SMSService = new MockSMSService();
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

Kami telah mencapai banyak fleksibilitas dan menerapkan pemisahan masalah dalam kode kami, tetapi kami masih perlu melakukan perubahan pada basis kode untuk beralih di antara dua Layanan SMS. Jadi kita perlu menerapkan Injeksi Ketergantungan .

Untuk mencapai hal ini, kita perlu mengimplementasikan perubahan pada konstruktor kelas (UIHandler) kita untuk meneruskan dependensi, dengan melakukan ini, kode yang menggunakan (UIHandler) dapat menentukan implementasi konkret dari (Layanan ISMS) yang akan digunakan:

public class UIHandler
{
    private readonly ISMSService _SMSService;

    public UIHandler(ISMSService SMSService)
    {
        _SMSService = SMSService;
    }

    public void SendConfirmationMsg(string mobileNumber)
    {
        _SMSService.SendSMS(mobileNumber, "Your order has been shipped successfully!");
    }
}

Sekarang bentuk UI yang akan berbicara dengan kelas (UIHandler) bertanggung jawab untuk melewati implementasi antarmuka mana (ISMSService) untuk dikonsumsi. Ini berarti kami telah membalikkan kontrol, (UIHandler) tidak lagi bertanggung jawab untuk memutuskan implementasi yang akan digunakan, kode panggilan tidak. Kami telah menerapkan prinsip Inversion of Control yang DI adalah salah satu jenisnya.

Kode bentuk UI akan seperti di bawah ini:

class Program
{
    static void Main(string[] args)
    {
        ISMSService _SMSService = new MockSMSService(); // dependency

        UIHandler _UIHandler = new UIHandler(_SMSService);
        _UIHandler.SendConfirmationMsg("96279544480");

        Console.ReadLine();
    }
}

Tetapi dokumentasi musim semi mengatakan mereka sama.

http://docs.spring.io/spring/docs/current/spring-framework-reference/htmlsingle/#beans-introduction

Di baris pertama " IoC juga dikenal sebagai injeksi ketergantungan (DI) ".

IoC - Pembalikan kontrol adalah istilah umum, tidak tergantung pada bahasa, sebenarnya bukan menciptakan objek tetapi menjelaskan di mana objek mode dibuat.

DI - Ketergantungan Injeksi adalah istilah konkret, di mana kami menyediakan dependensi objek pada saat dijalankan dengan menggunakan teknik injeksi yang berbeda yaitu. Setter, Injeksi Konstruktor atau Injeksi Antarmuka.

Inversion of control adalah paradigma desain dengan tujuan memberikan lebih banyak kontrol ke komponen yang ditargetkan dari aplikasi Anda, yang menyelesaikan pekerjaan.
Ketergantungan injeksi adalah pola yang digunakan untuk membuat instance objek yang bergantung pada objek lain tanpa mengetahui pada waktu kompilasi kelas mana yang akan digunakan untuk menyediakan fungsionalitas itu.

Ada beberapa teknik dasar untuk menerapkan inversi kontrol. Ini adalah:

• Menggunakan pola pabrik
  
• Menggunakan pola pencari lokasi layanan
  
• Menggunakan suntikan ketergantungan jenis apa pun yang diberikan di bawah ini:
  
  1). Suntikan konstruktor
  2). Suntikan setter
  3). Injeksi antarmuka

DI dan IOC adalah dua pola desain yang terutama berfokus pada penyediaan kopling longgar antara komponen , atau hanya cara di mana kita memisahkan hubungan ketergantungan konvensional antara objek sehingga objek tidak saling ketat.

Dengan contoh-contoh berikut, saya mencoba menjelaskan kedua konsep ini.

Sebelumnya kami menulis kode seperti ini

Public MyClass{
 DependentClass dependentObject
 /*
  At somewhere in our code we need to instantiate 
  the object with new operator  inorder to use it or perform some method.
  */ 
  dependentObject= new DependentClass();
  dependentObject.someMethod();
}

Dengan injeksi Dependency, injector dependensi akan menangani instantiasi objek

Public MyClass{
 /* Dependency injector will instantiate object*/
 DependentClass dependentObject

 /*
  At somewhere in our code we perform some method. 
  The process of  instantiation will be handled by the dependency injector
 */ 

  dependentObject.someMethod();
}

Proses pemberian kontrol di atas kepada orang lain (misalnya wadah) untuk instantiasi dan injeksi dapat disebut sebagai Inversion of Control dan proses di mana wadah IOC menyuntikkan dependensi bagi kita dapat disebut sebagai injeksi dependensi.

IOC adalah prinsip di mana aliran kontrol suatu program terbalik: alih-alih programmer mengontrol aliran suatu program , program mengontrol aliran dengan mengurangi overhead ke programmer . Dan proses yang digunakan oleh program untuk menyuntikkan ketergantungan disebut sebagai DI

Dua konsep bekerja bersama memberi kita cara untuk menulis kode yang jauh lebih fleksibel, dapat digunakan kembali, dan dienkapsulasi, yang menjadikannya sebagai konsep penting dalam merancang solusi berorientasi objek.

Juga merekomendasikan untuk membaca.

Apa itu injeksi ketergantungan?

Anda juga dapat memeriksa salah satu jawaban serupa saya di sini

Perbedaan antara Pembalikan Kontrol & Ketergantungan Injeksi

Inversion of Control adalah prinsip desain generik arsitektur perangkat lunak yang membantu menciptakan kerangka kerja perangkat lunak modular yang dapat digunakan kembali dan mudah dipelihara.

Ini adalah prinsip desain di mana Flow of Control "diterima" dari perpustakaan yang ditulis secara umum atau kode yang dapat digunakan kembali.

Untuk memahaminya dengan lebih baik, mari kita lihat bagaimana kita menggunakan kode pada hari-hari awal pengkodean kita. Dalam bahasa prosedural / tradisional, logika bisnis umumnya mengontrol aliran aplikasi dan "Memanggil" kode / fungsi umum atau yang dapat digunakan kembali. Misalnya, dalam aplikasi Konsol sederhana, aliran kendali saya dikendalikan oleh instruksi program saya, yang dapat mencakup panggilan ke beberapa fungsi umum yang dapat digunakan kembali.

print ("Please enter your name:");
scan (&name);
print ("Please enter your DOB:");
scan (&dob);

//More print and scan statements
<Do Something Interesting>

//Call a Library function to find the age (common code)
print Age

Dalam Kontras, dengan IoC, Kerangka adalah kode yang dapat digunakan kembali yang "Memanggil" logika bisnis.

Misalnya, dalam sistem berbasis windows, kerangka kerja sudah tersedia untuk membuat elemen UI seperti tombol, menu, jendela dan kotak dialog. Ketika saya menulis logika bisnis dari aplikasi saya, itu akan menjadi peristiwa kerangka kerja yang akan memanggil kode logika bisnis saya (ketika suatu peristiwa dipecat) dan BUKAN sebaliknya.

Meskipun, kode kerangka kerja ini tidak mengetahui logika bisnis saya, masih akan tahu cara memanggil kode saya. Ini dicapai dengan menggunakan acara / delegasi, panggilan balik dll. Di sini Kontrol aliran adalah "Terbalik".

Jadi, alih-alih bergantung pada aliran kontrol pada objek yang terikat secara statis, aliran tersebut bergantung pada grafik objek keseluruhan dan hubungan antara objek yang berbeda.

Dependency Injection adalah pola desain yang menerapkan prinsip IoC untuk menyelesaikan dependensi objek.

Dengan kata sederhana, ketika Anda mencoba menulis kode, Anda akan membuat dan menggunakan kelas yang berbeda. Satu kelas (Kelas A) dapat menggunakan kelas lain (Kelas B dan / atau D). Jadi, Kelas B dan D adalah dependensi kelas A.

Analogi sederhana akan menjadi Mobil kelas. Mobil mungkin bergantung pada kelas lain seperti Engine, Ban, dan lainnya.

Ketergantungan Injeksi menunjukkan bahwa alih-alih kelas Ketergantungan (Kelas Mobil di sini) menciptakan dependensinya (Kelas Mesin dan kelas Ban), kelas harus disuntikkan dengan contoh konkret ketergantungan.

Mari kita pahami dengan contoh yang lebih praktis. Pertimbangkan bahwa Anda sedang menulis TextEditor Anda sendiri. Antara lain, Anda bisa memiliki pemeriksa ejaan yang menyediakan fasilitas kepada pengguna untuk memeriksa kesalahan ketik dalam teksnya. Implementasi sederhana dari kode semacam itu dapat:

Class TextEditor
{

    //Lot of rocket science to create the Editor goes here

    EnglishSpellChecker objSpellCheck;
    String text;

    public void TextEditor()

    {   

        objSpellCheck = new EnglishSpellChecker();

    }

    public ArrayList <typos> CheckSpellings()
    {

        //return Typos;

    }

}

Pada pandangan pertama, semua tampak kemerahan. Pengguna akan menulis beberapa teks. Pengembang akan menangkap teks dan memanggil fungsi CheckSpellings dan akan menemukan daftar Typos yang akan ditampilkan kepada Pengguna.

Segalanya tampak bekerja dengan baik sampai suatu hari ketika seorang pengguna mulai menulis bahasa Prancis di Editor.

Untuk memberikan dukungan untuk lebih banyak bahasa, kita perlu memiliki lebih banyak Pemeriksa Ejaan. Mungkin Perancis, Jerman, Spanyol dll.

Di sini, kami telah membuat kode yang dipasangkan dengan SpellChecker "Bahasa Inggris" yang dipasangkan dengan kelas TextEditor kami, yang berarti kelas TextEditor kami bergantung pada EnglishSpellChecker atau dengan kata lain EnglishSpellCheker adalah ketergantungan untuk TextEditor. Kami harus menghapus ketergantungan ini. Lebih lanjut, Editor Teks kami membutuhkan cara untuk menyimpan referensi konkret dari Pemeriksa Ejaan apa pun berdasarkan kebijaksanaan pengembang pada waktu berjalan.

Jadi, seperti yang kita lihat dalam pengenalan DI, ini menunjukkan bahwa kelas harus disuntikkan dengan dependensinya. Jadi, itu harus menjadi tanggung jawab kode panggilan untuk menyuntikkan semua dependensi ke kelas / kode yang dipanggil. Jadi kami dapat menyusun kembali kode kami sebagai

interface ISpellChecker
{

    Arraylist<typos> CheckSpelling(string Text);

}

Class EnglishSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}



Class FrenchSpellChecker : ISpellChecker

{

    public override Arraylist<typos> CheckSpelling(string Text)

    {

        //All Magic goes here.

    }

}

Dalam contoh kami, kelas TextEditor harus menerima contoh konkret dari tipe ISpellChecker.

Sekarang, ketergantungan dapat disuntikkan di Konstruktor, Properti Publik atau metode.

Mari kita coba mengubah kelas kita menggunakan Constructor DI. Kelas TextEditor yang diubah akan terlihat seperti:

Class TextEditor

{

    ISpellChecker objSpellChecker;

    string Text;



    public void TextEditor(ISpellChecker objSC)

    {

        objSpellChecker = objSC;

    }



    public ArrayList <typos> CheckSpellings()

    {

        return objSpellChecker.CheckSpelling();

    }

}

Sehingga kode panggilan, saat membuat editor teks dapat menyuntikkan SpellChecker Type yang sesuai ke instance dari TextEditor.

Anda dapat membaca artikel selengkapnya di sini

IOC (Inversion Of Control): Memberi kendali ke wadah untuk mendapatkan instance objek disebut Inversion of Control. Itu berarti alih-alih Anda membuat objek menggunakan operator baru , biarkan wadah melakukannya untuk Anda.

DI (Dependency Injection): Melewati parameter yang diperlukan (properti) dari XML ke objek (dalam POJO CLASS) disebut Dependency injection.

IOC menunjukkan bahwa kelas eksternal mengelola kelas aplikasi, dan kelas eksternal berarti wadah mengelola ketergantungan antara kelas aplikasi. konsep dasar IOC adalah programmer tidak perlu membuat objek Anda tetapi menjelaskan bagaimana mereka harus dibuat.

Tugas utama yang dilakukan oleh wadah IoC adalah: untuk membuat instance kelas aplikasi. untuk mengkonfigurasi objek. untuk merakit dependensi antara objek.

DI adalah proses penyediaan dependensi suatu objek pada saat dijalankan dengan menggunakan setter injection atau injector injection.

IOC (Inversion of Control) pada dasarnya merancang konsep pola menghilangkan ketergantungan dan memisahkan mereka untuk membuat aliran non-linear, dan membiarkan wadah / atau entitas lain mengelola penyediaan dependensi. Ini sebenarnya mengikuti kepala sekolah Hollywood, “Jangan panggil kami, kami akan memanggilmu”. Jadi rangkum perbedaannya.

Inversi kontrol: - Ini adalah istilah umum untuk memisahkan dependensi dan mendelegasikan provisi mereka, dan ini dapat diimplementasikan dalam beberapa cara (acara, delegasi dll).

Ketergantungan injeksi: - DI adalah subtipe dari IOC dan diimplementasikan dengan injeksi konstruktor, injeksi setter atau injeksi metode.

Artikel berikut menggambarkannya dengan sangat rapi.

https://www.codeproject.com/Articles/592372/Dependency-Injection-DI-vs-Inversion-of-Control-IO

Saya pikir ide itu dapat didemonstrasikan dengan jelas tanpa masuk ke gulma Berorientasi Objek, yang tampaknya mengacaukan ide.

// dependency injection
function doSomething(dependency) {
    // do something with your dependency
}

// in contrast to creating your dependencies yourself
function doSomething() {
    dependency = getDependencySomehow()
}

// inversion of control
application = makeApp(authenticate, handleRequest, sendResponse)
application.run(getRequest())

// in contrast to direct control or a "library" style
application = makeApp()
request = application.getRequest()

if (application.authenticate(request.creds)) {
    response = application.handleRequest(request)
    application.sendResponse(response)
}

Jika Anda memiringkan kepala dan menyipitkan mata, Anda akan melihat bahwa DI adalah implementasi khusus IoC dengan masalah khusus. Alih-alih menyuntikkan model dan perilaku ke dalam kerangka kerja aplikasi atau operasi tingkat tinggi, Anda menyuntikkan variabel ke dalam fungsi atau objek.

Mari kita mulai dengan D SOLID dan lihat DI dan IoC dari buku Scott Millett "Professional ASP.NET Design Patterns":

Prinsip Ketergantungan Inversi (DIP)

The DIP adalah semua tentang mengisolasi kelas Anda dari implementasi konkret dan memiliki mereka bergantung pada kelas abstrak atau interface. Ini mempromosikan mantra pengkodean ke antarmuka daripada implementasi, yang meningkatkan fleksibilitas dalam suatu sistem dengan memastikan Anda tidak terikat erat dengan satu implementasi.

Dependency Injection (DI) dan Inversion of Control (IoC)

Terkait erat dengan DIP adalah prinsip DI dan prinsip IoC. DI adalah tindakan memasok kelas rendah atau kelas dependen melalui konstruktor, metode, atau properti. Digunakan bersama dengan DI, kelas dependen ini dapat dibalik ke antarmuka atau kelas abstrak yang akan mengarah pada sistem yang digabungkan secara longgar yang sangat dapat diuji dan mudah diubah.

Dalam IoC , aliran kontrol sistem terbalik dibandingkan dengan pemrograman prosedural. Contoh dari ini adalah wadah IoC , yang tujuannya adalah untuk menyuntikkan layanan ke dalam kode klien tanpa kode klien menentukan implementasi konkret. Kontrol dalam hal ini yang terbalik adalah tindakan klien yang mendapatkan layanan.

Millett, C (2010). Pola Desain ASP.NET Profesional. Penerbitan Wiley. 7-8.

// ICO, DI, 10 tahun yang lalu, begini caranya:

public class  AuditDAOImpl implements Audit{

    //dependency
    AuditDAO auditDAO = null;
        //Control of the AuditDAO is with AuditDAOImpl because its creating the object
    public AuditDAOImpl () {
        this.auditDAO = new AuditDAO ();
    }
}

Sekarang dengan Spring 3,4 atau terbaru seperti di bawah ini

public class  AuditDAOImpl implements Audit{

    //dependency

     //Now control is shifted to Spring. Container find the object and provide it. 
    @Autowired
    AuditDAO auditDAO = null;

}

Secara keseluruhan kontrol terbalik dari konsep lama kode digabungkan ke kerangka kerja seperti Spring yang membuat objek tersedia. Jadi itulah IOC sejauh yang saya tahu dan injeksi Ketergantungan seperti yang Anda ketahui saat kami menyuntikkan objek dependen ke objek lain menggunakan Konstruktor atau setter. Suntikan pada dasarnya berarti meneruskannya sebagai argumen. Pada musim semi kita memiliki konfigurasi berbasis XML & anotasi di mana kita mendefinisikan objek bean dan meneruskan objek dependen dengan gaya injeksi Constructor atau setter.

Saya menemukan contoh terbaik di Dzone.com yang sangat membantu untuk memahami perbedaan nyata antara IOC dan DI

"IoC adalah ketika kamu memiliki orang lain yang membuat objek untukmu." Jadi alih-alih menulis kata kunci "baru" (Misalnya, MyCode c = new MyCode ()) dalam kode Anda, objek tersebut dibuat oleh orang lain. 'Orang lain' ini biasanya disebut sebagai wadah IoC. Ini berarti kami menyerahkan rrsponsibility (kontrol) ke wadah untuk mendapatkan instance objek disebut Inversion of Control., Berarti alih-alih Anda membuat objek menggunakan operator baru, biarkan wadah melakukan itu untuk Anda.

   DI(Dependency Injection):  Way of injecting properties to an object is 
   called 
  Dependency injection.
   We have three types of Dependency injection
    1)  Constructor Injection
    2)  Setter/Getter Injection
    3)  Interface Injection
   Spring will support only Constructor Injection and Setter/Getter Injection.

Baca artikel lengkap IOC dan Baca artikel Lengkap DI

1) DI is Child-> obj tergantung pada parent-obj. Ketergantungan kata kerja itu penting. 2) IOC adalah Child-> obj tampil di bawah platform. di mana platform bisa menjadi sekolah, perguruan tinggi, kelas dansa. Performa di sini adalah aktivitas dengan implikasi berbeda di bawah penyedia platform apa pun.

contoh praktis: `

//DI
child.getSchool();
//IOC
child.perform()// is a stub implemented by dance-school
child.flourish()// is a stub implemented by dance-school/school/

`

-AB

Adapun pertanyaan ini, saya akan mengatakan wiki telah memberikan penjelasan yang terperinci dan mudah dipahami. Saya hanya akan mengutip yang paling signifikan di sini.

Implementasi IoC

Dalam pemrograman berorientasi objek, ada beberapa teknik dasar untuk menerapkan inversi kontrol. Ini adalah:

1. Menggunakan pola pelacak layanan Menggunakan injeksi dependensi, misalnya injeksi Konstruktor. Parameter injeksi. Setter injeksi Antarmuka antarmuka;
2. Menggunakan pencarian kontekstual;
3. Menggunakan pola desain metode templat;
4. Menggunakan pola desain strategi

Adapun Injeksi Ketergantungan

injeksi ketergantungan adalah teknik di mana satu objek (atau metode statis) memasok dependensi objek lain. Ketergantungan adalah objek yang dapat digunakan (layanan). Suntikan adalah perpindahan ketergantungan ke objek dependen (klien) yang akan menggunakannya.

Konsep IoC pada awalnya terdengar selama era pemrograman prosedural. Oleh karena itu dari konteks historis, IoC berbicara tentang inversi kepemilikan aliran kendali, yaitu siapa yang memiliki tanggung jawab untuk menjalankan fungsi dalam urutan yang diinginkan - apakah itu fungsi itu sendiri atau haruskah Anda membalikkannya ke entitas eksternal.

Namun begitu OOP muncul, orang-orang mulai berbicara tentang IoC dalam konteks OOP di mana aplikasi berkaitan dengan pembuatan objek dan hubungan mereka juga, terlepas dari aliran kontrol. Aplikasi seperti itu ingin membalikkan kepemilikan objek-penciptaan (bukan kontrol-aliran) dan membutuhkan wadah yang bertanggung jawab untuk pembuatan objek, siklus hidup objek & menyuntikkan dependensi objek aplikasi sehingga menghilangkan objek aplikasi dari membuat objek beton lainnya.

Dalam hal ini DI tidak sama dengan Io C , karena ini bukan tentang kontrol-aliran, namun itu semacam Io * , yaitu Pembalikan kepemilikan atas penciptaan objek.

Apa yang salah dengan cara saya menjelaskan DI dan IOC?

IoC alias Inversion of Control mengacu pada kontrol menciptakan instance yang dilakukan oleh wadah Spring. Kontrol untuk membuat dan membangun objek diurus oleh wadah. Wadah menciptakan objek dan menyuntikkannya ke dalam aplikasi kita.