it-swarm.dev

Builder Design pattern ile Factory Design pattern arasındaki fark nedir?

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 istersem bulgularımı grafik olarak nasıl temsil edebilirim?

525
Penguen

Tasarım modellerinde, genellikle tüm durumlar için işe yarayan "daha avantajlı" bir çözüm yoktur. Uygulamanız gerekenlere bağlıdır.

Wikipedia'dan: 

  • Oluşturucu, a. karmaşık nesne adım adım. Özet Fabrika bir ürün ailesini vurgular. nesneler (basit veya karmaşık) . Builder ürünü nihai olarak verir. adım, ancak Soyut Fabrika endişeli, ürün alır. hemen döndü.
  • Oluşturucu, genellikle bir Kompozit oluşturur.
  • Çoğu zaman, tasarımlar Fabrika Yöntemi kullanılarak başlar (daha az karmaşık, daha fazla Özelleştirilebilir, alt sınıflar çoğalır). ve Soyut Fabrikasına doğru gelişiyor, Tasarımcı olarak prototip veya Oluşturucu (daha esnek, Daha karmaşık). daha fazla esnekliğin nerede olduğunu keşfeder. gerekli.
  • Bazen yaratılış kalıpları tamamlayıcıdır: Oluşturucu bir .__ kullanabilir. uygulamak için diğer desenlerin hangi bileşenler oluşturulur. Özet Fabrika, Oluşturucu ve Prototip olabilir. Singleton’u kullanın. uygulamalar.

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

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

384
Adrian Grigore

A factory basitçe bir yapıcı etrafındaki bir sarmalayıcı işlevidir (muhtemelen farklı bir sınıftaki). Temel fark, bir fabrika yöntemi modelinin, tüm parametrelerin tek bir satırda iletilmesiyle tüm nesnenin tek bir yöntem çağrısında oluşturulmasını gerektirmesidir. Nihai nesne iade edilecektir.

Bir oluşturucu desen, diğer taraftan, esasen, yapıcı çağrısına geçmek isteyebileceğiniz tüm olası parametrelerin etrafındaki sarmalayıcı bir nesnedir. Bu, parametre listenizi yavaşça oluşturmak için setter yöntemlerini kullanmanızı sağlar. Bir oluşturucu sınıfındaki ek bir yöntem, oluşturucu nesnesini istenen yapıcıya basitçe ileten ve sonucu döndüren bir build () yöntemidir.

Java gibi statik dillerde, birkaç olası (potansiyel olarak isteğe bağlı) parametreden daha fazlasına sahip olduğunuzda bu daha önemli hale gelir, çünkü tüm olası parametre kombinasyonları için teleskopik yapıcılara sahip olma gereksinimini önler. Ayrıca bir oluşturucu, yapıcı ç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ından kod örneklerini karşılaştırmak faydalı olabilir:

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

261
James McGuigan

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

Fabrika modelinde, fabrika ihtiyaçlara bağlı olarak bir nesnenin çeşitli alt tiplerini oluşturmaktan sorumludur.

Bir fabrika yönteminin kullanıcısının, o nesnenin tam alt tipini bilmesi gerekmez. createCar fabrika yönteminin bir örneği Ford veya Honda yazılan bir nesne verebilir.

Builder deseninde, bir kurucu yöntemle farklı alt türler de oluşturulur, ancak nesnelerin bileşimi aynı alt sınıf içinde farklı olabilir.

Araba örneğine devam etmek için, 4 silindirli bir motorla createCar tipli bir nesne veya 6 silindirli Honda-tipli bir nesne oluşturan Honda oluşturucu yönteminiz olabilir. Yapıcı patern bu daha ince tanecikliğe izin verir.

Hem Builder paterni ve Fabrika metodu paterni diyagramları Wikipedia'da mevcuttur.

255
Ben S

Oluşturucu tasarım deseni, belirli bir türdeki başka bir nesneyi birkaç adımda nasıl oluşturacağını bilen bir nesneyi açıklar. Her ara adımda hedef madde için gereken durumu tutar. StringBuilder'ın son bir string üretmek için neler yaşadığını bir düşünün.

Fabrika tasarım deseni, belirli tipin verilen parametrelere göre seçildiği, bir adımda birkaç farklı fakat ilişkili nesne türünün nasıl oluşturulacağını bilen bir nesneyi tanımlar. Serileştiricinizi yarattığınız ve tek bir yük çağrısında istenen nesneyi oluşturduğu serileştirme sistemini düşünün.

53
Joel Coehoorn
  • Adım adım karmaşık bir nesne oluşturmak: builder pattern

  • Tek bir yöntem kullanılarak basit bir nesne oluşturulur: factory method pattern

  • Birden fazla fabrika yöntemi kullanarak nesne oluşturma: Soyut fabrika modeli

40

Her ikisi de Nesne oluşturmak için Yaratılış kalıplarıdır.

1) Fabrika Şablonu - Bir süper sınıfınız ve N alt sınıfınız olduğunu varsayalım. Oluşturulan nesne, hangi parametrenin/değerin geçtiğine bağlıdır.

2) Oluşturucu deseni - karmaşık bir 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.
13
Tony

Önce benim argümanımı takip edecek genel şeyler:

Büyük yazılım sistemlerinin tasarlanmasındaki ana zorluk, esnek olmaları ve değişime açık olmaları gerektiğidir. Bu nedenle, birleşme ve birleşme gibi bazı ölçütler vardır. Tüm sistemi sıfırdan yeniden tasarlama gereği duymaksızın fonksiyonelliğinde kolayca değiştirilebilen veya genişletilebilen sistemler elde etmek için tasarım ilkelerini (SOLID gibi) takip edebilirsiniz. Bir süre sonra, bazı geliştiriciler bu ilkeleri izlerlerse, benzer sorunlara iyi çalışan benzer çözümler olduğunu kabul ettiler. Bu standart çözümler tasarım kalıpları olarak ortaya çıktı.

Bu yüzden tasarım kalıpları, yüksek yapışmaya sahip gevşek bağlantılı sistemler elde etmek için genel tasarım ilkelerini takip etmenizi desteklemektir.

Soruyu cevaplayarak:

İki kalıp arasındaki farkı sorarak, kendinize hangi kalıbın sisteminizi daha esnek hale getirdiğini sormanız gerekir. Her desenin, sisteminizdeki sınıflar arasındaki bağımlılıkları organize etme 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: Buna benzer bir arabirim sağlayarak, her bir ailenin ürününün yapıcısına yapılan çağrı fabrika sınıfında kapsüllenir. Tüm sisteminizde bu kurucuların çağırıldığı tek yer burası 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ğunluğuna dokunmadan bir dizi ürün alışverişi yapabilirsiniz.

The Builder Pattern:.__ GoF: “Karmaşık bir nesnenin yapısını temsilinden ayırın, böylece aynı yapım süreci farklı temsiller oluşturabilir.”

Bu ne anlama geliyor: İnşaat sürecini yönetmen (GoF) adı verilen başka bir sınıfta kapsıyorsunuz. Bu yönetici, ürünün yeni örneklerini oluşturma algoritmasını içerir (örneğin, diğer parçalardan karmaşık bir ürün oluşturur). Tüm ürünün ayrılmaz parçalarını oluşturmak için yönetici bir inşaatçı kullanır. Yapıcıyı yönetmen içinde değiştirerek ürünü oluşturmak için aynı algoritmayı kullanabilirsiniz, ancak tek parçaların gösterimlerini (ve böylece ürünün gösterimini) değiştirebilirsiniz. Sisteminizi ürünün sunumunda genişletmek veya değiştirmek için yapmanız gereken tek şey yeni bir oluşturucu sınıfı uygulamaktır.

Yani kısaca: Soyut Fabrika Deseninin amacı, birlikte kullanılmak üzere üretilmiş bir ürün grubunu değiştirmektir. Builder Pattern’in amacı, ürünün farklı temsilleri için tekrar kullanmak üzere bir ürün yaratma soyut algoritmasını kapsama almaktır.

Bence Soyut Fabrika Deseninin, Oluşturucu Deseninin ağabeyi olduğunu söyleyemezsiniz. EVET, ikisi de yaratıcı desenlerdir, ancak desenlerin asıl amacı tamamen farklıdır.

10
Janis

Oluşturucu Deseni ve Fabrika modeli, ikisi de çıplak gözlere oldukça benzer görünüyor çünkü ikisi de sizin için nesneler oluşturuyor.

Ama daha yakından bakmalısın

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

Diyelim ki bir fast food restoranına gittiniz ve Food siparişi verdiniz. 

1) Hangi Yiyecek?

Pizza 

2) Ne malzemeleri?

Kırmızı biber, domates, barbekü tavuğu, NO ANANAS 

Bu nedenle, farklı türdeki yiyecekler Fabrika modeline göre yapılır, ancak belirli bir gıdanın farklı çeşitleri (lezzetleri) Oluşturucu modeline göre yapılır. 

Farklı yiyecek türleri

Pizza, Burger, Makarna 

Pizza çeşitleri

Sadece Peynir, Peynir + Domates + Kırmızı Biber, Peynir + Domates vs. 

Kod örneği

Her iki kalıbın örnek kod uygulamasını burada görebilirsiniz.
Oluşturucu Deseni
Fabrika Deseni

7
Rohit Singh

Yapabileceğim fabrika ile Builder arasındaki çarpıcı fark şu oldu:

farz edelim ki bir arabanız var

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 şu şekilde araba alabiliriz:

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

peki ya Koltuklar oluşturulurken bazı istisnalar olursa ??? NEDEN ALACAKSINIZ AT ALL //BUT

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 Araba alırsınız.

Bu araba daha sonra mükemmel çalışmıyor olabilir, ancak nesneye sahip olabilirsiniz.

Çünkü Factory Method size Araba'yı tek bir çağrıda verirken, Oluşturucu birer birer oluşturur.

Bununla birlikte, hangisinin gideceği konusundaki tenezzüllerin ihtiyaçlarına bağlıdır.

6
Fooo

Builder ve Abstract Factory farklı amaçlara yöneliktir. Doğru kullanım durumuna bağlı olarak, uygun tasarım modelini seçmeniz gerekir. 

Builder göze çarpan özellikler:

  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 Fabrikaya değiştirme: İstemci programdan Fabrika sınıfına hataya yatkın olabilecek çok fazla argüman var
  4. Tüm parametreleri göndermeye zorlayan Fabrika’dan farklı olarak bazı parametreler isteğe bağlı olabilir.

Fabrika (basit Fabrika) belirgin özellikleri:

  1. Yaratılış desen
  2. Mirasa dayalı
  3. Factory, sırayla Somut Nesne döndüren bir Fabrika Yöntemi (arayüz) döndürür
  4. Arayüz için yeni Beton Nesnelerin yerine geçebilir ve müşteri (arayan) tüm somut uygulamaların farkında olmamalıdır
  5. İstemci her zaman yalnızca arayüze erişir ve Nesne oluşturma ayrıntılarını Fabrika yönteminde gizleyebilirsiniz.

Genellikle, tasarımlar Fabrika Yöntemi (daha az karmaşık, daha özelleştirilebilir, alt sınıflar çoğalır) kullanılarak başlar ve Soyut Fabrika, Prototip veya Oluşturucu 'ya doğru gelişir (daha esnek, daha karmaşık) ) 

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

Builder'ı ayrı 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 bakın:

kaynak yapımı

journaldev

4
Ravindra babu
+-------------------------------------------------------------------+---------------------------------------------------+
|                              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 Yapıcı Deseni

Analoji: 

  • Fabrika: Bir restoran düşünün. "Bugünün yemeği" nin yaratılması bir fabrika şeklidir, çünkü mutfağa "beni bugünün yemeğini al" deyin ve mutfak (fabrika) hangi kriterlerin üretileceğine karar vermeden karar verir.
  • Builder: Özel bir pizza sipariş ederseniz oluşturucu görünür. Bu durumda garson şefe “inşaatçıya ihtiyacım var; peynir, soğan ve domuz pastırması ekle!” Diyor. Böylece, oluşturucu oluşturulan nesnenin sahip olması gereken özellikleri ortaya koyar, ancak onları nasıl ayarlayacağınızı gizler.

Nezaket

4
Premraj

Soyut Fabrika ve Oluşturucu kalıbı her ikisi de Yaratılış kalıplarıdır, ancak farklı amaçları vardır.

Soyut Fabrika Deseni / İlgili nesnelerin aileleri için nesne yaratımını vurgular:

  • Her aile, ortak bir temel sınıftan/Arayüzden türetilmiş bir sınıflar kümesidir.
  • Her nesne bir çağrı sonucu anında iade edilir.

Builder pattern , adım adım karmaşık bir nesne oluşturmaya odaklanır. .__ Karmaşık nesneyi oluşturma sürecinden temsilleri ayırır, böylece aynı yapım süreci farklı temsiller için kullanılabilir.

  • Builder nesnesi, karmaşık nesnenin yapılandırmasını kapsüller.
  • Director nesnesi, Builder'ın kullanılmasına yönelik protokolü bilir; burada Protokolü, karmaşık nesneyi oluşturmak için gereken tüm mantıksal adımları tanımlar. 
3
Saurabh Kumar

Karmaşık bir yapı, inşa edilecek nesnenin soyutlamalar tarafından temsil edilen farklı diğer nesnelerden oluşmasıdır.

McDonald's'ta bir menü düşünün. Bir menü bir içki, bir ana ve bir yan içerir. Bireysel soyutlamaların hangi torunlarının bir araya geldiğine bağlı olarak, oluşturulan menü başka bir gösterime sahiptir.

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

Orada, farklı temsilleri olan menüden iki örnek aldık. Sırasıyla inşaat süreci aynı kalır. İçki, ana ve kenarlı bir menü yaratıyorsunuz.

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

Oluşturucu düzeni açısından, algoritma yönetmene yerleştirilir, oysa yapıcılar tümleşik parçaları oluşturmak için kullanılır. Kullanılan oluşturucuyu yönetmenin algoritmasına göre değiştirmek farklı bir gösterimle sonuçlanır çünkü diğer bölümler bir menüye sahiptir. Bir menünün oluşturulma şekli aynı kalır.

2
Janis

Her ikisi de çok benzerdir, ancak bazılarını varsayılan değerlerle isteğe bağlı olan bazı nesnelerin oluşturulması için çok sayıda parametreniz varsa, Oluşturucu deseni için gidin.

1
Praveen Kumar

Aralarındaki temel fark, Oluşturucu şablonunun öncelikle karmaşık adımların adım adım anlatılmasıdır. Soyut Fabrika modelinde vurgu nesne-ürünlerin aileleri şeklindedir. Oluşturucu ürünü son adım içinde döndürür. Soyut Fabrika modelinde ürün hemen kullanılabilir 'dir.

Örnek: Labirent yarattığımızı 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();
}
1
XYZ123

Fabrika ve Oluşturucu kalıplarının kullanımı ve aralarındaki farkın, aynı kod bazında ve değişen gereksinimler üzerinde çalıştığınız belirli bir zaman diliminde daha kolay anlaşılabileceğini/netleştirilebileceğini düşünüyorum. 

Deneyimlerime göre, genellikle birkaç statik yaratma yöntemi içeren bir Fabrika modeli ile başlarsınız. Nesne hiyerarşiniz karmaşıklaştıkça (veya daha fazla tür eklediğinizde), muhtemelen yöntemlerinizi daha fazla parametre ile doldurmanız ve Fabrika modülünüzü yeniden derlemeniz gerekeceğinden bahsetmek zorunda kalmazsınız. Tüm bunlar yaratıcınızın yöntemlerinin karmaşıklığını arttırır, okunabilirliği azaltır ve oluşturma modülünü daha kırılgan hale getirir.

Bu nokta muhtemelen geçiş noktası olacaktır. Fabrikadan Oluşturucu desenine geçiş. Bunu yaparak, construction parametrelerinin etrafında bir sarmalayıcı modül yaratırsınız ve daha sonra gerçek (yaratma) mantığınıza dokunmadan bazı soyutlamalar (belki de) ve uygulamalar ekleyerek yeni (benzer) nesneleri temsil edebilirsiniz. Böylece daha az karmaşık bir mantık ve yeniden derlenmiş kaynak kodunuz oldu.

Açıkçası, bir çeşit "tek adımlı ya da çok adımda yaratılmış bir nesneye sahip olmak" farkına varmaktır. Çünkü tek çeşitlilik faktörü, karşılaştığım hemen hemen tüm davalarda her iki yolu da kullanabildiğim için onları ayırt etmem için yeterli değildi. Şimdi hiçbir fayda yaşamadan. Demek sonunda nihayet böyle düşündüm.

1
stdout

Fark açıktır. Oluşturucu deseninde, oluşturucu sizin için belirli bir nesne türü oluşturacaktır. Hangi kurucunun yapması gerektiğini söylemek zorundasın . Fabrika modelinde, soyut sınıfı kullanarak doğrudan belirli bir nesneyi inşa ediyorsunuz.

Burada oluşturucu sınıf, ana sınıf ve belirli tip sınıflar arasında arabulucu olarak görev yapar . Daha fazla soyutlama.

1
user2738678

Fabrika : Nesnenin bağımlılıklarının tamamen fabrika tarafından tutulduğu bir nesnenin örneğini oluşturmak için kullanılır.soyut fabrika modeli için, aynı soyut fabrikanın birçok somut uygulaması vardır. Fabrikanın doğru şekilde uygulanması bağımlılık enjeksiyonuyla enjekte edilir.

Builder :değişmeznesneleri oluşturmak için kullanılır, başlatılacak nesnenin bağımlılıkları kısmen önceden bilindiğinde ve kısmen inşaatçının müşterisi tarafından sağlandığında.

0
Hamady C.

Yapı modeli, karmaşıklık / nesne yaratma ("adımlar" ile çözülmüş) üzerinde durur.

Soyut desen (birden çok ama ilişkili) nesnelerin "soyutlamasının" sadece "üzerinde durur".

0
Sandeep Jindal

Oluşturucu ve Soyut Fabrika

Oluşturucu tasarım deseni, bir dereceye kadar Soyut Fabrika modeline çok benzer. Bu yüzden biri veya diğeri kullanıldığında durumlar arasında fark yaratabilmek önemlidir. Soyut Fabrika durumunda, müşteri kendi nesnelerini oluşturmak için fabrikanın yöntemlerini kullanır. Oluşturucu örneğinde, Oluşturucu sınıfına nesneyi nasıl oluşturacağınız konusunda talimat verilir ve daha sonra bunun istenir, ancak sınıfın bir araya getirilme şekli Oluşturucu sınıfına bağlıdır, bu ayrıntı iki kalıp arasındaki farkı ortaya çıkarı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ıf elde etmek için bir neden yoksa. Bu aynı zamanda, Oluşturucu paternini, ortak bir türden türetilmiş nesneler yaratan Soyut Fabrika paterninden ayırır.

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

0
Arturas M

Her iki kalıp da aynı gereklilik için gelir: Bazı müşteri kodlarından karmaşık bir nesnenin yapı mantığını gizleyin. Fakat “karmaşık” (veya bazen karmaşık hale getiren) nesneyi ne yapar? Temel olarak, bağımlılıklardan ya da daha çok kısmi devletlerden oluşan bir nesnenin durumundan kaynaklanmaktadır. İlk nesne durumunu ayarlamak için yapıcıya bağımlılıklar enjekte edebilirsiniz, ancak bir nesne çok fazla şey gerektirebilir, bazıları varsayılan bir başlangıç ​​durumunda olacak (sadece null'a varsayılan bir bağımlılık ayarlamanın en temiz yol olmadığını öğrenmemiz gerekirdi) ) ve bir kısmı başka bir koşul tarafından yönlendirilen bir duruma ayarlanmış. Dahası, bir tür "kayıtsız bağımlılık" olan nesne özellikleri vardır, ancak isteğe bağlı durumları da üstlenebilirler.

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

  • Kompozisyon/toplama: Bir nesne oluşturun, bağımlı nesnelerini yapın, sonra birbirine bağlayın. Burada, bir inşaatçı, bileşenlerin yapımını yönlendiren kuralları belirleyen süreci şeffaf ve esnek hale getirebilir.

  • Polimorfizm: Yapım kuralları doğrudan alt tür tanımına bildirilir, bu nedenle her alt tür için bir kurallar diziniz vardır ve bazı koşullar bu kurallar dizisinden hangisinin nesneyi oluşturmak için geçerli olduğuna karar verir. Bir fabrika bu senaryoda mükemmel bir uyum sergiliyor.

Hiçbir şey bu iki yaklaşımı karıştırmaz. Bir ürün ailesi, bir oluşturucu ile yapılan nesne yaratmayı soyutlayabilir, bir oluşturucu hangi bileşen nesnesinin somutlaştığını belirlemek için fabrikaları kullanabilir.

0
Carmine Ingaldi

Benim nacizane fikrime göre

Oluşturucu daha karmaşık bir fabrika türüdür.

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

Öyleyse, karmaşıklıkla "Yaratılış Kalıpları" evrimi hakkında şu şekilde düşünebilirsiniz:

Dependency Injection Container -> Service Locator -> Builder -> Factory
0
v.babak

Bence Builder deseni, başka bir grup nesneden bir nesne oluşturmak istediğinizde kullanılır ve parça oluşturma, oluşturmak istediğiniz nesneden bağımsız olmalıdır. Oluşturucu ve müşteriyi bağımsız kılmak için parçanın oluşturulmasını müşteriden gizlemeye yardımcı olur. Karmaşık nesnelerin oluşturulması için kullanılır (karmaşık özelliklerden oluşan nesneler)

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

0
AjayLohani