Observer Pattern #

Dalam dunia perangkat lunak, seringkali kita memiliki situasi di mana suatu objek perlu memberi tahu objek lain ketika terjadi perubahan. Observer Pattern adalah salah satu pola desain yang masuk dalam kategori Behavioral Pattern, yang fokus pada interaksi dan komunikasi antar objek.

Behavioral pattern membantu kita mengelola alur kontrol dan tanggung jawab antar objek. Observer Pattern khususnya berguna ketika kita ingin membuat sistem yang loosely coupled, sehingga perubahan pada satu objek tidak memaksa perubahan langsung pada objek lain.

Apa itu Observer Pattern? #

Observer Pattern adalah pola desain di mana satu objek, yang disebut Subject, menjaga daftar dependensi atau Observers, dan secara otomatis memberi tahu mereka ketika ada perubahan status. Dengan kata lain, Observer Pattern mendukung mekanisme publish-subscribe di mana objek lain dapat “mendengar” perubahan dari subject tanpa harus mengetahui detail internal subject.

Komponen utama:

1. Subject: Menyimpan daftar observers dan memiliki metode untuk menambahkan, menghapus, dan memberi tahu observers.
2. Observer: Interface yang menentukan metode Update atau metode serupa yang dipanggil oleh subject saat terjadi perubahan.

Diagram sederhananya:

Subject ----> Observer1
        
         ----> Observer2
        
         ----> Observer3

Tujuan dari Pattern #

1. Loose Coupling: Subject dan observers tidak bergantung secara langsung satu sama lain.
2. Dynamic Relationships: Observer dapat ditambah atau dihapus secara runtime.
3. Automated Updates: Memastikan semua dependensi selalu up-to-date ketika terjadi perubahan pada subject.

Kapan Cocok Digunakan? #

Observer Pattern cocok digunakan ketika:

• Anda memiliki satu objek yang perubahan statusnya harus diketahui banyak objek.
• Anda ingin menghindari coupling yang kuat antara objek-objek yang saling berinteraksi.
• Sistem perlu mendukung event-driven programming, misalnya GUI, notifikasi, atau sistem monitoring.

Contoh nyata:

• Sistem notifikasi email atau push notification.
• Event listener pada GUI.
• Stock price monitoring di aplikasi keuangan.

Contoh Implementasi (Golang) #

Berikut contoh sederhana implementasi Observer Pattern di Golang:

package main

import (
	"fmt"
)

// Observer interface
type Observer interface {
	Update(message string)
}

// Subject interface
type Subject interface {
	Register(observer Observer)
	Unregister(observer Observer)
	Notify()
}

// ConcreteSubject
type NewsPublisher struct {
	observers []Observer
	news      string
}

func (n *NewsPublisher) Register(o Observer) {
	n.observers = append(n.observers, o)
}

func (n *NewsPublisher) Unregister(o Observer) {
	for i, observer := range n.observers {
		if observer == o {
			n.observers = append(n.observers[:i], n.observers[i+1:]...)
			break
		}
	}
}

func (n *NewsPublisher) Notify() {
	for _, observer := range n.observers {
		observer.Update(n.news)
	}
}

func (n *NewsPublisher) AddNews(news string) {
	n.news = news
	n.Notify()
}

// ConcreteObserver
type Subscriber struct {
	name string
}

func (s *Subscriber) Update(news string) {
	fmt.Printf("%s received news: %s\n", s.name, news)
}

func main() {
	publisher := &NewsPublisher{}

	subscriber1 := &Subscriber{name: "Alice"}
	subscriber2 := &Subscriber{name: "Bob"}

	publisher.Register(subscriber1)
	publisher.Register(subscriber2)

	publisher.AddNews("Observer Pattern Released in Golang!")

	publisher.Unregister(subscriber1)
	publisher.AddNews("Second news update.")
}

Output:

Alice received news: Observer Pattern Released in Golang!
Bob received news: Observer Pattern Released in Golang!
Bob received news: Second news update.

Best Practices #

1. Loose Coupling: Pastikan observers tidak memiliki referensi langsung ke internal subject.
2. Minimize Side Effects: Update method sebaiknya tidak memodifikasi subject.
3. Thread Safety: Jika digunakan di aplikasi concurrent, gunakan mekanisme sinkronisasi untuk mencegah race condition.
4. Unregister Observers: Selalu sediakan mekanisme untuk menghapus observer yang tidak lagi membutuhkan notifikasi, agar tidak terjadi memory leak.
5. Use Event Channels (Optional): Di Golang, bisa memanfaatkan channel untuk implementasi event-driven yang lebih scalable.

Penutup #

Observer Pattern adalah salah satu behavioral design pattern yang berguna untuk mengelola komunikasi antar objek secara loosely coupled. Dengan menggunakan pattern ini, kita dapat membuat sistem yang lebih modular, mudah diperluas, dan mudah dirawat. Cocok untuk sistem notifikasi, GUI, atau event-driven system di mana banyak objek perlu merespons perubahan state satu objek secara real-time.