Patrons de conception : Usine abstraite et méthode d'usine

Question

Note : Les questions se trouvent à la fin de l'article.

J'ai lu les autres fils de discussion de stackoverflow concernant Usine abstraite et méthode d'usine . Je comprends l'intention de chaque modèle. Cependant, je ne suis pas sûr de la définition.

La méthode Factory définit une interface pour créer un objet, mais laisse sous-classes décider lesquelles de ces interfaces instancier. Une méthode d'usine permet aux classes de différer l'instanciation aux sous-classes.

En revanche, une fabrique abstraite fournit une interface pour créer des familles d'objets liés ou dépendants dépendants sans spécifier leurs classes concrètes.

- John Feminella

Le site Usine abstraite ressemble beaucoup à la Méthode d'usine . J'ai dessiné quelques classes UML pour illustrer mon propos.

Note :

• Les diagrammes sont tirés de www.yuml.com Ils ne sont donc pas parfaitement orientés. Mais c'est un service gratuit :).
• Les diagrammes peuvent ne pas être parfaits. Je suis encore en train d'apprendre le GoF les modèles de conception.

Méthode d'usine :

Usine abstraite (1 seul membre) :

L'usine abstraite :

Questions :

1. Si le Usine abstraite n'a qu'un seul créateur et un seul produit, est-ce encore le Usine abstraite modèle ? (une interface pour créer des familles)
2. Est-ce que le Méthode d'usine Le créateur concret peut être créé à partir d'une interface ou doit-il être issu d'une classe ? (les classes reportent les instanciations aux sous-classes)
3. Si l'usine abstraite ne peut avoir qu'un seul créateur et un seul produit, est-ce que la seule différence entre l'usine abstraite et l'usine de production est la suivante ? Usine abstraite et le Méthode d'usine que le créateur de la première est une interface et que le créateur de la seconde est une classe ?

Answer 1

J'espère que cela vous aidera. Il décrit les différents types d'usines. J'ai utilisé Les premiers modèles de conception (Head First Design Patterns) comme référence. J'ai utilisé yuml.me au diagramme.

Usine statique

Il s'agit d'une classe avec une méthode statique pour produire divers sous-types de produits.

Usine simple

Est une classe qui peut produire divers sous-types de produits. (C'est mieux que la fabrique statique. Lorsque de nouveaux types sont ajoutés, la classe de base Product n'a pas besoin d'être modifiée, mais seulement la classe Simple Factory).

Méthode d'usine

Contient une méthode pour produire un type de produit lié à son type. (Elle est meilleure qu'une Simple Factory car le type est reporté à une sous-classe).

Usine abstraite

Produit une famille de types qui sont liés. Elle est sensiblement différente d'une méthode d'usine car elle produit plus d'une méthode de types. (C'est compliqué, reportez-vous au diagramme suivant pour un meilleur exemple concret).

Exemple tiré du cadre .NET

DbFactoriesProvider est un Simple Factory car il n'a pas de sous-types. Le DbFactoryProvider est une fabrique abstraite car il peut créer divers objets de base de données connexes tels que des objets de connexion et de commande.

Answer 2

Les deux modèles sont certainement liés !

La différence entre les modèles réside généralement dans l'intention.

Le site intention de Méthode d'usine est "Définir une interface pour créer un objet, mais laisser les sous-classes décider de la classe à instancier. La méthode Factory permet à une classe de reporter l'instanciation à des sous-classes."

Le site intention de Usine abstraite est "Fournir une interface pour créer des familles d'objets liés ou dépendants sans spécifier leurs classes concrètes".

En me basant uniquement sur ces déclarations d'intention (citées par GoF), je dirais qu'en effet Méthode d'usine est en quelque sorte une "dégénérée" Usine abstraite avec une famille d'un seul membre.

Ils ont généralement tendance à différer dans leur mise en œuvre, car Méthode d'usine est beaucoup plus simple que Usine abstraite .

Cependant, ils sont également liés au niveau de la mise en œuvre. Comme indiqué dans le livre du GdF,

AbstractFactory ne déclare qu'une interface pour la création de produits. C'est aux sous-classes de ConcreteProduct de les créer réellement. La façon la plus courante de le faire est de définir une méthode d'usine pour chaque produit.

Ce site c2 wiki propose également une discussion intéressante sur ce sujet.

Answer 3

A mon avis, la légère différence entre les deux modèles réside dans la applicabilité et donc, comme nous l'avons déjà dit, dans les Intention .

Récapitulons les définitions (toutes deux tirées de Wikipedia).

Usine abstraite

Fournir une interface pour créer des familles d'objets connexes ou dépendants sans spécifier leurs classes concrètes.

Méthode d'usine

Définir un interface pour la création d'un objet mais laissons les classes qui implémentent l'interface décident de la classe à instancier. . La méthode Factory permet à une classe de différer son instanciation à des sous-classes.

Les deux modèles permettent de découpler les objets utilisateurs de la création des instances nécessaires (découplage à l'exécution), et c'est là leur point commun. Les deux modèles permettent de créer une hiérarchie de fabriques en fonction des besoins spécifiques, ce qui constitue un autre aspect commun.

Abstract Factory permet de créer plusieurs types différents d'instances dans une sous-classe, et de particulariser le comportement des créations dans ses différentes sous-classes ; normalement, la méthode Factory déclare la création d'un seul type d'objet qui peut être particularisé selon le mécanisme de sous-classement. C'est là toute la différence.

En résumant. Disons que Product définit la super-classe des objets à créer, et que ProductA et ProductB sont deux sous-classes différentes. Par conséquent, la méthode Abstract Factory aura deux méthodes, createProductA() et createProductB() qui seront particularisées (en termes d'étapes de création) dans ses sous-classes spécifiques : les sous-classes factory particularisent la méthode étapes de création pour les deux classes définies d'objets en cours de création.

Selon l'exemple ci-dessus, la méthode Factory sera implémentée différemment, en abstrayant la création de ProductA et ProductB dans autant de factories (une méthode par Factory), et la spécialisation supplémentaire de la méthode étapes de création sera déléguée à la hiérarchie au fur et à mesure de sa construction.

Answer 4

Si j'ai créé un (référencée via une interface ou une classe de base abstraite) Une classe d'usine qui crée des objets et qui n'a qu'une seule méthode pour créer des objets, alors ce serait une Méthode d'usine .

Si l'usine abstraite avait plus d'une méthode pour créer des objets, alors elle serait une Usine abstraite .

Disons que je crée un gestionnaire qui répondra aux besoins des méthodes d'action d'un contrôleur MVC. S'il n'avait qu'une seule méthode, par exemple pour créer les objets moteurs qui seront utilisés pour créer les modèles de vue, alors il s'agirait d'un modèle de méthode d'usine. D'un autre côté, s'il avait deux méthodes : une pour créer des moteurs de modèles de vues, et une autre pour créer des moteurs de modèles d'actions (ou quel que soit le nom que vous voulez donner au modèle que la méthode d'action contient des consommateurs), alors il serait une usine abstraite.

public ActionResult DoSomething(SpecificActionModel model)
{
    var actionModelEngine = manager.GetActionModelEngine<SpecificActionModel>();
    actionModelEngine.Execute(SpecificActionModelEnum.Value);

    var viewModelEngine = manager.GetViewModelEngine<SpecificViewModel>();
    return View(viewModelEngine.GetViewModel(SpecificViewModelEnum.Value);
}

Answer 5

D'après ce que je comprends de la définition des méthodes Abstract factory et Factory, la première est implémentée dans un contexte statique et fournit un objet basé sur les paramètres d'entrée.

La seconde utilise un objet déjà créé (la famille) qui implémente l'interface de la méthode factory. La méthode factory crée alors une instance spécifique liée à l'objet original, quel qu'il soit.

Cela conduit généralement à utiliser les deux modèles ensemble, en commençant par créer un objet général qui décrit une famille d'objets connexes. Il est appelé par la méthode statique getInstance("mon nom de famille"). L'implémentation de cette méthode getInstance détermine l'objet de la famille qui sera créé.

Ensuite, j'appelle la méthode createProduct() sur l'objet famille nouvellement créé et selon l'objet famille, le nouveau produit sera renvoyé.

Il semble que ces modèles coopèrent les uns avec les autres.

En d'autres termes, la méthode Abstract Factory se concentre sur le "QUOI" qui sera créé et la méthode Factory sur le "COMMENT" qui sera créé.