Bagaimana cara menjelaskan injeksi ketergantungan pada anak berusia 5 tahun? [Tutup]

Apa cara yang baik untuk menjelaskan injeksi ketergantungan ?

Saya menemukan beberapa tutorial di Google, tetapi tidak satu pun dari mereka yang akan menganggap pembaca hanya pemula Java. Bagaimana Anda menjelaskan hal ini kepada seorang pemula?

Saya memberi Anda suntikan ketergantungan untuk anak berusia lima tahun.

Ketika Anda pergi dan mengeluarkan barang-barang dari kulkas untuk diri sendiri, Anda dapat menyebabkan masalah. Anda mungkin membiarkan pintu terbuka, Anda mungkin mendapatkan sesuatu yang Ibu atau Ayah tidak ingin Anda miliki. Anda bahkan mungkin mencari sesuatu yang bahkan tidak kita miliki atau yang telah kedaluwarsa.

Yang harus Anda lakukan adalah menyatakan suatu kebutuhan, "Saya perlu minum dengan makan siang," dan kemudian kami akan memastikan Anda memiliki sesuatu ketika Anda duduk untuk makan.

Bagaimana dengan ini?

Jika Anda memiliki kelas Employeedan karyawan ini memiliki Address Anda dapat menentukan Employeekelas sebagai berikut:

class Employee {
    private Address address;

    // constructor 
    public Employee( Address newAddress ) {
        this.address = newAddress;
    }

    public Address getAddress() {
    return this.address;
    }
    public void setAddress( Address newAddress ) {
        this.address = newAddress;
    }
}

Semuanya terlihat baik sejauh ini.

Kode ini menunjukkan hubungan HAS-A antara karyawan dan alamatnya, itu tidak masalah.

Sekarang, hubungan HAS-A ini menciptakan ketergantungan di antara mereka. Masalahnya ada dalam konstruktor.

Setiap kali Anda ingin membuat Employeeinstance, Anda perlu Addressinstance:

 Address someAddress = ....
 Employee oscar = new Employee( someAddress ); 

Bekerja dengan cara ini menjadi bermasalah terutama ketika Anda ingin melakukan pengujian unit.

Masalah utama muncul ketika Anda perlu menguji satu objek tertentu, Anda perlu membuat instance objek lain, dan kemungkinan besar Anda perlu membuat instance objek lain untuk melakukan itu. Rantai mungkin menjadi tidak terkelola.

Untuk menghindari ini, Anda dapat mengubah konstruktor seperti ini:

  public Employee(){
  }

Menggunakan konstruktor no args.

Kemudian Anda dapat mengatur alamat kapan pun Anda mau:

 Address someAddress = ....
 Employee oscar = new Employee();
 oscar.setAddress( someAddress ); 

Sekarang, ini bisa menjadi hambatan, jika Anda memiliki beberapa atribut atau jika objek sulit dibuat.

Namun, pikirkan ini, katakanlah, Anda menambahkan Departmentatribut:

  class Employee {
      private Address address;
      private Department department;

  ....

Jika Anda memiliki 300 karyawan, dan semuanya harus memiliki departemen yang sama , dan ditambah departemen yang sama harus dibagi antara beberapa objek lain (seperti daftar departemen perusahaan, atau peran yang dimiliki masing-masing departemen, dll) maka Anda akan mengalami kesulitan dengan visibilitas Departmentobjek dan membaginya melalui semua jaringan objek.

Apa itu Injeksi Ketergantungan untuk membantu Anda, "menyuntikkan" dependensi ini dalam kode Anda. Sebagian besar kerangka kerja memungkinkan Anda untuk melakukan ini dengan menentukan dalam file eksternal, objek apa yang akan disuntikkan.

Asumsikan file properti untuk injector dependensi fiktif:

  #mock employee
  employee.address = MockAddress.class
  employee.department = MockDepartment.class

  #production setup 
  employee.address = RealAddress.class
  employee.department = RealDepartment.class

Anda akan menentukan apa yang harus disuntikkan untuk skenario yang diberikan.

Apa kerangka Dependency Injector akan lakukan adalah mengatur objek yang benar untuk Anda, sehingga Anda tidak perlu kode setAddressatau setDepartment. Ini akan dilakukan dengan refleksi atau oleh pembuatan kode atau teknik lainnya.

Jadi, lain kali Anda perlu menguji Employeekelas Anda dapat menyuntikkan mock Addressdan Departmentsobjek tanpa harus kode semua set / dapatkan untuk semua tes Anda. Bahkan lebih baik, Anda dapat menyuntikkan objek nyata Address dan Departmentdalam kode produksi, dan masih memiliki kepercayaan kode Anda berfungsi sebagai diuji.

Cukup banyak tentang itu.

Tetap saya tidak berpikir penjelasan ini cocok untuk anak berusia 5 tahun seperti yang Anda minta.

Saya harap Anda masih merasakan manfaatnya.

Saat menulis kelas, wajar saja jika menggunakan objek lain. Anda mungkin memiliki koneksi database, misalnya, atau layanan lain yang Anda gunakan. Objek-objek lain (atau layanan) ini adalah dependensi. Cara paling sederhana untuk menulis kode adalah dengan membuat dan menggunakan objek lain. Tetapi ini berarti objek Anda memiliki hubungan yang tidak fleksibel dengan dependensi tersebut: tidak peduli mengapa Anda memanggil objek Anda, ia menggunakan dependensi yang sama.

Teknik yang lebih kuat adalah bisa membuat objek Anda dan memberinya dependensi untuk digunakan. Jadi, Anda dapat membuat koneksi database untuk digunakan, kemudian menyerahkannya ke objek Anda. Dengan cara ini, Anda dapat membuat objek dengan dependensi berbeda di waktu yang berbeda, menjadikan objek Anda lebih fleksibel. Ini adalah injeksi ketergantungan, di mana Anda "menyuntikkan" dependensi ke objek.

BTW: Dalam gaya presentasi modern menggunakan foto flickr untuk mengilustrasikan konsep, ini dapat diilustrasikan dengan seorang pecandu yang menembak diri mereka sendiri dengan narkoba. Oh, tunggu, itu ketergantungan injeksi ... OK, maaf, lelucon buruk.

Saya tidak tahu tutorial apa pun yang disederhanakan, tetapi saya dapat memberi Anda versi yang hampir 25 250 kata atau kurang:

Dengan injeksi dependensi, objek tidak mengkonfigurasi komponennya sendiri berdasarkan hal-hal yang sudah diketahuinya, melainkan objek tersebut dikonfigurasikan oleh logika level yang lebih tinggi, dan kemudian memanggil komponen yang tidak memiliki pengetahuan sebelumnya tentang built-in. Idenya adalah untuk membuat objek lebih dari satu komponen dan lebih sedikit dari suatu aplikasi, memindahkan tugas-tugas konfigurasi pada tingkat yang lebih tinggi. Ini membuat objek lebih mungkin berguna di masa depan atau dengan konfigurasi yang berbeda.

Lebih baik untuk pengujian, lebih baik ketika tiba saatnya untuk merevisi aplikasi. Implementasi yang khas menempatkan konfigurasi dalam XML dan menggunakan kerangka kerja untuk memuat kelas secara dinamis.

Ketika Anda diberikan Nintendo baru, Anda bisa menggunakan tombol dan layar sentuh untuk bermain game.

Tapi di pabrik Nintendo, mereka perlu tahu cara menyatukannya.

Ketika orang-orang pintar di pabrik mengeluarkan Nintendo DS, itu akan berbeda di dalam, tetapi Anda masih tahu cara menggunakannya.