Modul 7 - Behavioral Patterns (Interpreter,
Iterator, Mediator)
Pada Modul ke 7 ini kita akan
membahas tentang pola Behavioral pattern yaitu kelas interpreter, iterator,
mediator pattern.
7.1. Interpreter Pattern
Sebuah masalah kelas terjadi berulang kali dalam sebuah
domain yang jelas dan dipahami dengan baik. Jika domain yang ditandai dengan
"bahasa", maka masalah bisa dengan mudah dipecahkan dengan
"mesin" interpretasi. Pola Interpreter mendefinisikan bahasa domain
(yaitu karakterisasi masalah) sebagai tata bahasa bahasa yang sederhana, yang
mewakili aturan domain sebagai kalimat bahasa, dan menafsirkan kalimat-kalimat
ini untuk memecahkan masalah. Pola ini menggunakan kelas untuk mewakili setiap
aturan tata bahasa. Dan karena tata bahasa biasanya hirarkis dalam struktur,
hirarki pewarisan kelas aturan memetakan dengan baik. Kelas dasar abstrak
menentukan metode interpret(). Setiap subclass beton mengimplementasikan interpret() dengan menerima (sebagai argumen) kondisi saat ini dari
aliran bahasa, dan menambahkan kontribusinya terhadap proses pemecahan masalah.
Interpreter menunjukkan pemodelan domain dengan tata bahasa
rekursif. Setiap aturan dalam tata bahasa yang bersangkutan merupakan
'komposit' (aturan bahwa referensi aturan lain) atau terminal (simpul daun
dalam struktur pohon). Juru bergantung pada traversal rekursif dari pola
Komposit untuk menafsirkan 'kalimat' itu diminta untuk diproses.
Berikut diagram UML
Interpreter pattern:
Berikut ini contoh
Code Interpreter dalam java:
using System;
using System.Collections;
namespace
DoFactory.GangOfFour.Interpreter.Structural
{
class MainApp
{
static void Main()
{
Context context = new
Context();
ArrayList list = new
ArrayList();
list.Add(new TerminalExpression());
list.Add(new NonterminalExpression());
list.Add(new TerminalExpression());
list.Add(new TerminalExpression());
foreach (AbstractExpression
exp in list)
{
exp.Interpret(context);
}
Console.ReadKey();
}
}
class Context
{
}
abstract class AbstractExpression
{
public abstract void Interpret(Context
context);
}
class TerminalExpression
: AbstractExpression
{
public override void Interpret(Context
context)
{
Console.WriteLine("Called
Terminal.Interpret()");
}
}
class NonterminalExpression
: AbstractExpression
{
public override void Interpret(Context
context)
{
Console.WriteLine("Called
Nonterminal.Interpret()");
}
}
}
7.2. Iterator
Pattern
Salah satu
struktur data yang paling umum dalam pengembangan perangkat lunak adalah
Collection. Collection ini mengelompokkan beberapa objek. Collection harus
menyediakan cara untuk mengakses suatu elemen tanpa memperlihatkan struktur di
dalamnya. Iterator pattern adalah untuk bertanggung jawab mengakses dan
melakukan passing objek pada collection lalu meletakkannya pada iterator objek.
Iterator objek ini akan mempertahankan kondisi iterasi, melacak item saat ini
dan mengidentifikasi elemen apa yang akan di iterasi selanjutnya. Tujuannya menyediakan
cara untuk mengakses elemen dari objek agregasi berurutan tanpa memperlihatkan
dasar representasinya. Abstraksinya memungkinkan untuk melakukan modifikasi
implementasi collection tanpa membuat perubahan diluar collection. Namun dalam
penggunaanya juga mengalami beberapa
masalah yaitu: Iterator dan multithreading, masalah akan muncul bila collection
ditambahkan dari thread yang berbeda. Tidak akan menjadi masalah bila
collection nya tidak berubah. Bila terjadi perubahan maka iterator harus berhati – hati. Tugas
utama saat membuat iterator
multithreading adalah membuat robust iterator sehingga perubahannya akan
tersinkronisasi. Saat iterator yang mengkontrol collection object maka disebut
internal iterator. Implementasi dan penggunaan internal iterator sangat sulit.
Berikut adalah diagram UML iterator
pattern:
Berikut ini contoh
Code Iterator dalam java:
using System;
using System.Collections;
namespace
DoFactory.GangOfFour.Iterator.Structural
{
class MainApp
{
static void Main()
{
ConcreteAggregate a = new ConcreteAggregate();
a[0] = "Item A";
a[1] = "Item B";
a[2] = "Item C";
a[3] = "Item D";
ConcreteIterator i = new ConcreteIterator(a);
Console.WriteLine("Iterating over collection:");
object item = i.First();
while (item != null)
{
Console.WriteLine(item);
item = i.Next();
}
Console.ReadKey();
}
}
abstract class Aggregate
{
public abstract Iterator CreateIterator();
}
class ConcreteAggregate
: Aggregate
{
private ArrayList
_items = new ArrayList();
public override
Iterator CreateIterator()
{
return new
ConcreteIterator(this);
}
public int Count
{
get { return
_items.Count; }
}
public object this[int index]
{
get { return
_items[index]; }
set { _items.Insert(index, value); }
}
}
abstract class Iterator
{
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
class ConcreteIterator
: Iterator
{
private ConcreteAggregate
_aggregate;
private int _current
= 0;
// Constructor
public ConcreteIterator(ConcreteAggregate
aggregate)
{
this._aggregate = aggregate;
}
public override object First()
{
return _aggregate[0];
}
// Gets next iteration item
public override object Next()
{
object ret = null;
if (_current <
_aggregate.Count - 1)
{
ret = _aggregate[++_current];
}
return ret;
}
// Gets current iteration item
public override object CurrentItem()
{
return _aggregate[_current];
}
// Gets whether iterations are complete
public override bool IsDone()
{
return _current >=
_aggregate.Count;
}
}
}
7.3. Mediator
Pattern
Mediator pattern termasuk dalam Behavioral Patterns (Pola
Perilaku), yang digunakan untuk mengelola interaksi antar kelas atau objek dan
pembagian tanggung jawab. Mediator Pattern menurut bahasa yaitu mendefinisikan
komunikasi yang sederhana antar kelas sedangkan menurut istilah adalah
abstrak/centralizes komunikasi sewenang-wenang antara obyek kita, secara rutin
menambah nilai, dan dikenal/direferensikan oleh objek kita (yakni
mendefinisikan sebuah protokol multi arah). Mediator pattern ialah
Mendifinisikan objek yang mengenkapsulasi bagaimana satu set objek
berinteraksi,. Mediator longgar mempromosikan kopling dengan menjaga
benda-benda dari merujuk kepada satu sama lain secara eksplisit dan
memungkinkan kita bervariasi interaksi secara mandiri.
Jadi Mediator memungkinkan kita untuk menciptakan sebuah
sistem longgar digabungkan dengan menciptakan satu set objek yang
mengenkapsulasi cara set benda berinteraksi satu sama lain. Dengan menghapus
perilaku ini dari objek individu kita mengurangi tanggung jawab mereka dan
mengurangi kopling. Berikut merupakan spesifikasi mediator pattern:
· Tergabung dalam tipe Behavioral Pattern
· Merupakan level Component
Tujuannya yaitu untuk mempermudah komunikasi antara
objek-objek dalam suatu sistem dengan memperkenalkan satu objek yang mengelola
pesan distribusi antara satu dengan yang lainnya.
Mediator
Dan Bagaimana Cara Menggunakannya
Kita tidak perlu untuk membuat kelas Abstrak (abstract
class) mediator atau antarmuka selama kita akan menggunakan hanya satu
mediator. Definisi dari Mediator abstrak diperlukan hanya jika kita perlu
bekerja dengan mediator yang berbeda. Ada berbagai cara untuk mewujudkan
komunikasi antara kita dan mediator, yaitu :
·
Paling
sering digunakan adalah dengan menggunakan Observer Pattern. Mediator dapat
juga di gunakan pengamat dan kolega dapat mengimplementasikan objek yang
diamati. Setiap kali mengubah dibuat di negara bagian
objek diamati, pengamat (mediator) akan diberitahu dan itu memberitahu semua
rekan objek lain.
· Metode alternatif dapat digunakan untuk mengirim pesan ke
mediator. Misalnya delegasi sederhana dapat digunakan dan metode khusus dapat
terpapar oleh mediator
·
Dalam
implementasi yang lebih kompleks pesan asinkron dapat ditambahkan ke antrian
pesan, dari mana mereka dapat diambil oleh objek mediator
Mediator pattern memiliki kompleksitas obyek mediator .
Objek mediator menangani semua interaksi antara obyek peserta. Salah satu
potensi masalah adalah kompleksitas mediator ketika jumlah peserta adalah
banyak dan peserta kelas yang banyak perbedaan. Jika kita membuat custome
dialog untuk aplikasi GUI, kita ingat bahwa setelah beberapa waktu kelas dialog
menjadi sangat kompleks karena mereka harus mengelola banyak operasi. Mediator
memiliki Struktur mediator yang merepresentasi bangun dari mediator, pada bagan
berikut terdapat poin yang perlu kita catat, yaitu :
·
Mediator
·
Colleague
·
Concrete
Mediator, dan
·
Concrete
Colleague
·
Mediator
Pattern Mediator membutuhkan antarmuka yang
mendefinisikan metode klien yang dapat memanggil pada Mediator.
·
ConcreteMediator
Ini berisi informasi aplikasi-spesifik tentang proses,
dan mungkin ConcreteMediator memiliki beberapa referensi hardcoded kepada
kliennya. Berdasarkan informasi yang Pengantara menerima, itu bisa memanggil
metode tertentu pada klien, atau memanggil sebuah metode umum untuk memberitahu
klien dari perubahan atau kombinasi keduanya. Interface mendefinisikan metode
umum mediator dan dapat digunakan untuk menginformasikan kasus kepada klien.
·
Client
Sebuah kelas yang mengimplementasikan antarmuka Klien dan
menyediakan implementasi untuk masing-masing.
·
ConcreteClient
ConcreteClient dapat menyimpan referensi ke contoh
Mediator untuk memberitahu klien rekan terhadap perubahan (melalui Mediator).
Mediator pattern dapat kita gunakan, ketika kita
menghadapi masalah berikut :
ü Ada aturan yang kompleks untuk komunikasi antara
objek-objek dalam suatu sistem (sering sebagai akibat dari model bisnis).
ü
Ketika
kita ingin menyimpan objek sederhana dan mudah dikelola. maintance.
ü Ketika kita ingin sebuah kelas untuk objek yang akan di
redeployable, sehingga tidak tergantung pada model bisnis sistem.
Berikut ini contoh
Code Mediator Pattern dalam java:
using System;
using System.Collections.Generic;
namespace
DoFactory.GangOfFour.Mediator.RealWorld
{
class MainApp
{
static void Main()
{
Chatroom chatroom = new
Chatroom();
Participant George = new
Beatle("George");
Participant Paul = new
Beatle("Paul");
Participant Ringo = new
Beatle("Ringo");
Participant John = new
Beatle("John");
Participant Yoko = new
NonBeatle("Yoko");
chatroom.Register(George);
chatroom.Register(Paul);
chatroom.Register(Ringo);
chatroom.Register(John);
chatroom.Register(Yoko);
// Chatting participants
Yoko.Send("John", "Hi
John!");
Paul.Send("Ringo", "All
you need is love");
Ringo.Send("George", "My
sweet Lord");
Paul.Send("John", "Can't
buy me love");
John.Send("Yoko", "My
sweet love");
// Wait for user
Console.ReadKey();
}
}
abstract class AbstractChatroom
{
public abstract void Register(Participant
participant);
public abstract void Send(
string from, string
to, string message);
}
class Chatroom : AbstractChatroom
{
private Dictionary<string,Participant>
_participants =
new Dictionary<string,Participant>();
public override void Register(Participant
participant)
{
if (!_participants.ContainsValue(participant))
{
_participants[participant.Name]
= participant;
}
participant.Chatroom
= this;
}
public override void Send(
string from, string
to, string message)
{
Participant participant = _participants[to];
if (participant != null)
{
participant.Receive(from,
message);
}
}
}
class Participant
{
private Chatroom
_chatroom;
private string _name;
// Constructor
public Participant(string
name)
{
this._name = name;
}
// Gets participant name
public string Name
{
get { return _name; }
}
// Gets chatroom
public Chatroom
Chatroom
{
set { _chatroom = value;
}
get { return
_chatroom; }
}
// Sends message to given participant
public void Send(string to, string
message)
{
_chatroom.Send(_name,
to, message);
}
// Receives message from given participant
public virtual void Receive(
string from, string
message)
{
Console.WriteLine("{0}
to {1}: '{2}'",
from,
Name, message);
}
}
class Beatle : Participant
{
// Constructor
public Beatle(string
name)
:
base(name)
{
}
public override void Receive(string
from, string message)
{
Console.Write("To
a Beatle: ");
base.Receive(from, message);
}
}
class NonBeatle : Participant
{
public NonBeatle(string
name)
:
base(name)
{
}
public override void Receive(string
from, string message)
{
Console.Write("To
a non-Beatle: ");
base.Receive(from, message);
}
}
}
Output:
Tidak ada komentar:
Posting Komentar