Builder tasarım deseni ile Fabrika tasarım deseni arasındaki fark nedir?

Hangisi daha avantajlıdır ve neden?

Bu kalıpları test etmek ve karşılaştırmak / karşılaştırmak istiyorsam bulgularımı grafik olarak nasıl temsil edebilirim?

Tasarım desenleriyle, genellikle tüm durumlar için çalışan "daha avantajlı" bir çözüm yoktur. Neyi uygulamanız gerektiğine bağlıdır.

Wikipedia'dan:

• Oluşturucu, adım adım karmaşık bir nesne oluşturmaya odaklanır. Abstract Factory bir ürün nesneleri ailesini (basit veya karmaşık) vurgular. Oluşturucu ürünü son bir adım olarak iade eder, ancak Soyut Fabrika söz konusu olduğunda, ürün hemen iade edilir.
• Oluşturucu genellikle bir Kompozit oluşturur.
• Genellikle tasarımlar, Fabrika Yöntemi (daha az karmaşık, daha özelleştirilebilir, alt sınıflar çoğalır) kullanarak başlar ve tasarımcı daha fazla esnekliğin gerekli olduğu yeri keşfederken Soyut Fabrika, Prototip veya Oluşturucu'ya (daha esnek, daha karmaşık) doğru gelişir.
• Bazen yaratıcı kalıplar tamamlayıcıdır: Oluşturucu, hangi bileşenlerin oluşturulduğunu uygulamak için diğer kalıplardan birini kullanabilir. Abstract Factory, Builder ve Prototype uygulamalarında Singleton'u kullanabilir.

Fabrika tasarım deseni için Wikipedia girişi: http://en.wikipedia.org/wiki/Factory_method_pattern

Oluşturucu tasarım deseni için Wikipedia girişi: http://en.wikipedia.org/wiki/Builder_pattern

Bir fabrika , bir kurucu etrafındaki bir sarmalayıcı işlevidir (muhtemelen farklı bir sınıftaki bir). Temel fark, bir fabrika yöntem kalıbının tüm nesnenin tek bir yöntem çağrısında oluşturulmasını ve tüm parametrelerin tek bir satıra aktarılmasını gerektirmesidir. Son nesne döndürülecektir.

Öte yandan bir oluşturucu deseni , bir kurucu çağrısına geçmek isteyebileceğiniz tüm olası parametrelerin etrafındaki bir sarıcı nesnedir. Bu, parametre listenizi yavaşça oluşturmak için ayarlayıcı yöntemlerini kullanmanızı sağlar. Bir oluşturucu sınıfındaki ek bir yöntem, oluşturucu nesnesini istenen yapıcıya geçiren ve sonucu döndüren bir build () yöntemidir.

Java gibi statik dillerde, bu, olası tüm parametre kombinasyonları için teleskopik kuruculara sahip olma gereksinimini ortadan kaldırdığından, birkaç (potansiyel olarak isteğe bağlı) parametreden fazlasına sahip olduğunuzda daha önemli hale gelir. Ayrıca bir oluşturucu, kurucu çağrıldıktan sonra doğrudan değiştirilemeyen salt okunur veya özel alanları tanımlamak için ayarlayıcı yöntemlerini kullanmanızı sağlar.

Temel Fabrika Örneği

// Factory
static class FruitFactory {
    static Fruit create(name, color, firmness) {
        // Additional logic
        return new Fruit(name, color, firmness);
    }
}

// Usage
Fruit fruit = FruitFactory.create("apple", "red", "crunchy");

Temel Oluşturucu Örneği

// Builder
class FruitBuilder {
    String name, color, firmness;
    FruitBuilder setName(name)         { this.name     = name;     return this; }
    FruitBuilder setColor(color)       { this.color    = color;    return this; }
    FruitBuilder setFirmness(firmness) { this.firmness = firmness; return this; }
    Fruit build() {
        return new Fruit(this); // Pass in the builder
    }
}

// Usage
Fruit fruit = new FruitBuilder()
        .setName("apple")
        .setColor("red")
        .setFirmness("crunchy")
        .build();

Bu iki wikipedia sayfasındaki kod örneklerini karşılaştırmak faydalı olabilir:

http://en.wikipedia.org/wiki/Factory_method_pattern
http://en.wikipedia.org/wiki/Builder_pattern

Fabrika kalıbı neredeyse Oluşturucu kalıbının basitleştirilmiş bir versiyonu olarak görülebilir.

Gelen Fabrika desen, fabrika ihtiyaçlarına bağlı olarak bir nesnenin değişik alt türleri oluşturma sorumludur.

Bir fabrika yönteminin kullanıcısının bu nesnenin tam alt türünü bilmesine gerek yoktur. Fabrika yöntemine bir örnek, bir veya yazılan bir nesneyi createCardöndürebilir .FordHonda

Gelen Oluşturucu desen, farklı alt tipler de bir kurucu yöntemi ile oluşturulur, ancak nesnelerin bileşimi aynı alt sınıf içinde farklılık gösterebilir.

Araba örneğine devam etmek için 4 silindirli bir motora sahip bir tip nesne veya 6 silindirli createCarbir Hondatipli nesne oluşturan bir oluşturucu yönteminiz olabilir Honda. Oluşturucu modeli bu daha ince tanecikliğe izin verir.

Hem Builder deseninin hem de Factory yöntem deseninin diyagramları Wikipedia'da mevcuttur.

Oluşturucu tasarım deseni, belirli bir türde başka bir nesnenin birkaç adımda nasıl oluşturulacağını bilen bir nesneyi açıklar. Her bir ara adımda hedef madde için gereken durumu tutar. Son bir dize oluşturmak için StringBuilder'ın nelerden geçtiğini düşünün.

Fabrika tasarım deseni, belirli bir türde belirli parametrelere göre seçildiği bir adımda birkaç farklı ancak ilgili nesne türünün nasıl oluşturulacağını bilen bir nesneyi açıklar. Serileştiricinizi oluşturduğunuz ve tek bir yükleme çağrısında nesne içinde istenen nesneyi oluşturduğu serileştirme sistemini düşünün.

• Adım adım karmaşık bir nesne oluşturma: oluşturucu deseni

• Tek bir yöntem kullanılarak basit bir nesne oluşturulur: fabrika yöntem kalıbı

• Birden çok fabrika yöntemi kullanarak nesne oluşturma: Soyut fabrika düzeni

Oluşturucu Deseni ve Fabrika deseni, ikisi de çıplak gözlere oldukça benziyor çünkü ikisi de sizin için nesne yaratıyor.

Ama daha yakından bakmalısın

Bu gerçek hayat örneği ikisi arasındaki farkı daha net hale getirecektir.

Varsayalım, bir fast food restoran gitti ve sipariş Yiyecek .

1) Hangi Yiyecek?

Pizza

2) Ne Topingler?

Capsicum, Domates, Barbekü tavuk, PINEAPPLE YOK

Bu nedenle, Fabrika deseni tarafından farklı türde yiyecekler yapılır, ancak belirli bir yiyeceğin farklı varyantları (lezzetleri) Builder modeli tarafından yapılır.

Farklı yiyecek çeşitleri

Pizza, Burger, Makarna

Pizza Çeşitleri

Sadece Peynir, Peynir + Domates + Capsicum, Peynir + Domates vb.

Kod örneği

Her iki desenin örnek kod uygulamasını burada görebilirsiniz
Builder Pattern
Factory Pattern

Her ikisi de Nesne oluşturmak için Yaratıcı kalıplardır.

1) Fabrika Deseni - Varsayalım, bir süper sınıfınız ve N sayıda alt sınıfınız var. Nesne, hangi parametrenin / değerin geçirildiğine bağlıdır.

2) Oluşturucu deseni - karmaşık nesne oluşturmak için.

Ex: Make a Loan Object. Loan could be house loan, car loan ,
    education loan ..etc. Each loan will have different interest rate, amount ,  
    duration ...etc. Finally a complex object created through step by step process.

İlk önce benim argümanımı takip etmek için bazı genel şeyler:

Büyük yazılım sistemlerinin tasarlanmasındaki temel zorluk, değişebilmeleri için esnek ve karmaşık olmalarıdır. Bu nedenle, birleştirme ve uyum gibi bazı metrikler vardır. Tüm sistemi sıfırdan yeniden tasarlamaya gerek kalmadan işlevselliğinde kolayca değiştirilebilen veya genişletilebilen sistemler elde etmek için tasarım ilkelerini (SOLID vb. Gibi) takip edebilirsiniz. Bir süre sonra bazı geliştiriciler, bu ilkeleri uygularlarsa benzer sorunlara iyi çalışan benzer çözümlerin olduğunu fark ettiler. Bu standart çözümlerin tasarım kalıpları olduğu ortaya çıktı.

Bu nedenle tasarım kalıpları, yüksek uyum sağlayan gevşek bağlı sistemlere ulaşmak için genel tasarım prensiplerini takip etmenize yardımcı olmak içindir.

Soruyu cevaplamak:

İki örüntü arasındaki farkı sorarak, kendinize hangi örüntünün sisteminizi daha esnek hale getirdiğini sormalısınız. Her desenin, sisteminizdeki sınıflar arasındaki bağımlılıkları organize etmek için kendi amacı vardır.

Soyut Fabrika Deseni: GoF: “Somut sınıflarını belirtmeden ilgili veya bağımlı nesnelerin ailelerini oluşturmak için bir arayüz sağlayın.”

Bu ne anlama geliyor: Böyle bir arayüz sağlayarak, ailenin her ürününün kurucusuna yapılan çağrı fabrika sınıfında kapsüllenir. Ve bu, tüm sisteminizde bu kurucuların çağrıldığı tek yer olduğundan, yeni bir fabrika sınıfı uygulayarak sisteminizi değiştirebilirsiniz. Fabrikanın temsilini bir başkasıyla değiştirirseniz, kodunuzun çoğuna dokunmadan tüm bir ürün setini değiştirebilirsiniz.

Oluşturucu Deseni: GoF: “Aynı inşaat sürecinin farklı temsiller oluşturabilmesi için karmaşık bir nesnenin yapısını temsilinden ayırın.”

Bu ne anlama geliyor: İnşaat sürecini yönetmen (GoF) adı verilen başka bir sınıfta kapsüllersiniz. Bu yönetmen, ürünün yeni örneklerini oluşturma algoritmasını içerir (örneğin, diğer parçalardan karmaşık bir ürün oluşturun). Yönetmen tüm ürünün ayrılmaz parçalarını oluşturmak için bir inşaatçı kullanır. Direktörü kurucu ile değiştirerek, ürünü oluşturmak için aynı algoritmayı kullanabilirsiniz, ancak tek parçaların temsillerini (ve böylece ürünün temsilini) değiştirebilirsiniz. Sisteminizi ürünün temsilinde genişletmek veya değiştirmek için yapmanız gereken tek şey yeni bir oluşturucu sınıfı uygulamaktır.

Kısacası: Özet Fabrika Deseni'nin amacı, birlikte kullanılmak üzere yapılmış bir dizi ürünü değiş tokuş etmektir. Üretici Modelinin amacı, ürünün farklı temsillerinde yeniden kullanılmak üzere bir ürün oluşturma soyut algoritmasını kapsamaktır.

Benim düşünceme göre, Soyut Fabrika Deseninin Oluşturucu Deseninin büyük kardeşi olduğunu söyleyemezsiniz. EVET, her ikisi de yaratıcı kalıplardır, ancak kalıpların ana amacı tamamen farklıdır.

Builder ve fabrika arasında yapabileceğim çarpıcı bir fark şunlardı:

bir arabamız olduğunu varsayalım

class Car
{
  bool HasGPS;
  bool IsCityCar;
  bool IsSportsCar;
  int   Cylenders;
  int Seats;

  public:
     void Car(bool hasGPs=false,bool IsCityCar=false,bool IsSportsCar=false, int Cylender=2, int Seats=4);
 };

Yukarıdaki arayüzde arabayı şu şekilde alabiliriz:

 int main()
 {
    BadCar = new Car(false,false,true,4,4);
  }

ama ne olur, koltuklar oluşturulurken bir istisna olur ??? NESNEYİ TÜMÜNDE ALMAYACAKSINIZ AMA

aşağıdaki gibi bir uygulamanız olduğunu varsayalım

class Car
 {
    bool mHasGPS;
    bool mIsCityCar;
    bool mIsSportsCar;
    int mCylenders;
    int mSeats;

 public:
    void Car() : mHasGPs(false), mIsCityCar(false), mIsSportsCar(false), mCylender(2), mSeats(4) {}
    void SetGPS(bool hasGPs=false)  {mHasGPs = hasGPs;}
    void SetCity(bool CityCar)  {mIsCityCar = CityCar;}
    void SetSports(bool SportsCar)  {mIsSportsCar = SportsCar;}
    void SetCylender(int Cylender)  {mCylenders = Cylender;}    
    void SetSeats(int seat) {mSeats = seat;}    
};

 class CarBuilder 
 {
    Car* mCar;
public:
        CarBuilder():mCar(NULL) {   mCar* = new Car();  }
        ~CarBuilder()   {   if(mCar)    {   delete mCar;    }
        Car* GetCar()   {   return mCar; mCar=new Car();    }
        CarBuilder* SetSeats(int n) {   mCar->SetSeats(n); return this; }
        CarBuilder* SetCylender(int n)  {   mCar->SetCylender(n); return this;  }
        CarBuilder* SetSports(bool val) {   mCar->SetSports(val); return this;  }
        CarBuilder* SetCity(bool val)   {   mCar->SetCity(val); return this;    }
        CarBuilder* SetGPS(bool val)    {   mCar->SetGPS(val); return this; }
}

Şimdi böyle yaratabilirsiniz

 int main()
 {
   CarBuilder* bp =new CarBuilder;
    Car* NewCar  = bp->SetSeats(4)->SetSports(4)->SetCity(ture)->SetGPS(false)->SetSports(true)->GetCar();

     bp->SetSeats(2);

     bp->SetSports(4);

     bp->SetCity(ture);

     bp->SetSports(true)

     Car* Car_II=  bp->GetCar();

  }

Burada ikinci durumda, bir işlem başarısız olsa bile yine de Arabayı alırsınız.

Belki araba daha sonra mükemmel çalışmaz ama nesneye sahip olabilirsiniz.

Çünkü Factory Method size tek çağrıda Araba verirken, Builder tek tek inşa eder.

Rağmen, bu gitmek için tenezzül ihtiyaçlarına bağlıdır.

+-------------------------------------------------------------------+---------------------------------------------------+
|                              Builder                              |                      Factory                      |
+-------------------------------------------------------------------+---------------------------------------------------+
| Return only single instance to handle complex object construction | Retrun various instances on multiple constructors |
| No interface required                                             | Interface driven                                  |
| Inner classes is involved (to avoid telescopic constructors)      | Subclasses are involved                           |
+-------------------------------------------------------------------+---------------------------------------------------+  

Teleskop Oluşturucu Deseni

Analoji:

• Fabrika: Bir restoran düşünün. "Bugünün yemeği" nin oluşturulması bir fabrika modelidir, çünkü mutfağa "bugünkü yemeği al" deyin ve mutfak (fabrika) gizli kriterlere göre hangi nesnenin üretileceğine karar verirsiniz.
• Oluşturucu: Özel bir pizza sipariş ederseniz oluşturucu görünür. Bu durumda, garson şefe (inşaatçı) "Pizzaya ihtiyacım var; peynir, soğan ve pastırma ekleyin!" Böylece, oluşturucu oluşturulan nesnenin sahip olması gereken öznitelikleri ortaya çıkarır, ancak bunların nasıl ayarlanacağını gizler.

Nezaket

Oluşturucu ve Soyut Fabrika farklı amaçlar için amaçlanmıştır. Doğru kullanım durumuna bağlı olarak, uygun tasarım desenini seçmelisiniz.

Oluşturucu çıkıntılı özellikleri:

1. Oluşturucu deseni basit nesneleri kullanarak ve adım adım yaklaşımı kullanarak karmaşık bir nesne oluşturur
2. Bir Builder sınıfı, son nesneyi adım adım oluşturur. Bu oluşturucu diğer nesnelerden bağımsız
3. Bu senaryoda Fabrika yöntemine / Soyut Fabrika'ya geçiş: İstemci programından Fabrika sınıfına hataya eğilimli olabilecek çok fazla argüman
4. Parametrelerin bazıları, tüm parametreleri göndermeye zorlayan Fabrikadan farklı olarak isteğe bağlı olabilir

Fabrika (basit Fabrika) çıkıntılı özellikleri:

1. Yaratıcı desen
2. Kalıtım temelli
3. Fabrika, bir Fabrika Yöntemi (arabirim) döndürür ve bu da Beton Nesnesini döndürür
4. Arabirim için yeni Beton Nesneleri kullanabilirsiniz ve müşteri (arayan) tüm somut uygulamaların farkında olmamalıdır
5. İstemci her zaman yalnızca arabirime erişir ve Nesne oluşturma ayrıntılarını Fabrika yönteminde gizleyebilirsiniz.

Tasarımlar genellikle Fabrika Yöntemini (daha az karmaşık, daha özelleştirilebilir, alt sınıflar çoğalır) kullanarak başlar ve Soyut Fabrika , Prototip veya Oluşturucu'ya (daha esnek, daha karmaşık) dönüşür

İlgili yayınlara bir göz atın:

Oluşturucuyu ayrı bir sınıfta tutma (akıcı arayüz)

Tasarım Desenleri: Fabrika vs Fabrika yöntemi vs Soyut Fabrika

Daha fazla ayrıntı için aşağıdaki makalelere bakabilirsiniz:

sourcemaking

journaldev

Fabrika : Nesnenin bağımlılıklarının tamamen fabrika tarafından tutulduğu bir nesne örneği oluşturmak için kullanılır. İçin soyut fabrika deseni , aynı soyut fabrikanın birçok somut uygulamaları genellikle vardır. Fabrikanın doğru uygulaması bağımlılık enjeksiyonu ile enjekte edilir.

Oluşturucu : Örneklenecek nesnenin bağımlılıkları kısmen önceden bilindiği ve kısmen oluşturucunun istemcisi tarafından sağlandığı zaman değişmez nesneler oluşturmak için kullanılır.

Özet Fabrika ve İnşaatçı deseni hem Yaratıcılıklı hem de farklı niyetlidir.

Soyut Fabrika Deseni , aşağıdaki durumlarda ilgili nesnelerin aileleri için nesne oluşturmayı vurgular:

• Her aile, ortak bir temel sınıftan / Arabirimden türetilen bir sınıflar kümesidir.
• Her nesne, bir çağrı sonucunda hemen döndürülür.

Oluşturucu deseni , adım adım karmaşık bir nesne oluşturmaya odaklanır. Temsili, karmaşık nesneyi oluşturma sürecinden ayırır, böylece aynı yapım süreci farklı temsiller için kullanılabilir.

• Oluşturucu nesnesi, karmaşık nesnenin yapılandırmasını içerir.
• Director nesnesi, protokolün karmaşık nesneyi oluşturmak için gereken tüm mantıksal adımları tanımladığı Builder'ı kullanma protokolünü bilir.

Karmaşık bir yapı, inşa edilecek nesnenin soyutlarla temsil edilen farklı diğer nesnelerden oluştuğu zamandır.

McDonald's'ta bir menü düşünün. Bir menü bir içki, bir ana ve bir yan içerir. Bireysel soyutlamaların soyunun birlikte oluşturulduğuna bağlı olarak, oluşturulan menünün başka bir temsili vardır.

1. Örnek: Kola, Büyük Mac, Patates Kızartması
2. Örnek: Sprite, Nuggets, Kıvırcık Patates

Orada, farklı temsiller ile iki menü örneği var. İnşaat süreci de aynı kalır. Bir içki, bir ana ve bir yan ile bir menü oluşturursunuz.

Oluşturucu desenini kullanarak, karmaşık bir nesne oluşturma algoritmasını oluşturmak için kullanılan farklı bileşenlerden ayırırsınız.

Oluşturucu modeli açısından algoritma, yönetmen içinde kapsüllenirken, oluşturucular ayrılmaz parçalar oluşturmak için kullanılır. Yönetmen algoritmasında kullanılan kurucuyu değiştirmek farklı bir temsile yol açar, çünkü diğer parçalar bir menüye oluşturulur. Bir menünün oluşturulma şekli aynı kalır.

Aralarındaki ana fark, Oluşturucu deseninin öncelikle karmaşık nesnelerin oluşturulmasını adım adım tanımlamasıdır. Soyut Fabrika modelinde, vurgu nesne-ürün aileleri üzerindedir . Oluşturucu ürünü son adımda döndürür . Abstract Factory modelindeyken ürün hemen teslime hazırdır .

Örnek: Labirent oluşturduğumuzu varsayalım

1. Soyut Fabrika:

Maze* MazeGame::CreateMaze (MazeFactory& factory) {
Maze* maze = factory.MakeMaze(); /// product is available at start!!
 /* Call some methods on maze */
return maze;
}

2. Oluşturucu:

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {
builder.buildMaze(); /// We don't have access to maze
 /* Call some methods on builder */
return builder.GetMaze();
}

Fabrika ve İnşaatçı kalıplarının kullanımı ve arasındaki farkın, aynı kod tabanı üzerinde çalıştığınız ve değişen gereksinimleri belirli bir zaman diliminde daha kolay anlaşılabileceğine / netleştirilebileceğine inanıyorum.

Deneyimlerime göre, genellikle nispeten karmaşık başlatma mantığını gizlemek için birkaç statik yaratıcı yöntem içeren bir Fabrika deseni ile başlarsınız. Nesne hiyerarşiniz daha karmaşık hale geldikçe (veya daha fazla tür, parametre ekledikçe), muhtemelen yöntemlerinizin daha fazla parametreyle doldurulduğunu ve Fabrika modülünüzü yeniden derlemeniz gerektiğini belirtmeyeceksiniz. Tüm bu şeyler, yaratıcı yöntemlerinizin karmaşıklığını artırır, okunabilirliği azaltır ve oluşturma modülünü daha kırılgan hale getirir.

Bu nokta muhtemelen geçiş / uzatma noktası olacaktır. Bunu yaparak, yapı parametreleri etrafında bir sarmalayıcı modülü yaratırsınız ve daha sonra, gerçek mantıkınıza dokunmadan daha fazla soyutlama (belki) ve uygulama ekleyerek yeni (benzer) nesneleri temsil edebileceksiniz. Yani "daha az" karmaşık mantığınız vardı.

Açıkçası, tek bir çeşitlilik faktörü onları ayırt etmem için yeterli olmadığından, "tek adımda veya birden fazla adımda bir nesneye sahip olmak" gibi bir şeye atıfta bulunmak tek fark faktörü onları ayırt etmem için yeterli olmadığından, Şimdi hiçbir fayda görmeden. Nihayet bu konuda düşündüm.

Oluşturucu deseninin fabrika desenine göre ana avantajı, birçok olası özelleştirmeyle standart bir nesne oluşturmak istiyorsanız, ancak genellikle birkaçını özelleştirmenizdir.

Örneğin, bir HTTP İstemcisi yazmak istiyorsanız - varsayılan yazma / okuma zaman aşımı, protokoller, önbellek, DNS, durdurucular vb. Gibi bazı varsayılan parametreler ayarlarsınız.

Diğer bazı kullanıcılar diğer parametrelerin bazılarını özelleştirmek isteyebilirken, istemcinizin kullanıcılarının çoğu bu varsayılan parametreleri kullanır. Bazı durumlarda, zaman aşımlarını değiştirmek ve geri kalanını olduğu gibi kullanmak istersiniz, diğer durumlarda örneğin önbelleği özelleştirmeniz gerekebilir.

İstemcinizi örneklemenin olası yolları (OkHttpClient'ten alınmıştır):

//just give me the default stuff
HttpClient.Builder().build()   

//I want to use custom cache
HttpClient.Builder().cache(MyCache()).build() 

//I want custom connection timeout
HttpClient.Builder().connectTimeout(30, TimeUnit.SECONDS).build() 

//I am more interested in read/write timeout
HttpClient.Builder()
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS).build()

Bunun için bir fabrika kalıbı kullanırsanız, tüm olası yaratıcı parametre kombinasyonlarıyla birçok yöntem yazacaksınız. Oluşturucu ile, sadece önem verdiğiniz kişileri belirlersiniz ve diğer tüm parametrelerle ilgilenmek için oluşturucunun onu oluşturmasına izin verirsiniz.

Yapı deseni, nesne oluşturmanın karmaşıklığına vurgu yapar ("adımlar" ile çözülür)

Soyut örüntü, (çok fakat ilişkili) nesnelerin “soyut” unu “sadece” vurgular.

Fark açıktır Oluşturucu deseninde, oluşturucu sizin için belirli bir nesne türü oluşturur. Oluşturucunun ne inşa etmesi gerektiğini söylemelisin. Fabrika modelinde, soyut sınıfı kullanarak doğrudan belirli bir nesneyi inşa ediyorsunuz.

Burada yapıcı sınıfı, ana sınıf ve belirli tür sınıfları arasında aracı görevi görür. Daha soyutlama.

Her ikisi de çok benzerdir, ancak bazıları varsayılan değerlerle isteğe bağlı olarak nesne oluşturma için çok sayıda parametreniz varsa, Oluşturucu desenine gidin.

Benim nacizane fikrime göre

Builder bir tür daha karmaşık Fabrika.

Ancak Builder'da , son ve geçerli nesne oluşturmak için gereken başka fabrikaları kullanarak nesneleri başlatabilirsiniz .

Yani, karmaşıklığa göre "Yaratıcı Desenler" evrimi hakkında konuşurken, onu bu şekilde düşünebilirsiniz:

Dependency Injection Container -> Service Locator -> Builder -> Factory

Her iki desen de aynı zorunluluk için gelir: Bazı istemci kodlarından karmaşık bir nesnenin yapım mantığını gizleyin. Fakat "karmaşık" (ya da bazen karmaşıklaştıran) bir nesneyi yapan nedir? Esas olarak, bağımlılıklardan veya daha kısmi durumlardan oluşan bir nesnenin durumundan kaynaklanır. Başlangıç ​​nesnesi durumunu ayarlamak için kurucuya bağımlılıklar enjekte edebilirsiniz, ancak bir nesne çok fazla gerektirebilir, bazıları varsayılan başlangıç ​​durumunda olacaktır (sadece varsayılan bağımlılığı null değerine ayarlamanın en temiz yol olmadığını öğrenmiş olmamız gerekirdi) ) ve diğer bazı durumlar tarafından yönlendirilen bir duruma ayarlanır. Dahası, bir tür "kayıtsız bağımlılıklar" olan nesne özellikleri vardır, fakat aynı zamanda isteğe bağlı durumları da alabilirler.

bu karmaşıklığa hükmetmenin iyi bilinen iki yolu vardır:

• Kompozisyon / toplama: Bir nesne inşa edin, bağımlı nesnelerini inşa edin, sonra birbirine bağlayın. Burada bir inşaatçı, bileşenin yapımına öncülük eden kuralları belirleyen süreci şeffaf ve esnek hale getirebilir.

• Çok biçimlilik: İnşaat kuralları doğrudan alt tür tanımına bildirilir, bu nedenle her alt tür için bir dizi kuralınız vardır ve bazı koşullar, nesneyi oluşturmak için bu kurallar kümesinden hangisinin uygulanacağına karar verir. Bir fabrika bu senaryoya mükemmel uyum sağlar.

Hiçbir şey bu iki yaklaşımı karıştırmayı engellemez. Bir ürün ailesi, bir oluşturucu ile yapılan soyut nesne oluşturma, bir oluşturucu hangi bileşen nesnesinin örneklediğini belirlemek için fabrikaları kullanabilir.

Bence Oluşturucu deseni, bir grup diğer nesneden bir nesne oluşturmak istediğinizde kullanılır ve parça oluşturulması, oluşturmak istediğiniz nesneden bağımsız olmalıdır. Oluşturucuyu ve istemciyi bağımsız hale getirmek için parçanın oluşturulmasını istemciden gizlemeye yardımcı olur. Karmaşık nesneler oluşturmak için kullanılır (karmaşık özelliklerden oluşabilecek nesneler)

Fabrika düzeni, ortak bir ailenin nesnelerini oluşturmak istediğinizi ve aynı anda oluşturulmasını istediğinizi belirtir. Daha basit nesneler için kullanılır.

Oluşturucu ve Soyut Fabrika

Builder tasarım deseni bir dereceye kadar Soyut Fabrika modeline çok benzemektedir. Bu nedenle, birinin veya diğerinin kullanıldığı durumlar arasında fark yaratabilmek önemlidir. Soyut Fabrika durumunda, müşteri kendi nesnelerini oluşturmak için fabrikanın yöntemlerini kullanır. Builder örneğinde, Builder sınıfına nesnenin nasıl oluşturulacağı konusunda talimat verilir ve daha sonra nesnenin sorulması istenir, ancak sınıfın bir araya getirilme şekli Builder sınıfına bağlıdır, bu detay iki desen arasındaki farkı yaratır.

Ürünler için ortak arayüz

Uygulamada, beton üreticileri tarafından oluşturulan ürünler önemli ölçüde farklı bir yapıya sahiptir, bu nedenle farklı ürünleri ortak bir ana sınıftan türetmek için bir neden yoksa. Bu aynı zamanda Oluşturucu desenini ortak bir türden türetilen nesneler oluşturan Soyut Fabrika modelinden ayırır.

Gönderen: http://www.oodesign.com/builder-pattern.html

Fabrika düzeni, bir sınıfın çalışma zamanında somut bir uygulamasını oluşturur, yani asıl amacı, alt sınıfların hangi sınıfın örnekleneceğine karar vermesine izin vermek için polimorfizm kullanmaktır. Bu, derleme zamanında oluşturulacak tam sınıfı bilmediğimiz anlamına gelirken, Oluşturucu deseni esas olarak bir sınıfın çok sayıda isteğe bağlı alanından kaynaklanan teleskopik inşaatçılar antipattern problemini çözmekle ilgilidir. Oluşturucu deseninde, derleme zamanında hangi nesneyi oluşturmaya çalıştığımızı bildiğimiz için polimorfizm kavramı yoktur.

Bu iki desenin tek ortak teması, geliştirici nesne yapımı için inşaatçıların ve nesne oluşturma işlemlerinin fabrika yöntemlerinin arkasına saklanması ve inşa yöntemidir.

Fabrika kalıbı, bir kerede aynı anda bir nesne oluşturmanıza izin verirken, oluşturucu deseni bir nesnenin oluşturma sürecini kırmanıza izin verir. Bu şekilde, bir nesne oluşturulurken farklı işlevler ekleyebilirsiniz.