Series Belajar Solid Principle - Liskov Substitution Principle (LSP)

Hai semuanya!, di series sebelumnya gw udah share apa itu Open Closed Principle, nah kali ini gw akan bahas Liskov Substitution Principle (LSP).

Apa itu Liskov Substitution Principle (LSP)?

Prinsip LSP itu seperti aturan dasar/pattern yang harus diikuti dalam membangun hubungan antar class. Intinya, kita harus desain class-class kita dengan hati-hati supaya bisa disubstitusi tanpa bikin masalah.
Jadi, setiap turunan class minimal harus bisa ngelakuin hal yang sama kayak class dasarnya, bingung? :D, Langsung aja ke contohnya yaa biar ga bingung.

Gw pake contoh studi kasus yang sama dengan artikel sebelum sebelumnya.

Before

Sebelum menggunakan LSP, mungkin kode kita terlihat seperti ini:

class Payment {
    public function checkout($customer) {
        // Proses pembayaran...
        // Kirim notifikasi
        if ($customer->hasWhatsApp()) {
            $this->sendWhatsAppNotification($customer);
        } else {
            $this->sendEmailNotification($customer);
        }
    }

    private function sendWhatsAppNotification($customer) {
        // Mengirim notifikasi ke WhatsApp
    }

    private function sendEmailNotification($customer) {
        // Mengirim notifikasi via email
    }
}

// 
$customer = 'misal data customer...'; 
$payment = new Payment();
$payment->checkout($customer);

Implementasi di atas mungkin tampak baik pada awalnya, tetapi itu melanggar prinsip LSP. Mengapa? Karena class Payment tidak fleksibel dan tidak dapat diperluas jika kita ingin menambahkan cara pengiriman notifikasi lainnya di masa depan.
Selain itu, class diatas mempunyai terlalu banyak tanggung jawab dan kurang terorganisir.

After

Untuk memperbaiki masalah di atas dan menerapkan LSP, kita akan menggunakan abstraksi untuk memisahkan logika notifikasi dari proses pembayaran.

// Abstract class untuk notifikasi
abstract class Notification {
    abstract public function send($customer);
}

// Implementasi notifikasi via WhatsApp
class WhatsAppNotification extends Notification {
    public function send($customer) {
        // Mengirim notifikasi ke WhatsApp
    }
}

// Implementasi notifikasi via email
class EmailNotification extends Notification {
    public function send($customer) {
        // Mengirim notifikasi via email
    }
}

class Payment {
    public function checkout($customer, Notification $notification) {
        // Proses pembayaran...

        // Kirim notifikasi menggunakan abstraksi
        $notification->send($customer);
    }
}

Sekarang, kode kita lebih sesuai dengan prinsip LSP. Mengapa?

• Kodenya lebih fleksibel, Jika kita ingin menambahkan metode notifikasi baru di masa depan, kita cukup membuat class baru yang mengimplementasikan abstraksi Notification,misal dimasa depan diharuskan menambahkan fitur notifikasi telegram, tentu dengan design kode diatas kita tinggal menambahkan class Telegram yang mengextends abstract class Notification, tanpa perlu merubah class Payment(Service Class).
• Tanggung jawab terkait notifikasi dipisahkan dari proses pembayaran, memperjelas struktur dan readable.
• Penggunaan abstraksi memungkinkan kita untuk mengganti atau memperluas perilaku notifikasi tanpa mempengaruhi class lain dalam sistem.

Setelah kita memiliki class Payment yang telah ditingkatkan, kita dapat mengintegrasikannya dengan mudah ke dalam kode kita.

$customer = 'misal data customer...'; 
$payment = new Payment();
$notification = $customer->hasWhatsApp() ? new WhatsAppNotification() : EmailNotification();
$payment->checkout($customer, $notification);

Kesimpulan

Dengan demikian, penggunaan LSP membawa manfaat seperti peningkatan fleksibilitas kode, lebih readable, dan kemampuan untuk mengganti atau memperluas fungsi/behaviour notifikasi tanpa mempengaruhi class lain dalam sistem. Ini memungkinkan developer untuk menghasilkan kode yang lebih modular, mudah dipelihara/maintainable, dan mudah diubah di masa depan.