Design Pattern: Dependency Injection

Dependency Injection ini adalah sebuah teknik dalam OOP di mana sebuah objek menerima objek lain yang dibutuhkan (disebut dependency) dari luar daripada membuatnya sendiri. Artinya, sebuah class tidak mengatur sendiri pembuatan objek yang ia butuhkan, melainkan hanya diberikan objeknya dari luar. Ini membuat kode lebih fleksibel, mudah diuji, dan mudah diganti implementasinya.

Contoh tanpa Dependency Injection

public class NotificationService {
    private EmailNotifier notifier = new EmailNotifier(); // KODE TERIKAT

    public void notify(String msg) {
        notifier.send(msg);
    }
}

Sekilas mungkin terlihat akan berjalan lancar, tapi kalau EmailNotifier nya berubah NotificationService akan ikut berantakan. Ini disebut tight coupling dimana NotificationService akan terikat dengan EmailNotifier, jika nanti ingin menggunakan SmsNotifier misalkan, harus mengubah isi kode kelas NotificationService. Hal ini juga akan membuat NotificationService susah untuk di-mock test.

Dengan Dependency Injection

buat terlebih dahulu kontrak interface-nya

public interface Notifier {
    void send(String message);
}

kemudian buat implementasi dari interface misalnya aja ada dua implementasi tersebut

public class EmailNotifier implements Notifier {
    @Override
    public void send(String msg) {
        System.out.println("Email: " + msg);
    }
}

public class SmsNotifier implements Notifier {
    @Override
    public void send(String msg) {
        System.out.println("SMS: " + msg);
    }
}

bentuk NotificationService-nya akan seperti ini

public class NotificationService {
    private final Notifier notifier;

    // Dependensi di-inject dari luar
    public NotificationService(Notifier notifier) { 
        this.notifier = notifier;
    }

    public void notify(String msg) {
        notifier.send(msg);
    }
}

Sekarang saat membuat objek NotificationService, kita sendiri yang menentukan notifier apa yang mau dipakai:

Notifier notifier = new EmailNotifier();
NotificationService service = new NotificationService(notifier);

class NotificationService tidak lagi membuat object Notifier dari dalam class, tetapi dibuat dan dimasukkan/di-inject dari luar class lewat constructor. Class NotificationService juga tidak lagi tahu dan tidak peduli jenis Notifier apa yang dipakai, selama itu sesuai kontrak/interface Notifier. Jadi, kita bisa ganti implementasinya tanpa menyentuh kelas NotificationService.

Manfaat Dependency Injection

1. Kode lebih longgar (loose coupling) : mudah untuk diganti implementasi-nya dengan kelas lain, kelas NotificationService tidak usah disentuh sama sekali.
2. Sangat mudah untuk di-test : mudah saat melakukan unit test, kita bisa mengganti implementasi dengan mock atau fake object. misalnya:

Notifier notifier = mock(Notifier.class); // dengan mockito
NotificationService servicer = new NotificationService(notifier);

3. Memudahkan konfigurasi aplikasi : biasanya framework yang mengatur injeksi-nya (Spring, Laravel, dll).

Konklusi

Dependency Injection adalah cara mudah untuk memberikan dependensi dari luar ke dalam kelas, bukan kelas itu sendiri yang membuatnya. Hasilnya, kode yang bersih, mudah di-test, fleksibel, dan scalable.