Résumé usine, Méthode Factory, Builder

StackOverflow https://stackoverflow.com/questions/3687299

Question

Il peut sembler que si cela est question est une dupe, mais plaît garder avec moi - je promets que j'ai lu les messages connexes (et GOF livre ).

Après tout ce que je l'ai lu, je n'ai pas encore clair quand utiliser un résumé Factory, une méthode usine ou un constructeur. Je crois qu'il va enfin couler après que je vois un exemple simple d'un problème qui est le mieux approché par, disons, constructeur et il serait d'utiliser clairement stupide, disons, un usine abstraite .

Pouvez-vous donner un exemple simple où vous utiliseriez clairement un modèle et pas les autres?

Je comprends qu'il peut bouillir à une question d'opinion, si l'exemple est trop simple, mais je suis plein d'espoir que si quelqu'un peut, cette personne est en SO.

Merci.

Était-ce utile?

La solution

Un constructeur vous aide à construire un objet complexe. Un exemple est la classe StringBuilder ( Java , C # ), qui construit la pièce de chaîne finale par pièce. Un meilleur exemple est le UriComponentsBuilder au printemps, ce qui vous aide à construire un URI.

Une méthode d'usine vous donne un objet complet d'un seul coup (par opposition au constructeur). Une classe de base définit une seule méthode abstraite qui renvoie une référence interface (ou super classe) et diffère la création de béton de l'objet sous-classes.

Une usine abstraite est une interface (ou classe abstraite) pour créer de nombreux objets connexes. Un bon exemple (.NET) est DbProviderFactory classe, qui sert à créer d'autres objets (connexions, commandes, ...) à un fournisseur de base de données donnée (Oracle, serveur SQL, ...), en fonction de sa mise en œuvre concrète.

Autres conseils

Builder 

// 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éthode usine 

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

Résumé usine 

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

Résumé usine, Méthode d'usine, Constructeur : Tous ces motifs sont des motifs creational, qui sont modèles de conception qui traitent des mécanismes de création d'objets , en essayant de créer des objets d'une manière adapté à la situation.

Méthode usine:

  1. Il définit une interface pour la création d'un objet , mais laissez-les sous-classes de décider quelle classe instancier
  2. Nous créons un objet sans exposer la logique de création au client et reportez-vous à l'objet nouvellement créé à l'aide d'une interface commune (ou classes abstraites)
  3. Fournit-couplage lâche en éliminant la nécessité de lier les classes spécifiques de l'application dans le code . Code interagit avec uniquement l'interface ou classe abstraite

  4. Il peut utiliser héritage ou sous classage pour atteindre l'objectif

    Note clé: Vous allez créer une implémentation d'interface et spécifique de ces interfaces. Dans la méthode usine, selon l'état, vous obtiendrez la mise en œuvre concrète de l'interface commune.

Résumé usine:

  1. Fournir une interface pour la création de familles d'objets liés ou dépendants sans préciser leurs classes concrètes
  2. Une hiérarchie qui encapsule: nombre possible "plates-formes" `, et la construction d'une suite de "produits"
  3. Résumé des cours d'usine sont souvent mises en œuvre avec des méthodes d'usine , mais ils peuvent aussi être mis en œuvre en utilisant Prototype

Constructeur:

  1. Builder modèle construit un objet complexe en utilisant des objets simples et en utilisant une approche étape par étape
  2. Remplacement à la méthode usine / Abstract Factory dans ce scénario : trop d'arguments pour passer du programme client à la classe Factory qui peut être source d'erreurs
  3. Certains paramètres peuvent être en option contrairement à l'usine où les forces pour envoyer tous les paramètres

Lignes directrices pour modèle de conception Builder en Java

  1. Faites une classe imbriquée statique appelée Builder dans la classe dont l'objet sera construit par le constructeur
  2. classe le constructeur aura exactement le même ensemble de champs classe d'origine
  3. classe Builder exposera la méthode pour ajouter des ingrédients . Chaque méthode retourne même objet Builder. Builder sera enrichi chaque appel de méthode.
  4. méthode Builder.build () copiera toutes les valeurs de champ constructeur en classe réelle et l'objet de retour de classe Item
  5. classe d'objet (classe pour laquelle nous créons Builder) devrait avoir constructeur privé pour créer son objet méthode de build () et empêcher étranger d'accéder à son constructeur.

Related posts:

Design Patterns: usine vs méthode d'usine vs Abstract Factory

Garder le constructeur dans la classe séparée (interface fluide)

Liens utiles:

sourcemaking design patterns-

Les utilisations Résumé de motif usine Subclassing (des usines) pour produire d'autres objets (non-usines). Abstract Factory aussi prévoit que les objets produits appartiennent à des hiérarchies parallèles (par exemple à la plate-forme poignée indépendance, une hiérarchie pour chaque plate-forme).

Le modèle Builder utilise le sous-classement pour produire « sortie » - qui est objets pas nécessairement du tout . L'exemple de GOF a la sortie de texte production Builder (balisage ou autre).

Le modèle Méthode Factory, contrairement aux deux autres, divise le « créateur » dans une mise en œuvre abstraite et concrète (donc l'accent sur ce qui appartient à une mise en œuvre du cadre). Comme Abstract Factory, il oeuvre dans la fabrication d'objets réels.

Les trois sont très semblables, car ils ont tous subclassing d'utilisation. Il est le sous-classement qui est la qualité exceptionnelle de tous, qui cache les différences subtiles (décrites ci-dessus) et donc beaucoup de gens ont du mal à voir les différences.

Résumé Factory est particulièrement utile pour le développement piloté par les tests et réduire le couplage.

Par exemple, 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 cette façon, vous pouvez utiliser l'injection de dépendance pour injecter les implémentations par défaut pour le code de production, et vous pouvez facilement se moquer de l'usine et les objets qu'il crée.

  • motif.Procédé usine -. Lorsque vous voulez construire la famille d'objets complexes
  • modèle de générateur d'objets - Lorsque vous voulez permettre à l'utilisateur de plug-in leur implémentation personnalisée dans votre cadre

S'il vous plaît visitez l'adresse suivante pour plus de détails.

http://xeon2k.wordpress.com

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top