Giriş
Adapter bir
Yapısal Örüntüdür. Adapter iki standart arayüzü birbirine dönüştürmek için
kullanılır. Burada dikkat edilmesi gereken kelime arayüz kelimesi. Örneğin VGA girişini DVI çıkışına çeviren fiziksel nesne de adaptördür. Adapter örüntüsü de fiziksel nesne ile aynı işlevi yapar.
Kavramlar
1.
Target Interface - Client tarafından bilinen arayüzdür.
2.
Adaptee Interface - Kullanılmak istenen ancak Target Interface'e
uymayan arayüzdür
3.
Adapter - Bizim yazdığımız kod. Adaptee nesnesini Target Interface ile uyumlu hale getirir.
Adapter Gerçekleştirimleri
Açıklaması
şöyle. Tüm Adapter örüntüleri kalıtım kullanmak zorundadır.
The GoF lists three different approaches to design a Target API for adaptation. The first two are recognizable as a couple of their Behavioral design patterns.
1. Template Method
2. Strategy
3. Closures (what Smalltalk calls code blocks)
Template Method
Normalde Eğer Strategy kullanıyorsak Adapter sınıfımızın constructor metoduna belli bir tip geçmek gerekir. Yani bir adapter bir target ile çalışır. Ancak elimizde daha fazla target nesne varsa template kullanabiliriz.
Örnek
Şöyle
yaparız. Burada amaç
Point bekleyen metoda örneğin
Line geçebilmek.
GenericLineAdapter kullanarak hangi tipte
Line olursa olsun onu
Point bekleyen metoda geçebiliriz.
template<class T>
struct GenericLineAdapter : Point {
T& m_line;
GenericLineAdapter(T &line) : m_line(line) {}
void draw(){ m_line.draw(); }
};
Strategy
Bu örüntünün iki çeşidi olsa da her iki yöntemde de Adapter, ihtiyaç duyduğumuz Target arayüzünü gerçekleştirmek zorundadır.
- Eğer Target bir sınıf ise Adapter mecburen kalıtır.
- Eğer Target bir arayüz ise Adapter bu arayüzü gerçekleştirir.
1. Object Adapter Türevi - Composition
Adapter sınıfı
Target arayüzünden kalıtır/gerçekleştirir ve verilen
Adaptee nesnesini
sarmalar. Yani klasik composition çözümü uygulanır. Eğer
Target sınıfının gerçekleştirilmesi gereken çok sayıda metodu varsa, zor bir çözüm halini alabilir.
Örnek
Şöyle
yaparız. Mevcut kod yani draw_point() metodu Point nesnesi alıyor. Ancak biz Line nesnesi kullanmak istiyoruz. LineAdapter ile bu iş halledilebilir.
struct Point {
int32_t m_x;
virtual void draw(){ cout<<"Point\n"; }
};
struct Point2D : Point {
int32_t m_y;
void draw(){ cout<<"Point2D\n"; }
};
void draw_point(Point &p) {
p.draw();
}
struct Line {
Point2D m_start;
Point2D m_end;
void draw(){ cout<<"Line\n"; }
};
struct LineAdapter : Point {
Line& m_line;
LineAdapter(Line &line) : m_line(line) {}
void draw(){ m_line.draw(); }
};
int main() {
Line l;
LineAdapter lineAdapter(l);
draw_point(lineAdapter);
return EXIT_SUCCESS;
}
1.1 Pluggable Adapter
Bu aslında Closure veya Functional Interfaces ile kurulan bir yapı. Açıklaması
şöyle.
A distinguishing feature of pluggable adapters is that the name of a method called by the client and that existing in the ITarget interface can be different. The adapter must be able to handle the name change. In the previous adapter variations, this was true for all Adaptee methods, but the client had to use the names in the ITarget interface. (...)
The pluggable adapter sorts out which object is being plugged in at the time. Once a service has been plugged in and its methods have been assigned to the delegate objects, the association lasts until another set of methods is assigned. What characterizes a pluggable adapter is that it will have constructors for each of the types that it adapts. In each of them, it does the delegate assignments (one, or more than one if there are further methods for rerouting).
Bir başka açıklama
şöyle
The pluggable adapter pattern is a technique for creating adapters that doesn't require making a new class for each adaptee interface you need to support.
Örnek
Elimizde şöyle bir kod
olsun. Bu örnekte Composition kullanılıyor ancak Target arayüzün Estimate() metodunu kullanmak yerine
yeni bir Request metodu tanımlanıyor. Request metodu istenirse Adaptee veya istenirse Target arayüzünü çağırabiliyor.
class Adaptee
{
public double Precise(double a, double b)
{
...;
}
}
// New standard for requests
class Target
{
public string Estimate(int i)
{
...
}
}
// Implementing new requests via old
class Adapter : Adaptee
{
public Func<int, string> Request;
// Different constructors for the expected targets/adaptees
// Adapter-Adaptee
public Adapter(Adaptee adaptee)
{
// Set the delegate to the new standard
Request = x => Math.Round(Precise(x, 3));
}
// Adapter-Target
public Adapter(Target target)
{
// Set the delegate to the existing standard
Request = target.Estimate;
}
}
Kullanmak için şöyle
yaparız.
Adapter adapter1 = new Adapter (new Adaptee( ));
//Here, it will call the Adaptee's abstracted method.
adapter1.Request(5);
//The only way to call the Target's method is to instantiate a new adapter with the
//target
Adapter adapter2 = new Adapter (new Target( ));
Console.WriteLine(adapter2.Request(5));
Örnek
Şöyle
yaparız. Burada Adapter Beverage ile ilklendirilirse Beverage gibi davranır. Eğer JuiceMaker ile ilklendirilirse JuiveMaker gibi davranır.
/* Legacy code -------------------------------------------------------------- */
struct Beverage {
virtual void getBeverage() = 0;
};
struct CoffeeMaker : Beverage {
void Brew() { cout << "brewing coffee" << endl;}
void getBeverage() { Brew(); }
};
void make_drink(Beverage &drink){
drink.getBeverage(); // Interface already shipped & known to client
}
/* --------------------------------------------------------------------------- */
struct JuiceMaker { // Introduced later on
void Squeeze() { cout << "making Juice" << endl; }
};
struct Adapter : Beverage { // Making things compatible
function<void()> m_request;
Adapter(CoffeeMaker* cm) { m_request = [cm] ( ) { cm->Brew(); }; }
Adapter(JuiceMaker* jm) { m_request = [jm] ( ) { jm->Squeeze(); }; }
void getBeverage() { m_request(); }
};
int main() {
Adapter adp1(new CoffeeMaker());
make_drink(adp1);
Adapter adp2(new JuiceMaker());
make_drink(adp2);
return EXIT_SUCCESS;
}
2. Class Adapter - Multiple Inheritance
Adapter sınıfı Target ve Adaptee sınıflarından multiple inheritance kullanarak aynı anda
kalıtır. C++ gibi diller tarafından kullanılabilen bir yöntem. Java gibi multiple inheritance desteklemeyen diller tarafından bu yöntem
biraz değiştirilerek kullanılır.
Örnek
C# kodunda şöyle
yaparız.
// Required standard for requests
interface ITarget {
// Rough estimate required
string Request (int i);
}
// Existing way requests are implemented
class Adaptee {
// Provide full precision
public double SpecificRequest (double a, double b) {
...;
}
}
// Implementing the required standard via Adaptee
class Adapter : Adaptee, ITarget {
public string Request (int i) {
return "Rough estimate is " + (int) Math.Round(SpecificRequest (i,3));
}
}
2.1 . Two Way Adapter
Two Way Adapter yazısına taşıdım.
Adapter'ın Hangi Mesajı Sarmaladığını Nasıl Anlarız
1. Adapter'a bir
getAdapteeMessageType() metodu yazılır. Bu metoda bakarak gerçek nesneye cast edilir.
Örnek - Yanlış İsimlendirme
Normalde
Adapter örüntüsü için iki tane farklı arayüz gerekir. Bunlar
Adaptee ve
Target Interface Elimizde
Callback şeklinde
Client'ı tetikleyen bir kod parçası vardı. Bu callback'lere bir filtre eklenmesi gerekti. Böylece
Client her zaman tetiklenmeyecekti.
Filtre koduna
Adapter ismi verildi.
Filtre kodu
EventSource'u ve
IFilter nesnesini sarmaladı ve
EventSource'a kendisi abone oldu. Gelen event'i süzdü ve gerekiyorsa
Client'a verdi. Burada bir arayüzü diğerine çevirme olayı olmamasına rağmen sınıfa
XFilterAdapter ismi verilmesi bence yanlıştı
Örnek - Doğru İsimlendirme
Elimizde iki tane mesaj seti vardı (
A seti ve
B seti) ve bu mesajlar farklı hiyererşilere sahipti. Client normalde
A seti ile çalışıyordu ancak daha sonra
B setine ne de çevirip farklı bir sisteme de mesaj gönderme ihtiyacı çıktı.
ABAdapter yazılarak A mesajını B mesajına çeviren ve gönderen bir sınıf yazıldı.
Diğer
Adapter,Decorator ve Facade davranış açısından bir başka nesneyi sarmaladıkları için birbirlerine benzerler. Açıklaması
şöyle.
A decorator makes it possible to add or alter behavior of an interface at run-time. Alternatively, the adapter can be used when the wrapper must respect a particular interface and must support polymorphic behavior, and the Facade when an easier or simpler interface to an underlying object is desired
Adapter ve Decorator arasındaki fark nedir
Decorator arayüzü
değiştirmez, sadece sınıfa yeni davranış ekler.
Facade ve Adapter arasındaki fark nedir?
Facade ise sadece kullanım kolaylığı için vardır. Arayüzler çok önemli
değildir.
