design patterns - qué - Fábrica abstracta, método de fábrica, constructor

patron simple factory

Question

Puede parecer que esta pregunta es una tontería, pero por favor tengan paciencia , les prometo que he leído las publicaciones relacionadas (y el libro de GOF ).

Después de todo lo que he leído, todavía no tengo claro cuándo utilizar una fábrica abstracta, un método de fábrica o un generador. Creo que finalmente se va a hundir después de que veo un ejemplo simple de un problema que es mejor abordado por, por ejemplo, un constructor y sería claramente tonto usar, por ejemplo, una fábrica abstracta .

¿Puedes dar un ejemplo simple donde claramente usarías un patrón y no los otros?

Entiendo que puede reducirse a una cuestión de opinión si el ejemplo es demasiado simple, pero tengo la esperanza de que, si alguien puede, esa persona está en TAN.

Gracias.

Answer 1

Abstract Factory es particularmente útil para el desarrollo impulsado por pruebas y para reducir el acoplamiento.

Por ejemplo, en 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 ...
    }
}

De esta forma, puede usar la inyección de dependencia para inyectar las implementaciones predeterminadas para el código de producción, y luego puede simular fácilmente la fábrica y los objetos que crea.

Answer 2

El otro día escribí un artículo con el objetivo de comparar el patrón del Método de Fábrica y el patrón del Constructor. Puede encontrarlo aquí: http://www.shenghua.co.uk/factory-method-vs-builder/ . Espero que pueda ofrecer algunas ayudas también.

Desde mi propia experiencia, encontré que el libro de Head First Design Pattern también es un libro realmente bueno que habla de Design Patterns. A diferencia de lo escrito por Erich Gamma, se acercó a cada patrón de diseño al introducir un problema causado por cuando los patrones de diseño no se utilizan y luego se intensificó a cómo un patrón de diseño puede resolver ese problema. Fue una lectura muy agradable para mí. También hizo que el escrito por Erich Gamma fuera mucho más fácil de entender después de terminar de leerlo.

Answer 3

El patrón Abstract Factory utiliza subclases (de fábricas) para producir otros objetos (no fábricas). Abstract Factory también prevé que los objetos producidos pertenecen a jerarquías paralelas (por ejemplo, para manejar la independencia de la plataforma, una jerarquía para cada plataforma).

El patrón de Constructor usa subclases para producir "salida", que no es necesariamente ningún objeto . El ejemplo de GOF tiene el generador produciendo salida de texto (marcado o de otro tipo).

El patrón Factory Method, a diferencia de los otros dos, divide al "creador" en una implementación abstracta y concreta (de ahí el énfasis en que pertenece a una implementación de framework). Al igual que Abstract Factory, se trata de hacer objetos reales.

Los tres son muy similares, porque todos usan subclases. Es la subclase que es la cualidad sobresaliente de todas ellas, que oculta las diferencias sutiles (descritas anteriormente) y, por lo tanto, muchas personas tienen dificultades para ver las diferencias.

Answer 4

Abstract Factory, Factory Method, Builder : todos estos patrones son patrones creacionales, que son patrones de diseño que se ocupan de los mecanismos de creación de objetos , tratando de crear objetos de una manera adecuada a la situación.

Método de fábrica:

1. Define una interfaz para crear un objeto , pero deja que las subclases decidan qué clase instanciar
2. Creamos un objeto sin exponer la lógica de creación al cliente y hacemos referencia a un objeto recién creado utilizando una interfaz común (o una clase abstracta)
3. Proporciona acoplamiento libre al eliminar la necesidad de vincular clases específicas de la aplicación en el código . El código solo interactúa con la interfaz o la clase abstracta

4. Puede usar herencia o subclasificación para lograr el propósito

   Nota clave: creará una interfaz e implementación específica de estas interfaces. En el método Factory, dependiendo de las condiciones, obtendrá una implementación concreta de la interfaz común.

Fábrica abstracta:

1. Proporcionar una interfaz para crear familias de objetos relacionados o dependientes sin especificar sus clases concretas
2. Una jerarquía que encapsula: muchas posibles "plataformas" `y la construcción de un conjunto de" productos "
3. Las clases abstractas de Factory a menudo se implementan con Factory Methods , pero también se pueden implementar utilizando Prototype

Constructor:

1. Patrón de compilación construye un objeto complejo utilizando objetos simples y usando un enfoque paso a paso
2. Reemplazo del método Factory / Abstract Factory en este escenario : Demasiados argumentos para pasar del programa cliente a la clase Factory que puede ser propenso a errores
3. Algunos de los parámetros pueden ser opcionales a diferencia de Factory, que obliga a enviar todos los parámetros

Pautas para el patrón de diseño del constructor en Java

1. Cree una clase anidada estática llamada Generador dentro de la clase cuyo objeto será compilado por el Generador
2. La clase de generador tendrá exactamente el mismo conjunto de campos que la clase original
3. La clase de constructores expondrá el método para agregar ingredientes . Cada método devolverá el mismo objeto Builder. El generador se enriquecerá con cada llamada al método.
4. El método Builder.build () copiará todos los valores del campo del constructor en la clase real y devolverá el objeto de la clase Item
5. La clase de elemento (clase para la cual creamos Builder) debe tener un constructor privado para crear su objeto a partir del método build () y evitar que alguien externo acceda a su constructor.

Artículos Relacionados:

Patrones de diseño: método Factory vs Factory vs Abstract Factory

Mantener el constructor en una clase separada (interfaz fluida)

Enlaces útiles:

sourcemaking diseño sourcemaking

Answer 5

Constructor

// 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();
}

Método de fábrica

// 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(); 

Fábrica abstracta

// 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
...

Answer 6

Un constructor te ayuda a construir un objeto complejo. Un ejemplo es la clase StringBuilder ( Java , C# ), que construye la secuencia final pieza por pieza. Un mejor ejemplo es el UriComponentsBuilder en Spring, que lo ayuda a construir un URI.

Un método de fábrica le proporciona un objeto completo de una vez (en lugar de un constructor). Una clase base define un único método abstracto que devuelve una referencia de interfaz (o superclase) y difiere la creación concreta del objeto a subclases.

Una fábrica abstracta es una interfaz (o clase abstracta) para crear muchos objetos relacionados diferentes. Un buen ejemplo (en .NET) es la clase DbProviderFactory , que sirve para crear objetos relacionados (conexiones, comandos, ...) a un proveedor de base de datos dado (oráculo, servidor SQL, ...), dependiendo de su implementación concreta.

Answer 7

• Patrón de método de fábrica: cuando desea construir una familia de objetos complejos.
• Patrón de generador de objetos: cuando desea permitir que el usuario complemente su implementación personalizada en su marco

Por favor visite la siguiente url para más detalles.

http://xeon2k.wordpress.com