Abstrakcyjna Fabryka, Metoda Fabryczna, Konstruktor

Budowniczy

// Builder encapsulates construction of other object. Building of the object can be done in multiple steps (methods)
public class ConfigurationBuilder
{
  // Each method adds some configuration part to internally created Configuration object
  void AddDbConfiguration(...);
  void AddSmtpConfiguration(...);
  void AddWebServicesConfiguration(...);
  void AddWebServerConfiguration(...);

  // Returns built configuration
  Configuration GetConfiguration();
}

Metoda fabryczna

// Factory method is declared in base class or interface. Subclass defines what type is created by factory method.
public interface ICacheProvider
{
  ISession CreateCache(); // Don't have to return new instance each time - such decission is part of implementation in derived class.
}

public class InMemoryCacheProvider : ICacheProvider
{ ... }

public class DbStoredCacheProvider : ICacheProvider
{ ... }

// Client code
ICacheProvider provider = new InMemoryCacheProvider
ICache cache = provider.CreateCache(); 

Abstract Factory

// Abstract factory defines families of platform classes - you don't need to specify each platform class on the client.
public interface IDbPlatform
{
  // It basically defines many factory methods for related classes
  IDbConnection CreateConnection();
  IDbCommand CreateCommand();
  ...
}

// Abstract factory implementation - single class defines whole platform
public class OraclePlatfrom : IDbPlatform
{ ... }

public class MySqlPlatform : IDbPlatform
{ ... }

// Client code:
IDbPlatform platform = new OraclePlatform();
IConnection connection = platform.CreateConnection(); // Automatically Oracle related
...

Abstract Factory, factory Method, Builder: wszystkie te wzorce są wzorcami kreacyjnymi, które są wzorcami projektowymi zajmującymi się mechanizmami tworzenia obiektów, starającymi się tworzyć obiekty w sposób odpowiedni do sytuacji.

Metoda FABRYCZNA:

1. definiuje interfejs do tworzenia obiektu , ale niech podklasy decydują, którą klasę utworzyć instancję
2. tworzymy obiekt bez narażania logiki tworzenia na client i odnosić się do nowo utworzonego obiektu przy użyciu wspólnego interfejsu (lub klas abstrakcyjnych)
3. zapewnia luźne sprzężenie, eliminując potrzebę wiązania klas specyficznych dla aplikacji w kodzie. Kod współdziała tylko z interfejsem lub klasą abstrakcyjną

4. Może używać dziedziczenia lub podklasowania do osiągnięcia celu

   Uwaga: utworzysz interfejs i konkretną implementację tych interfejsów. W metodzie fabrycznej, w zależności od warunek, otrzymasz konkretną realizację wspólnego interfejsu.

Abstract Factory:

1. zapewnienie interfejsu do tworzenia rodzin powiązanych lub zależnych obiektów bez określania ich konkretnych klas
2. W 2007 roku, po raz pierwszy w Polsce, w 2008 roku, w Polsce i za granicą, w 2009 roku, w 2009 roku, w Polsce i za granicą.]}
3. abstrakcyjne klasy fabryczne są często implementowane metodami fabrycznymi, ale może być również zaimplementowany przy użyciu Prototype

Budowniczy:

1. wzorzec Builder buduje złożony obiekt przy użyciu prostych obiektów i przy użyciu podejścia krok po kroku
2. zastąpienie metody Factory / Abstract Factory w tym scenariuszu: zbyt wiele argumentów, aby przejść z programu klienta do klasy Factory, które mogą być podatne na błędy
3. niektóre parametry mogą być opcjonalne w przeciwieństwie do fabrycznych, które wymusza wysłanie wszystkich parametry

Guidelines for Builder design pattern in Java

1. Utwórz statycznie zagnieżdżoną klasę o nazwie Builder wewnątrz klasy, której obiekt zostanie zbudowany przez Builder
2. Klasa Builder będzie miała dokładnie taki sam zestaw pól Jak Klasa oryginalna
3. Klasa Builder ujawni metodę dodawania składników . Każda metoda zwróci ten sam obiekt Builder. Builder będzie wzbogacony o każde wywołanie metody.
4. Budowniczy.zbuduj() metoda skopiuje wszystkie wartości pola builder do rzeczywistej klasy i zwróci obiekt klasy elementu
5. Klasa Item (klasa dla której tworzymy Builder) powinna mieć prywatny konstruktor do tworzenia swojego obiektu z metody build() i uniemożliwiać outsiderowi dostęp do swojego konstruktora.

Related posts:

Wzorce projektowe: Factory vs Factory method vs Abstract Factory

Utrzymanie Buildera w osobnej klasie (płynnie interfejs)

Przydatne linki:

Sourcemaking design-patterns

Napisałem niedawno artykuł, którego celem było porównanie wzorca metody fabrycznej i wzorca konstruktora. Znajdziesz go tutaj: http://www.shenghua.co.uk/factory-method-vs-builder / . Mam nadzieję, że może też pomóc.

Z własnego doświadczenia dowiedziałem się, że książka Head First Design Pattern book jest również naprawdę dobrą książką mówiącą o wzorcach projektowych. Różni się od tego, który napisał Erich Gamma, podszedł do każdego wzorca projektowego, wprowadzając problem spowodowany przez when design wzorce nie są używane, a następnie udoskonalono sposób, w jaki wzór projektowy może rozwiązać ten problem. To była dla mnie bardzo przyjemna lektura. Dzięki temu tekst napisany przez Ericha Gamma stał się znacznie łatwiejszy do zrozumienia po jego przeczytaniu.

Abstrakcyjny wzorzec fabryki wykorzystuje podklasowanie (fabryk) do produkcji innych obiektów (nie-fabryk). Abstract Factory zakłada również, że produkowane obiekty należą do równoległych hierarchii (np. do obsługi niezależności Platformy, po jednej hierarchii dla każdej platformy).

Wzorzec Builder wykorzystuje podklasowanie do wytworzenia "wyjścia" - które jest niekoniecznie obiektami . Przykład GOF ma Konstruktor wytwarzający tekst wyjściowy(znaczniki lub w inny sposób).

The Schemat metody fabrycznej, w przeciwieństwie do dwóch pozostałych, dzieli "Stwórcę" na abstrakcyjną i konkretną implementację (stąd nacisk na nią należy do implementacji frameworkowej). Podobnie jak Abstract Factory zajmuje się tworzeniem rzeczywistych obiektów.

Wszystkie trzy są bardzo podobne, ponieważ wszystkie używają podklasowania. To właśnie podklasowanie jest wyjątkową jakością ich wszystkich, która ukrywa subtelne różnice (opisane powyżej) i dlatego wiele osób ma trudności z widzeniem różnice.

Abstract Factory jest szczególnie pomocny w test driven development i redukcji sprzężenia.

Na przykład w C#:

public class Worker
{
    public IConsumerFactory Factory { get; set; }

    private IResource resource;

    public DoWork()
    {
        IConsumer consumer = Factory.CreateConsumer();
        consumer.Consume(resource);
    }
}

public interface IConsumerFactory
{
    IConsumer CreateConsumer();
}

public interface IConsumer
{
    void Consume(IResource resource);
}

public class DefaultConsumerFactory : IConsumerFactory
{
    public IConsumer CreateConsumer()
    {
        return new DefaultConsumer();
    }
}

public class DefaultConsumer : IConsumer
{
    public void Consume(IResource resource)
    {
      ... Do Work ...
    }
}

W ten sposób można użyć dependency injection, aby wstrzyknąć domyślne implementacje kodu produkcyjnego, a następnie łatwo wyśledzić fabrykę i tworzone przez nią obiekty.

• wzorzec metody Fabrycznej - gdy chcemy zbudować rodzinę złożonych obiektów.
• Object builder pattern-gdy chcesz zezwolić użytkownikowi na wtyczkę ich niestandardowej implementacji do twojego frameworka

Odwiedź poniższy adres url, aby uzyskać więcej informacji.

Http://xeon2k.wordpress.com