Factory Design Patterns Abstract Factory

Factory Design PatternsFactory Design Patterns

Abstract FactoryAbstract Factory

Abstract Factory Design PatternAbstract Factory Design Pattern

PlanPlan

• Factory patterns: principesFactory patterns: principes

• The Factory Method patternThe Factory Method pattern

• The Abstract Factory patternThe Abstract Factory pattern

““Design patterns are recurring solutions to design Design patterns are recurring solutions to design problems you see over and over.” problems you see over and over.”

[Smalltalk Companion][Smalltalk Companion]


IntentionIntention PortéePortée: objets: objets

• Fournir une interface pour créer des familles Fournir une interface pour créer des familles d’objets reliés ou dépendants sans spécifier d’objets reliés ou dépendants sans spécifier leur classe concrèteleur classe concrète


MotivationMotivation

• PROBLEMEPROBLEME::• portabilité de l’application sur plusieurs plate-formes, portabilité de l’application sur plusieurs plate-formes,

• e.g. look and feele.g. look and feel

• l’instanciation de classes spécifiques à travers toute l’instanciation de classes spécifiques à travers toute l’application rend plus difficile les changements l’application rend plus difficile les changements ultérieurs de ces classes spécifiquesultérieurs de ces classes spécifiques

• SOLUTIONSOLUTION::• Le patron AbstractFactory Le patron AbstractFactory

• encapsule la responsabilité et le processus de création des encapsule la responsabilité et le processus de création des produits produits

• isole les clients de l’implémentationisole les clients de l’implémentation


ExempleExemple


Quand l’appliquerQuand l’appliquer

• Lorsqu’un système doit être indépendant de la manière Lorsqu’un système doit être indépendant de la manière dont ses objets sont créés, composés et représentésdont ses objets sont créés, composés et représentés

• Lorsqu’un système doit être configuré avec une famille Lorsqu’un système doit être configuré avec une famille d’objets parmi plusieurs familles d’objets reliésd’objets parmi plusieurs familles d’objets reliés

• Lorsqu’une famille d’objets est conçue pour être utilisée Lorsqu’une famille d’objets est conçue pour être utilisée ensemble et que cette contrainte doit être renforcée ensemble et que cette contrainte doit être renforcée

• Pour fournir une librairie de classes de produits et pour ne Pour fournir une librairie de classes de produits et pour ne révéler que leur interface et non leur implémentationrévéler que leur interface et non leur implémentation


StructureStructure

Seulement une collection de

factory methods


ParticipantsParticipants

• AbstractFactoryAbstractFactory ( (WidgetFactoryWidgetFactory) ) • ddééclare clare uneune interface interface pour lespour les op opéérations rations qui créent les produits abstraitsqui créent les produits abstraits. .

• ConcreteFactoryConcreteFactory ( (MotifWidgetFactoryMotifWidgetFactory, , PMWidgetFactoryPMWidgetFactory) ) • ImplImpléémentmente les opérations pour créer les produits concretse les opérations pour créer les produits concrets. .

• AbstractProductAbstractProduct ( (WindowWindow, , ScrollBarScrollBar) ) • DDééclareclare une interface pour un type de produit une interface pour un type de produit. .

• ConcreteProductConcreteProduct ( (MotifWindowMotifWindow, , MotifScrollBarMotifScrollBar) ) • DDééfinfinit un produit à créer par la “factory” concrète correspondanteit un produit à créer par la “factory” concrète correspondante. . • ImplImpléémentmente l’interface e l’interface AbstractProductAbstractProduct. .

• ClientClient • N’utilise que les N’utilise que les interfaces interfaces déclarées par les classes déclarées par les classes AbstractFactoryAbstractFactory etet

AbstractProductAbstractProduct. .


Collaboration I Collaboration I

• Il y a une classe “factory” abstraite Il y a une classe “factory” abstraite qui déclare l’interface requise pour la création qui déclare l’interface requise pour la création de chaque type d’objetde chaque type d’objet

• Pour chaque type spécifique d’objet, Pour chaque type spécifique d’objet, il existe il existe • une classe abstraite (ou une interface)une classe abstraite (ou une interface)• des sous-classes concrètes qui spécialisent la classe des sous-classes concrètes qui spécialisent la classe

abstraite pour leur contexte spécifiqueabstraite pour leur contexte spécifique


Collaboration IICollaboration II

• Un client invoque les méthodes pour obtenir les Un client invoque les méthodes pour obtenir les instances, instances, mais sans savoir les classes concrètes qui sont mais sans savoir les classes concrètes qui sont utiliséesutilisées

• Un client Un client • crée les objets uniquement à l’aide de l’interface crée les objets uniquement à l’aide de l’interface

“factory” “factory” • ne possède pas de connaissances sur les classes qui ne possède pas de connaissances sur les classes qui

implémentent les objets dans son cas particulier. implémentent les objets dans son cas particulier.


Collaboration IIICollaboration III

• Toute instance unique de la classe Toute instance unique de la classe ConcreteFactoryConcreteFactory est créée à l’exécution est créée à l’exécution

• Une sous-classe concrète de Une sous-classe concrète de AbstractFactoryAbstractFactory pour chaque famille de produitpour chaque famille de produit

• AbstractFactoryAbstractFactory délègue la création des délègue la création des produits produits à ses sous-classes (à ses sous-classes (ConcreteFactoryConcreteFactory))


Bénéfices et Bénéfices et désavantagesdésavantages

• Isole les classes concrètes Isole les classes concrètes

• Isole les clients de l’implémentation, Isole les clients de l’implémentation, • les clients ne manipulent les instances qu’à travers leurs les clients ne manipulent les instances qu’à travers leurs

interfaces abstraitesinterfaces abstraites

• Les noms des produits n’apparaissent pas dans le Les noms des produits n’apparaissent pas dans le code du clientcode du client

• Facilite le changement et l’échange de familles de Facilite le changement et l’échange de familles de produitsproduits

• Le support de nouveaux types de produits est Le support de nouveaux types de produits est difficiledifficile• Exige de spécialiser l’interface “factory”, ce qui implique Exige de spécialiser l’interface “factory”, ce qui implique

des modifications équivalentes au niveau de la classe des modifications équivalentes au niveau de la classe AbstractFactoryAbstractFactory et de ses sous-classes et de ses sous-classes


Choix d’implémentationChoix d’implémentation1.1. Nombre d’instances de “factory”. Nombre d’instances de “factory”.

• Une seule instance de ConcreteFactory (Singleton) par famille Une seule instance de ConcreteFactory (Singleton) par famille de produitsde produits

2.2. Création des produits Création des produits • Utiliser des méthodes “factory” dans Utiliser des méthodes “factory” dans AbstractFactoryAbstractFactory

(abstraite ou concrète) pour chaque produit(abstraite ou concrète) pour chaque produit• ConcreteFactory va redéfinir ces méthodesConcreteFactory va redéfinir ces méthodes• Utiliser une sous-classe pour chaque famille de produits Utiliser une sous-classe pour chaque famille de produits • La sorte de produit est “encodée” dans la signatureLa sorte de produit est “encodée” dans la signature

• Alternative : utiliser des prototypes qui seront clonésAlternative : utiliser des prototypes qui seront clonés• Alternative : utiliser la réflexivité, Alternative : utiliser la réflexivité,

i.e. Emmagasiner dans la factory les classes qui devront être i.e. Emmagasiner dans la factory les classes qui devront être instanciéesinstanciées

3.3. ““factories” extensiblesfactories” extensibles• pour identifier la sorte de produit à créer, on ajoute des pour identifier la sorte de produit à créer, on ajoute des

paramètres aux opérations qui créent des objetsparamètres aux opérations qui créent des objets


RéférencesRéférences

• E. Gamma, R. Helm, R. Johnson, J. E. Gamma, R. Helm, R. Johnson, J. Vlissides, Vlissides, Design PatternsDesign Patterns,, Addison-Addison-Wesley Professional Computing Series,Wesley Professional Computing Series, 1998.1998.

• J.W. Cooper, J.W. Cooper, Java Design PatternsJava Design Patterns – A – A TutorialTutorial, Addison-Wesley, 2000., Addison-Wesley, 2000.

• http://www.brent.worden.org/tips/2002/http://www.brent.worden.org/tips/2002/abstractFactory.htmlabstractFactory.html


Exemple Exemple supplémentairesupplémentaire

• In the Java™ Message Service (JMS) Specification, In the Java™ Message Service (JMS) Specification, • it is stated that accessing administered objects (queues, queue connection it is stated that accessing administered objects (queues, queue connection

factories, topics, and topic connection factories) should be accomplished via JNDI factories, topics, and topic connection factories) should be accomplished via JNDI lookup. lookup.

• The specification recommends this approach The specification recommends this approach • to allow JMS enabled systems to be vendor neutral to allow JMS enabled systems to be vendor neutral • to allow these systems to use any JMS compliant implementation. to allow these systems to use any JMS compliant implementation.

• One way to isolate the accessing of administered objects is to use an abstract One way to isolate the accessing of administered objects is to use an abstract factory. factory. • The abstract factory would define methods to create the four administered The abstract factory would define methods to create the four administered

objects. objects. • There would be one concrete factory that follows the recommendation in the JMS There would be one concrete factory that follows the recommendation in the JMS

specification by using JNDI lookup.specification by using JNDI lookup.• Also, there could be one concrete factory and set of concrete products for each Also, there could be one concrete factory and set of concrete products for each

vendor variation of accessing administered object. vendor variation of accessing administered object. • This way, clients access administered object through a vendor neutral abstract factory. This way, clients access administered object through a vendor neutral abstract factory. • This allows for any JMS implementation to be used without affecting the client at all. This allows for any JMS implementation to be used without affecting the client at all.

• A sample Java™ implementation of this abstract factory is in A sample Java™ implementation of this abstract factory is in JMS_AbstractFactoryExample.zip. JMS_AbstractFactoryExample.zip.

Documents

Factory Design Patterns Abstract Factory