Eğitim Mh. Ahsen Çıkmazı Sk. Sadıkoğlu 5 Plaza No:12/41
Hasanpaşa, Kadıköy - İstanbul / Türkiye

Başlık

Autem vel eum iriure dolor in hendrerit in vulputate velit esse molestie consequat, vel illum dolore eu feugiat nulla facilisis at vero eros et dolore feugait

Tasarım Desenleri : Observer Design Pattern

Bu sefer adını çok duyduğumuz, bir çok yerde karşılaşabildiğimiz, gerçek hayattaki işleyişe çok benzeyen bir tasarım desenini tanıtmaya çalışacağım: Observer Design Pattern.

Observer’ın, kelime anlamı “Gözlemci” demektir. Observer Tasarım Deseni, “özne” konumundaki bir nesnenin kendisine bağımlı olan diğer nesnelere kendisinde gerçekleşen bir koşul, olay veya durum değişikliğini otomatik olarak bildirmesini, bu sayede de onların kendilerini güncellenmesini tetikleyen bir yapıyı tarif eder. Bu yapıda bağımlılıkların listesini tutan ve değişiklikleri takip eden “özne” konumunda bir ana nesne ve bu nesneye bildirim bağlamında bağımlı olan “Gözlemci” konumundaki birden çok alt nesne yer alır. Alt nesnelerin veya abonelerin ortak bir ata nesneden türetilmiş olması tercih edilir. Ortak bir atadan türetilmeseler bile kendi yapılarında bir “Update” metodunu barındırmaları gerekmektedir… Özünde bu tasarım deseni, “Özne” ile “Gözlemciler” arasındaki etkileşimin nasıl yönetileceğini yani bire çok olay işlemeyi nasıl gerçekleştirebileceğimizi tarif etmektedir.

Yukarıdaki paragraftan bu desenin çok basit bir yapısı olduğu izlenimine kapılabilirsiniz. Endişelenmeyin haklısınız, aslında bu kadar basit. Fakat tasarım desenini daha iyi anlamak için bu desenin çalışma biçimini bir hikaye üzerinden de anlatmayı deneyebiliriz…

Diyelim ki siz bir bankacısınız ve müşterilerinize yatırım danışmanlığı yapıyorsunuz. 3 tane müşteriniz var, bu müşteriler Dolar üzerinden al-sat işlemleri yapıyor fakat bu konuda sizden danışmanlık hizmeti alıyor… Siz dolar piyasasını takip ederken dolar düşmeden önce müşterilerinize “sat”, yükselmeden önce “al” önerisinde bulunuyorsunuz. İşte Observer tasarım deseni de aslında bu etkileşimin nasıl yönetileceğini tarif ediyor. bu senaryoya göre siz “Özne” (subject), müşterileriniz “Gözlemci” (observer), sizin “al” veya “sat” talimatlarınız “Bildirim” (Notification, NotifyObservers), müşterilerinizin “alma” veya “satma” eylemi “Güncelleme” (update) anlamına geliyor. Burada birisinin size müşteri olması durumu “aboneliği başlatıyor” (RegisterObserver), müşteriniz ile sizden aranızdaki iş ilişkisinin sona ermesi ise “aboneliği bitiriyor” (UnRegisterObserver). Son olarak portföyünüz ise “Müşteri Listeniz” (yani ObserverCollection) anlamına geliyor…

Bunu bir de aşağıdaki gibi bir UML diyagramında gösterelim.

Yukarıdaki senaryoyu ve UML diyagramını bir Pascal kodu ile örneklendirmeye çalışayım;


unit Observer_Objects_;
 
interface
 
uses
   Vcl.Dialogs                         //  ShowMessage
 , System.Generics.Collections         //  TList, TObjectList
 ;
 
 {
 Tasarım deseninde önerilen kalıptan uzaklaşmamak adına nesne ve değişken isimlerini UML diyagramındaki isimlerle benzeştirdim.
 Bu sayede UML diyagramında gösterilen nesnelerin Delphi kodunda nereye denk geldiğini daha kolay anlamış olacağız. Fakat siz bu
 isimlendirmeye uymak durumunda değilsiniz. Bu tasarım deseninde önemli olan, bu tür bir mekanizmayı hayata geçirebilmeniz...
 }
 
type
 // Gözlemcilerimiz için ortak bir arabirim tanımlıyoruz. Diğer gözlemci sınıflarını bu arabirimden türeteceğiz
 // veya bu arabirimi kullanarak ilgili sınıflara adaptör yazabileceğiz... Bu sayede abonelerin yok edilmesi sırasında
 // Bellek yönetimini en az eforla sağlamış olacağız.
 IObserver = interface
     procedure Update(aTalimat: String); // Bu metod aracılığıyla abonelerin kendierini güncellemesini tetikleyebileceğiz.
 end;
 
 // IObserver sınıfından türetilen aşağıdaki iki sınıf ise birbirinden farklı nesnelere dikkatinizi çekmek amacıyla tanımlandı.
 // UML Grafiğinde bu durumu sarı renklerde vurgulanmış bir şekilde görmektesiniz.
 TConcreateObserver_A = class(TInterfacedObject, IObserver) // bu sınıfı bir bakkal veya bir market gibi düşünün
   public
     procedure Update(aTalimat: String);  // Bu, "A" sınıfına özgü fiili bir güncelleme yapacak..
 end;
 TConcreateObserver_B = class(TInterfacedObject, IObserver) // bu sınıfı da bir fırıncı veya pastane gibi düşünün
   public
     procedure Update(aTalimat: String);  // Bu ise "B" sınıfına özgü fiili bir güncelleme yapılacak...
 end;
 
 // Özne tanımımızı bir Interface olarak yapıyoruz.
 ISubject = interface
   function  GetObserverCollection: TList;
   procedure SetObserverCollection(aObserverCollection: TList);
 
   property  ObserverCollection: TList        // Bu bizim abone listemiz, Sınıfı bir Interface değil de bir Abstract
        read GetObserverCollection                       // sınıf olarak sanımlasaydık bunu bir property
       write SetObserverCollection;                      // yerine doğrudan bir değişken olarak da kullanabilirdik.
 
   procedure NotifyObservers(aTalimat: string);          // Bu tüm gözlemcilerimize durum değişikliğini toplu olarak bildirir
   procedure RegisterObserver(aObserver: IObserver);     // Bu bizim yeni aboneyi listeye eklediğimiz metod
   procedure UnRegisterObserver(aObserver: IObserver);   // Bu bizim mevcut abonemizi listeden çıkaracak olan metodumuz
   procedure TEST(aTalimat: String);                     // Durum değişikliğinin gerçekleşeceği temsili bir metoddur.
 end;
 
 TSubject = class(TInterfacedObject, ISubject)
   private
 
     FObserverCollection: TList;              // Bu değişken aslında bizim abonelerimizin listesini tutacak
     function GetObserverCollection: TList;
     procedure SetObserverCollection(aObserverCollection: TList);
     procedure NotifyObservers(aTalimat: string);
   protected
   public
     constructor Create;
     destructor Destroy; override;
 
     // Bu bizin süreci tetiklediğimiz metod. Bu herhangi başka bir metod da olabilir. UML çiziminde bunu görmezsiniz
     // çünkü bu kısımm her türlü tetiklemeyi temsil ediyor.
     procedure TEST(aTalimat: String);
     procedure RegisterObserver(aObserver: IObserver);
     procedure UnRegisterObserver(aObserver: IObserver);
     property  ObserverCollection: TList
         read  GetObserverCollection
         write SetObserverCollection;
 end;
 
implementation
 
{ TSubject }
 
constructor TSubject.Create;
begin
 inherited Create;
 FObserverCollection := TList.Create;
end;
 
destructor TSubject.Destroy;
begin
 FObserverCollection.Destroy; // FreeAndNil ( FObserverCollection ); de kullanılabilir.
 inherited Destroy;
end;
 
procedure TSubject.RegisterObserver(aObserver: IObserver);
begin
 GetObserverCollection.Add(aObserver)
end;
 
procedure TSubject.UnRegisterObserver(aObserver: IObserver);
begin
 GetObserverCollection.Remove(aObserver);
end;
 
procedure TSubject.NotifyObservers(aTalimat: string);
var
 aObserver: IObserver;
begin
 for aObserver in GetObserverCollection    // Gözlemci listemizdeki her bir gözlemciyi tek tek ziyaret edip
  do aObserver.Update(aTalimat);           // kendisini güncellemesini sağlıyoruz.
end;
 
function TSubject.GetObserverCollection: TList;
begin
 Result := FObserverCollection;
end;
 
procedure TSubject.SetObserverCollection(aObserverCollection: TList);
begin
 FObserverCollection := aObserverCollection;
end;
 
procedure TSubject.TEST(aTalimat: String);
begin
 // Burası ise fiilen durumun değiştiği kök noktamız.
 ShowMessage('Gözlemci Listesindeki her bir gözlemciye şu talimatı verdim = ' + aTalimat);
 
 // Durum değişikliği gerçekleştikten sonra oluşan yeni konjonktürü gözlemcilerimize bildiriyoruz.
 NotifyObservers(aTalimat);
end;
 
{ TConcreateObserver_A }
 
procedure TConcreateObserver_A.Update(aTalimat: String);
begin
 // A tipindeki bu gözlemciyi mesela bir bakkal olarak düşünebilirsiniz
 ShowMessage('A Sınıfına göre değişik bir güncelleme işlemi yaptık = ' + aTalimat);
end;
 
{ TConcreateObserver_B }
 
procedure TConcreateObserver_B.Update(aTalimat: String);
begin
 // B tipindeki bu gözlemcisi ise misalen bir fırıncı olarak düşünebilirisinis.
 ShowMessage('B Sınıfına göre çok farklı, emsalsiz bir başka güncelleme işlemi daha yaptık = ' + aTalimat);
end;
 
end.

Gelelim, şimdi bu yapının nasıl kullanıldığına.


implementation
 
uses
   Observer_Objects_                                             // Sınıfın tanımlı olduğu Uniti kullanacağız.
 ;
 
{$R *.dfm}
 
procedure TAna.Button1Click(Sender: TObject);                     // Bir butonun OnClick olayına
var
 KurTakipcisi: TSubject;                                         // özne konumundaki bir nesneyi değişken olarak tanımladık
begin
 KurTakipcisi := TSubject.Create;                                // Özneyi oluşturduk
 KurTakipcisi.RegisterObserver(TConcreateObserver_A.Create);     // A türünden bir gözlemci / abone / alt nesne oluşturduk
 KurTakipcisi.RegisterObserver(TConcreateObserver_B.Create);     // B türünden başka bir gözlemci / abone / alt nesne oluşturduk
 KurTakipcisi.RegisterObserver(TConcreateObserver_A.Create);     // A türünden başka bir gözlemci / abone / alt nesne oluşturduk
 KurTakipcisi.RegisterObserver(TConcreateObserver_B.Create);     // B türünden başka bir gözlemci / abone / alt nesne oluşturduk
 
 KurTakipcisi.TEST('Al');                                        // durum değişikliğini tetiklemek için "AL" emri verdik
 
 FreeAndNil(KurTakipcisi);                                       // Öznemizi ve ona bağlı olan tüm aboneleri bellekten temizledik.
end;
 
// VEYA BAŞKA BİR KULLANIM ŞEKLİ (ASLINDA AYNI. SADECE ABONELERİN KİM OLDUĞUNU DAHA NET BİLİYORUZ )
 
procedure TAna.Button2Click(Sender: TObject);                     // BAŞKA bir butonun OnClick olayına
var
 KurTakipcisi : TSubject;                                        // Özne konumunda olan bir BANKACIYI değişken olarak tanımladık
 Firinci      : TConcreateObserver_A;                            // A tipli
 Bakkal       : TConcreateObserver_B;                            // B tipli
begin
 Firinci      := TConcreateObserver_A.Create;                    // Bir fırıncı oluşturduk.
 
 KurTakipcisi := TSubject.Create;                                // Bankacımızı oluşturduk.
 KurTakipcisi.RegisterObserver( Firinci );                       // Fırıncımızı abone listesine aldık
 KurTakipcisi.RegisterObserver( TConcreateObserver_B.Create );   // B tipinde başka birisi bize abone oldu
 
 Bakkal       := TConcreateObserver_B.Create;                    // Bir bakkal oluşturduk
 KurTakipcisi.RegisterObserver( Bakkal );                        // Bakkalımızı abone listesine aldık
 
 KurTakipcisi.TEST('Sat');                                       // tüm abonelere Satma yönünde talimat verdik
 
 KurTakipcisi.UnRegisterObserver( Firinci );                     // Fırıncı bizim hizmetten memnun kalmadığı için listemizden çıkardık...
 
 KurTakipcisi.TEST('Al');                                        // geri kalan tüm abonelere Alma yönünde talimat verdik...
 
 FreeAndNil(KurTakipcisi);
end;
Uğur PARLAYAN

1976 İstanbul doğumlu yazar, yeniliğe ve teknolojiye karşı aşırı ilgisi nedeniyle ortaokul yıllarında tanıştığı programlamayı profesyonel düzeyde devam ettirmektedir. 2005 yılından bu yana perakende, hukuk, lojistik ve makine haberleşmesi konuları başta olmak üzere çeşitli masaüstü ve internet tabanlı yazılımlar geliştirmiştir. Öğrenmenin, yeniliklere açık olmanın bu mesleğin temel taşlarından birisi olduğunun farkında olan yazarımız 2016 Yılında Rubicube Yazılım, Donanım ve Teknoloji Hizmetleri Limited Şirketini kurmuş ve çalışmalarını bu şemsiye altında devam etmektedir.

Yorum yapabilmek için giriş yapmalısınız