Series Belajar Solid Principle - Open Close Principle (OCP)
Tags: oop, solid, ocp, fundamental
Published: 2024-04-18 04:23:10

---
title: Series Belajar Solid Principle - Open Close Principle (OCP)

published: true

description: Dengan menerapkan Prinsip Open Close dan Prinsip Single Responsibility, kita membuat kode yang lebih adaptif dan mudah dimaintain. Dengan memisahkan tanggung jawab tiap komponen ke dalam kelas-kelas terpisah, kita memungkinkan penambahan fitur atau perubahan tanpa harus mengubah kode yang sudah ada.

tags: oop,solid,ocp,fundamental
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qwb1db4imqbpghbyviib.jpg---

Yo guys, Melanjutkan [series sebelumnya](https://dev.to/julles/series-belajar-solid-principle-single-responsibility-principle-srp-18j5) mengenai [Single Responsibility Principle](https://dev.to/julles/series-belajar-solid-principle-single-responsibility-principle-srp-18j5), kali ini gw akan menjelaskan tentang Open Close Principle.

Dalam dunia pemrograman, kita selalu mencari cara untuk membuat kode kita makin mudah untuk dikembangkan dan dimaintain, Salah satu pattern yang bisa kita pakai adalah Open Close Principle (OCP).

#### Apa Itu OCP?

OCP adalah salah satu pattern/principle yang membentuk SOLID, yang tujuannya membuat kode kita mudah jika ada perubahan, seperti penambahan fitur baru tanpa harus merubah bagian-bagian yang sudah ada.

Sama seperti [Series](https://dev.to/julles/series-belajar-solid-principle-single-responsibility-principle-srp-18j5) yg sebelumnya, gw akan menggunakan studi kasus proses checkout dan Notifikasi ke pelanggan.

#### Before
Sebelum menggunakan OCP, mungkin kode kita terlihat seperti ini:

``` php 
class CheckoutProcess {
    public function checkout($items,$customer) {
        // Proses checkout
        // ...

        // Update status di database
        $this->updateDatabase();
        
        if(!empty($customer->waNumber))
        {
            // Kirim pesan WhatsApp ke pelanggan
            $this->sendWhatsApp();
        }else{
             // Kirim email ke pelanggan
            $this->sendEmail();
        }
    }

    private function updateDatabase() {
        // Logika untuk memperbarui status di database
        // ...
    }

    private function sendEmail() {
        // Logika untuk mengirim email ke pelanggan
        // ...
    }

    private function sendWhatsApp() {
        // Logika untuk mengirim pesan WhatsApp ke pelanggan
        // ...
    }
}

```
Meskipun ini mungkin bekerja dengan baik, kekurangan dari codingan diatas adalah setiap kali kita ingin menambahkan method notifikasi baru seperti telegram notification misalnya, maka kita harus merubah class CheckoutProcess, hal ini tidak sesuai dengan OCP.


#### Implementasi OCP

[Diseries sebelumnya](https://dev.to/julles/series-belajar-solid-principle-single-responsibility-principle-srp-18j5) kita sudah belajar mengenai SRP ([Single Responsibility Principle](https://dev.to/julles/series-belajar-solid-principle-single-responsibility-principle-srp-18j5)) maka kita harus memisahkan class sesuai dengan perannya.

``` php
<?php 

class DatabaseUpdater {
  public function update($items) {
      // Logika untuk memperbarui status dalam database
  }
} 

interface NotificationService {
  public function notify();
}

class EmailNotification implements NotificationService {
  public function notify() {
      // Logic ngirim email
      // ...
  }
}

class WhatsAppNotification implements NotificationService {
  public function notify() {
      // Logic ngirim  WhatsApp
      // ...
  }
}

class CheckoutProcess {
  private $notificationService;

  public function __construct(DatabaseUpdater $db, NotificationService $notificationService) {
      $this->notificationService = $notificationService;
  }

  public function checkout($items) {
      // Proses checkout
      // ...

      // Update status di database
      $this->db->update($items);

      // Notifikasi ke pelanggan
      $this->notificationService->notify();
  }
}
```
Dalam implementasi di atas, kita telah memisahkan tanggung jawab masing-masing metode ke dalam class-class terpisah. class CheckoutProcess bertanggung jawab hanya untuk proses checkout dan tidak lagi tergantung pada implementasi langsung dari fungsi-fungsi atau method notification (sendWhatsApp() dan sendEmail()).

Koencinya ada di interface NotificationService
Dengan menggunakan interface, kita dapat dengan mudah menambahkan jenis notifikasi baru tanpa perlu merubah class-class lainnya. Interface ini memastikan bahwa setiap kelas yang berperan sebagai layanan notification (WhatsAppNotification,EmailNotification)  harus berisi method notify.

Setelah kita memiliki kelas CheckoutProcess yang dioptimalkan, kita dapat dengan mudah menggunakannya dalam codingan kita, contoh misalkan kita ingin menggunakan fungsi checkout tapi menggunakan whatsapp notifier

``` php
$db = new DatabaseUpdater();
$whatsappNotification = new WhatsAppNotification();
$checkoutWithWhatsApp = new CheckoutProcess($db,$whatsappNotification);
$checkoutWithWhatsApp->checkout($items);
```
Tapi jika kita ingin menggunakan email notifier, tinggal ubah saja WhatsappNotification menjadi EmailNotifcation.

``` php
$db = new DatabaseUpdater();
$emailNotification= new EmailNotification();
$checkoutWithEmail= new CheckoutProcess($db,$emailNotification);
$checkoutWithEmail->checkout($items);
```
Atau combine keduanya:
``` php
$db = new DatabaseUpdater();
$customer = 'misalkan berisi data customer';
$notification = !empty(@$customer->waNumber) ? new WhatsAppNotification() : new EmailNotification();
$checkout= new CheckoutProcess($db,$notification);
$checkout->checkout($items);
```
Dengan cara ini, kita bisa menggunakan CheckoutProcess dengan berbagai jenis notifikasi tanpa harus mengubah kode di dalam class tersebut. misalkan kedepannya client meminta notif ke telegram,sms,slack dan sebagainya.

#### Kesimpulan
Dengan menerapkan Prinsip Open Close dan Prinsip Single Responsibility, kita membuat kode yang lebih adaptif dan mudah dimaintain. Dengan memisahkan tanggung jawab tiap komponen ke dalam kelas-kelas terpisah, kita memungkinkan penambahan fitur atau perubahan tanpa harus mengubah kode yang sudah ada. Ini meningkatkan fleksibilitas dan mempermudah pengelolaan kode dalam jangka panjang. Karenanya, penting untuk selalu mempertimbangkan prinsip-prinsip SOLID dalam pengembangan perangkat lunak.