Menulis Clean Code: Prinsip Dependency Inversion Principle (DIP) Pada SOLID

Dependency Inversion Principle (DIP) adalah prinsip dimana modul tingkat tinggi tidak boleh bergantung pada modul tingkat rendah. Keduanya sebaiknya bergantung pada abstraksi, sehingga meningkatkan fleksibilitas kode.

Prinsip Dependency Inversion Principle (DIP) Pada SOLID

Java mendukung DIP melalui dependency injection, yang dapat dilakukan menggunakan Spring Framework atau manual. Dengan menggunakan antarmuka dan dependency injection, kelas-kelas dalam aplikasi Anda akan bergantung pada abstraksi, bukan pada implementasi langsung, yang memudahkan pergantian implementasi.

"kelas-kelas dalam aplikasi Anda akan bergantung pada abstraksi, bukan pada implementasi langsung"

Contoh Dependency Inversion Principle (DIP)

Misalkan kita memiliki aplikasi untuk mengirim notifikasi dengan berbagai metode, seperti email dan SMS. Pada awalnya, mungkin kita memiliki kelas NotificationService yang bergantung pada implementasi spesifik seperti EmailService dan SMSService.

Desain yang Tidak Memenuhi DIP:

public class NotificationService {
    private EmailService emailService;
    private SMSService smsService;

    public NotificationService() {
        this.emailService = new EmailService();
        this.smsService = new SMSService();
    }

    public void sendNotification(String message) {
        emailService.sendEmail(message);
        smsService.sendSMS(message);
    }
}

Pada desain ini, NotificationService bergantung langsung pada implementasi EmailService dan SMSService. Jika nanti kita menambahkan layanan notifikasi baru, seperti PushNotificationService, kita perlu mengubah NotificationService, yang melanggar prinsip DIP.

Solusi dengan DIP: Untuk memenuhi DIP, kita bisa membuat antarmuka Notifier yang mengabstraksi layanan notifikasi dan membuat NotificationService bergantung pada antarmuka ini.


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

public class EmailService implements Notifier {
    @Override
    public void send(String message) {
        System.out.println("Sending email: " + message);
    }
}

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

public class NotificationService {
    private List<Notifier> notifiers;

    public NotificationService(List<Notifier> notifiers) {
        this.notifiers = notifiers;
    }

    public void sendNotification(String message) {
        for (Notifier notifier : notifiers) {
            notifier.send(message);
        }
    }
}

Sekarang, NotificationService hanya bergantung pada Notifier, bukan implementasi spesifiknya. Kita bisa menambahkan layanan baru tanpa mengubah NotificationService.

Hubungan DIP dengan KISS

Membuat Kode Fleksibel dan Mudah Diperluas: Dengan bergantung pada abstraksi, kode menjadi lebih fleksibel dan mudah diperluas. Ini menghindari perubahan yang tidak perlu dan menjaga kode tetap sederhana sesuai dengan prinsip KISS.

Meningkatkan Reusabilitas dan Meminimalkan Dampak Perubahan: Dengan DIP, perubahan pada satu layanan tidak memengaruhi layanan lain, sehingga kode lebih mudah dipelihara dan lebih sederhana dalam hal pengelolaan perubahan.

Artikel ini terkait dengan: menulis clean code dengan prinsip solid dan kiss

2. Menulis Clean Code: Prinsip Single Responsibility Principle (SRP) pada SOLID

3. Menulis Clean Code Dengan Open Closed Principle

4. Menulis Clean dengan Interface Segregation Principle

5. Menulis Clean Code: Prinsip Dependency Inversion Principle (DIP) Pada SOLID

6. Prinsip Liskov Substitution Principle (LSP) Pada SOLID