Mediator Pattern #

Dalam pengembangan perangkat lunak, komunikasi antar objek sering kali menjadi kompleks ketika jumlah objek meningkat. Setiap objek mungkin perlu berinteraksi dengan banyak objek lain, yang menyebabkan tight coupling dan sulitnya pemeliharaan kode. Mediator Pattern adalah salah satu solusi dari behavioral design pattern yang membantu mengurangi kompleksitas komunikasi antar objek dengan memperkenalkan objek perantara, atau mediator, yang bertanggung jawab mengatur interaksi antar objek.

Apa itu Mediator Pattern? #

Mediator Pattern adalah pola desain perilaku (behavioral pattern) yang mendefinisikan objek yang mengelola komunikasi antar objek lain sehingga objek-objek tersebut tidak perlu secara langsung berkomunikasi satu sama lain. Dengan pola ini, masing-masing objek fokus pada logikanya sendiri dan interaksi antar objek diatur oleh mediator.

Struktur Umum: #

• Mediator: Interface atau abstraksi mediator.
• ConcreteMediator: Implementasi mediator yang mengatur komunikasi antar colleagues.
• Colleague: Objek yang berkomunikasi melalui mediator.

Tujuan dari Pattern #

• Mengurangi tight coupling antar objek.
• Menyederhanakan komunikasi kompleks di antara objek.
• Mempermudah pemeliharaan dan pengembangan kode.
• Menjadi pusat pengontrol interaksi antar objek, sehingga logika interaksi tidak tersebar di banyak tempat.

Kapan Cocok Digunakan? #

• Ketika banyak objek berinteraksi satu sama lain, sehingga kompleksitas komunikasi tinggi.
• Saat ingin mengurangi ketergantungan langsung antar objek.
• Saat logika koordinasi antar objek sering berubah dan perlu dikontrol di satu tempat.
• Cocok untuk chatroom, sistem UI kompleks, workflow engine, atau event system.

Contoh Implementasi (Golang) #

Berikut contoh sederhana Mediator Pattern untuk sistem chatroom:

package main

import (
	"fmt"
)

// Mediator Interface
type ChatRoomMediator interface {
	ShowMessage(user *User, message string)
}

// Concrete Mediator
type ChatRoom struct{}

func (c *ChatRoom) ShowMessage(user *User, message string) {
	fmt.Printf("[%s]: %s\n", user.Name, message)
}

// Colleague
type User struct {
	Name     string
	Mediator ChatRoomMediator
}

func (u *User) SendMessage(message string) {
	u.Mediator.ShowMessage(u, message)
}

func main() {
	chatRoom := &ChatRoom{}

	user1 := &User{Name: "Alice", Mediator: chatRoom}
	user2 := &User{Name: "Bob", Mediator: chatRoom}

	user1.SendMessage("Hello Bob!")
	user2.SendMessage("Hi Alice!")
}

Output:

[Alice]: Hello Bob!
[Bob]: Hi Alice!

Pada contoh ini, User tidak langsung mengirim pesan ke user lain, melainkan melalui ChatRoom sebagai mediator.

Tambahan Informasi #

• Mediator Pattern sering dibandingkan dengan Observer Pattern. Perbedaan utamanya, Observer memberikan notifikasi secara broadcast, sedangkan Mediator mengontrol interaksi secara terpusat.
• Pola ini banyak digunakan pada sistem UI (misal: form dengan banyak input saling mempengaruhi), workflow engine, sistem game, dan protokol komunikasi internal.

Best Practices #

1. Single Responsibility: Pastikan mediator hanya mengatur komunikasi antar objek, tidak menangani logika bisnis lain.
2. Scalability: Jika mediator menjadi sangat besar karena banyak colleague, pertimbangkan membaginya menjadi beberapa mediator spesifik.
3. Loose Coupling: Colleague sebaiknya hanya mengenal mediator, bukan objek lain.
4. Testable: Dengan mediator terpisah, testing komunikasi antar objek lebih mudah.

Penutup #

Mediator Pattern adalah solusi efektif untuk mengelola kompleksitas komunikasi antar objek dalam software. Dengan memperkenalkan mediator, sistem menjadi lebih mudah di-maintain, fleksibel, dan scalable. Implementasi sederhana di Golang memperlihatkan bagaimana pola ini dapat diterapkan untuk kasus nyata seperti chatroom atau sistem interaksi antar komponen.