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

Dalam Single Responsibility Principle (SRP) Setiap kelas harus memiliki satu tanggung jawab atau alasan untuk berubah, sehingga kode menjadi lebih terorganisir dan lebih mudah di-maintain.

Prinsip Single Responsibility Principle (SRP) pada SOLID

Semisal dalam pemrograman Java memungkinkan kita membuat kelas dengan satu tanggung jawab yang spesifik. Contohnya, Anda bisa memisahkan logika bisnis dari logika akses data dengan membuat kelas terpisah untuk masing-masing fungsi, seperti UserService dan UserRepository.

Dengan memberikan satu tanggung jawab spesifik untuk setiap kelas, kode Anda jadi lebih mudah dipahami dan mengikuti KISS, karena tidak ada kerumitan dari tanggung jawab ganda dalam satu kelas.

Contoh Penerapan Single Responsibility Principle (SRP)

Berikut contoh real case penerapan Single Responsibility Principle (SRP) dalam Java.

Misalkan kita sedang mengembangkan aplikasi untuk manajemen akun pengguna. Awalnya, kita memiliki satu kelas User yang menangani berbagai fungsi seperti menyimpan data pengguna, mengirim email notifikasi, dan memvalidasi data pengguna. Kelas ini terlihat seperti berikut:

public class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public void save() {
        // Code untuk menyimpan data pengguna ke database
    }

    public void sendEmail() {
        // Code untuk mengirim email notifikasi ke pengguna
    }

    public boolean validate() {
        // Code untuk memvalidasi email pengguna
        return email.contains("@");
    }
}

Masalah: Kelas User di atas melanggar SRP karena memiliki beberapa tanggung jawab sekaligus, yaitu:

1. Menyimpan data pengguna ke database (save()).
2. Mengirim notifikasi email (sendEmail()).
3. Memvalidasi data pengguna (validate()).

Kelas ini akan sulit dikelola dan diuji karena memiliki banyak fungsi yang berbeda.

Solusi dengan SRP: Untuk mematuhi SRP, kita perlu memisahkan tanggung jawab ini ke dalam beberapa kelas yang memiliki satu tanggung jawab spesifik.

1. User: hanya bertanggung jawab untuk menyimpan data pengguna.
2. UserRepository: bertanggung jawab untuk operasi penyimpanan data.
3. EmailService: bertanggung jawab untuk mengirim email.
4. UserValidator: bertanggung jawab untuk memvalidasi data pengguna.

Implementasi yang telah dipisahkan:

// 1. User.java
public class User {
    private String name;
    private String email;

    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

// 2. UserRepository.java
public class UserRepository {
    public void save(User user) {
        // Code untuk menyimpan data pengguna ke database
        System.out.println("User disimpan ke database: " + user.getName());
    }
}

// 3. EmailService.java
public class EmailService {
    public void sendEmail(User user) {
        // Code untuk mengirim email notifikasi ke pengguna
        System.out.println("Email notifikasi dikirim ke: " + user.getEmail());
    }
}

// 4. UserValidator.java
public class UserValidator {
    public boolean validate(User user) {
        // Code untuk memvalidasi email pengguna
        return user.getEmail().contains("@");
    }
}

Penggunaan: Kita dapat menggunakan kelas-kelas ini dengan mudah dan terpisah sesuai dengan tanggung jawab masing-masing.

public class Main {
    public static void main(String[] args) {
        User user = new User("John Doe", "johndoe@example.com");

        UserValidator validator = new UserValidator();
        if (validator.validate(user)) {
            UserRepository repository = new UserRepository();
            repository.save(user);

            EmailService emailService = new EmailService();
            emailService.sendEmail(user);
        } else {
            System.out.println("Email pengguna tidak valid.");
        }
    }
}

Dengan membagi kelas-kelas ini berdasarkan tanggung jawabnya, kode menjadi lebih terstruktur, modular, mudah diuji, dan dipelihara. Setiap kelas hanya fokus pada satu hal, sehingga perubahan di satu area tidak akan mempengaruhi area lainnya.

Penerapan Single Responsibility Principle (SRP) sangat sesuai dengan prinsip KISS (Keep It Simple, Stupid) karena keduanya menekankan pada kesederhanaan dalam desain kode. Berikut adalah beberapa kaitan spesifik antara keduanya:

1. Membuat Kode Lebih Mudah Dipahami; SRP menyederhanakan kode dengan memastikan setiap kelas hanya melakukan satu tugas tertentu. Hal ini membuat kode lebih mudah dibaca dan dipahami, sehingga sesuai dengan filosofi KISS. Ketika Anda membuka kelas UserRepository, misalnya, Anda tahu persis bahwa kelas ini hanya menangani penyimpanan data pengguna, bukan hal lain.

2. Menghindari Kompleksitas yang Tidak Diperlukan; KISS menekankan pada penghindaran kerumitan yang tidak perlu. Dengan memecah tugas menjadi beberapa kelas sesuai SRP, Anda menghindari pembuatan kelas yang "gemuk" atau kompleks yang mengandung banyak fungsi sekaligus. Sebaliknya, kode akan terstruktur secara modular, di mana setiap kelas memiliki logika sederhana dan spesifik, membuat sistem lebih sederhana secara keseluruhan.

3. Memudahkan Perubahan dan Pemeliharaan; Kelas yang mematuhi SRP lebih mudah diubah atau diperbaiki tanpa risiko merusak fungsi lain. KISS mengedepankan kemudahan pemeliharaan, dan SRP mendukung ini dengan membuat perubahan di satu area tidak memengaruhi area lainnya. Misalnya, jika ada perubahan cara validasi email di UserValidator, Anda hanya perlu memperbarui kelas tersebut tanpa harus mengubah kelas User atau UserRepository.

4. Mengurangi Kesalahan dan Duplikasi Kode; Dengan memisahkan tanggung jawab berdasarkan SRP, Anda menghindari pengulangan kode yang sama di berbagai tempat. Ini mendukung prinsip KISS dengan menjaga kode tetap sederhana dan bebas dari pengulangan yang tidak diperlukan. Jika Anda memiliki validasi email, misalnya, logika ini hanya ada di satu tempat, yaitu di UserValidator.

5. Mengoptimalkan Pengujian; KISS mendorong proses pengembangan yang sederhana, termasuk pengujian. Dengan SRP, setiap kelas hanya memiliki satu tanggung jawab, sehingga Anda bisa menguji masing-masing kelas secara terpisah. Ini membuat pengujian lebih sederhana dan efisien, karena tidak perlu memeriksa seluruh fungsi dalam satu kelas besar.

Secara keseluruhan, SRP mendukung KISS dengan membuat kode lebih modular, mudah dipahami, dan bebas dari kerumitan yang tidak diperlukan. Dengan demikian, kode menjadi lebih sederhana dan terstruktur, yang sesuai dengan tujuan utama dari prinsip KISS.

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

Related Article:

1. 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