Kamis, 14 Juni 2012

Modul 7 - Behavioral Patterns (Interpreter, Iterator, Mediator)


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:



0 komentar:

Posting Komentar