Mengenal Design Pattern dalam Pengembangan Software

Apa itu Design Pattern?

Design pattern adalah solusi umum yang sudah terbukti untuk masalah-masalah yang sering muncul dalam desain software. Design pattern bukan kode yang bisa langsung di-copy paste, melainkan template atau blueprint yang bisa Anda adaptasi untuk menyelesaikan masalah desain tertentu dalam kode Anda.

Konsep design pattern dipopulerkan oleh buku "Design Patterns: Elements of Reusable Object-Oriented Software" yang ditulis oleh Gang of Four (GoF) pada tahun 1994.

Kategori Design Pattern

Design pattern umumnya dibagi menjadi tiga kategori:

1. Creational Pattern: Berkaitan dengan cara membuat object
2. Structural Pattern: Berkaitan dengan komposisi class dan object
3. Behavioral Pattern: Berkaitan dengan komunikasi antar object

1. MVC (Model-View-Controller)

MVC adalah architectural pattern yang paling banyak digunakan dalam web development. Pattern ini memisahkan aplikasi menjadi tiga komponen:

• Model: Menangani data dan business logic
• View: Menangani tampilan dan presentasi data ke user
• Controller: Menerima input dari user dan mengkoordinasikan Model dan View

Framework seperti CodeIgniter, Laravel, dan Django mengadopsi pattern ini. Kelebihannya adalah separation of concerns yang jelas, memudahkan maintenance dan testing.

Contoh Sederhana MVC

// Model - User_model.php
class User_model extends CI_Model {
  public function get_user($id) {
    return $this->db->get_where('users', ['id' => $id])->row();
  }
}

// Controller - User.php
class User extends CI_Controller {
  public function profile($id) {
    $data['user'] = $this->User_model->get_user($id);
    $this->load->view('user/profile', $data);
  }
}

// View - profile.php
<h1><?= $user->name ?></h1>
<p><?= $user->email ?></p>

2. Singleton Pattern

Singleton memastikan bahwa sebuah class hanya memiliki satu instance dan menyediakan global access point ke instance tersebut. Pattern ini berguna untuk resource yang harus shared seperti database connection atau configuration manager.

class Database {
  private static $instance = null;
  private $connection;

  private function __construct() {
    $this->connection = new PDO('mysql:host=localhost;dbname=mydb', 'root', '');
  }

  public static function getInstance() {
    if (self::$instance === null) {
      self::$instance = new self();
    }
    return self::$instance;
  }
}

3. Factory Pattern

Factory pattern menyediakan interface untuk membuat object tanpa menentukan class spesifik dari object tersebut. Pattern ini berguna ketika Anda memiliki beberapa class yang mengimplementasikan interface yang sama.

interface Notification {
  public function send($message);
}

class EmailNotification implements Notification {
  public function send($message) {
    // Kirim email
  }
}

class SMSNotification implements Notification {
  public function send($message) {
    // Kirim SMS
  }
}

class NotificationFactory {
  public static function create($type) {
    switch ($type) {
      case 'email': return new EmailNotification();
      case 'sms': return new SMSNotification();
      default: throw new Exception('Unknown type');
    }
  }
}

4. Observer Pattern

Observer pattern mendefinisikan hubungan one-to-many antara object, sehingga ketika satu object berubah state, semua dependennya akan di-notify dan di-update secara otomatis. Pattern ini banyak digunakan untuk event handling.

class EventManager {
  private $listeners = [];

  public function subscribe($event, $callback) {
    $this->listeners[$event][] = $callback;
  }

  public function notify($event, $data) {
    foreach ($this->listeners[$event] as $callback) {
      call_user_func($callback, $data);
    }
  }
}

// Usage
$events = new EventManager();
$events->subscribe('user_registered', function($user) {
  // Kirim welcome email
});
$events->subscribe('user_registered', function($user) {
  // Catat di log
});
$events->notify('user_registered', $newUser);

Kapan Menggunakan Design Pattern?

Design pattern sebaiknya digunakan ketika:

• Anda menghadapi masalah yang sudah pernah diselesaikan oleh pattern tersebut
• Kode Anda mulai sulit di-maintain karena terlalu tightly coupled
• Anda ingin membuat kode yang lebih scalable dan testable

Namun, hindari over-engineering. Jangan memaksakan pattern jika masalahnya sederhana.

Kesimpulan

Memahami design pattern akan membuat Anda menjadi developer yang lebih baik. Pattern-pattern ini adalah wisdom dari developer berpengalaman yang telah teruji waktu. Mulailah dengan memahami MVC karena hampir semua framework modern menggunakannya, lalu pelajari pattern lain secara bertahap sesuai kebutuhan project Anda.