7b_IFT232_DesignPatterns_FactoryMethod

Factory Design Patterns
Factory Method
Plan
• Factory : principes
• The Factory Method pattern
• The Abstract Factory pattern
“Design patterns are recurring solutions to design problems
you see over and over.”
[Smalltalk Companion]
Factory Method Design Pattern
Intention
Portée: classes
• Définir une interface pour la création d’un objet,
mais laisser les sous-classes décider de la classe à
instancier
• Une classe délègue l’instanciation à ses sousclasses.
Factory Method Design Pattern
Motivation
• PROBLEME:
• Un framework possède
• des classes abstraites par rapport aux applications
• des sous-classes spécifiques aux applications pour
réaliser différentes implémentations
• SOLUTION:
• Le Factory Method pattern
• encapsule les connaissances
sur quelles sous-classes il faut instancier
• déplace ces connaissances à l’extérieur du
framework
Factory Method Design Pattern
Exemple I
Factory Method Design Pattern
Exemple II
• Enterprise JavaBean (EJB) Application:
• Un bean entité est une représentation objet de données persistentes
ces données sont placées sur un support persistent, e.g. une base de données.
• Une clé primaire identifie chaque instance d’un bean entité.
• Les beans entités sont créés en instanciant un objet via une méthode factory
(create).
• Le même principe s’applique pour les beans de session.
Factory Method Design Pattern
Exemple II (suite)
import javax.naming.*;
public class EJBClient {
public static void main (String[] argv)
{ // get the JNDI naming context
Context initialCtx = new InitialContext ();
// use the context to lookup the EJB Home interface
AccountHome home=(AccountHome)initialCtx.lookup("Account");
// use the Home Interface to create a Session bean object
Account account = home.create (10001, "Athul", 100000000.25d);
// invoke business methods
account.credit (200000000.25d);
// remove the object
account.remove ();
}
}
Factory Method Design Pattern
Structure
• Les sous-classes redéfinissent les méthodes abstraites de la
classe abstraite pour rendre la sous-classe appropriée
Factory Method Design Pattern
Collaboration
• La classe Creator s’appuie sur ses sousclasses pour définir une méthode “factory” qui
rend une instance de la classe appropriée
ConcreteProduct
Factory Method Design Pattern
Quand l’appliquer?
• Lorsque la classe qui doit instancier des classes ne connaît
que les classes abstraites.
• La classe ne connaît que le moment de la création d’un objet,
• mais ne connaît pas quelle sorte d’objets, elle doit créer
parce que cet objet dépend de l’application
• Une classe veut que ses sous-classes spécifient quels objets
seront créés
• Les classes délèguent la responsabilité à une ou plusieurs
sous-classes d’aide
• on désire rendre locales les connaissances qui vont aider à
déterminer quel sera la classe d’aide dans une situation donnée
Factory Method Design Pattern
Implémentations - Variations
1.
__
•
Une classe abstraite définit la méthode “factory” abstraite
•
•
2.
Les sous-classes de la classe abstraite implémentent
l’interface
__
•
•
3.
Alternative: une interface contient les signatures de création
Une classe concrète possède une implémentation par défaut
de la méthode “factory”
Les sous-classes redéfinissent ou non la méthode “factory”
__
• La méthode “factory” possède un paramètre qui identifie la
sorte d’objet à créer
Factory Method Design Pattern
Factory Method: diagramme de classe I
factory method
Factory Method Design Pattern
Factory Method: diagramme de classe II
factory method
• Invocation de la factory method createDocument() qui
est responsable de la construction des objets
Factory Method Design Pattern
Bénéfices et désavantages I
• Les méthodes “factory” éliminent le besoin de lier des
classes spécifiques à une application dans le code
• Le code n’intervient qu’avec l’interface du produit et
peut ainsi travailler avec n’importe quelle classe
concrète définie par l’usager
• Les clients peuvent devoir sous-classer la classe
Creator uniquement pour créer un type particulier
d’objet ConcreteProduct
Factory Method Design Pattern
Bénéfices et désavantages II
•
Fournir des points d’arrimage (“hook”) pour les
sous-classes
•
La création d’objets à l’intérieur d’une classe à
l’aide d’une méthode “factory” est toujours plus
flexible que la création directe de l’objet.
Factory Method Design Pattern
Bénéfices et désavantages III
•
Connexion de hiérarchies parallèles
•
Les hiérarchies parallèles de classes
surviennent lorsqu’une classe délègue une
partie de ses responsabilités à une classe
séparée
Factory Method Design Pattern
Choix d’implémentation I
•
Deux variantes principales
•
La classe Creator est une classe abstraite et ne
fournit pas d’implémentation par défaut de la
méthode “factory”
•
La classe Creator est une classe concrète et
fournit une implémentation par défaut de la
méthode “factory”
Factory Method Design Pattern
Choix d’implémentation II
•
La méthode “factory” est paramétrée.
•
Une variation sur ce patron permet à la méthode
“factory” de créer plusieurs sortes de produits.
•
La méthode “factory” possède un paramètre qui
identifie la sorte d’objet à créer.
•
Tous les objets créés par la méthode “factory”
partagent l’interface Product.
Factory Method Design Pattern
Factory Method: exemple II
Classe
abstraite
interface
Classe
concrète
Classe
concrète
public abstract class TablesCreator
{…
public abstract TableCodeCreator getTableCodeCreator(String dbName) ;
}
public interface TableCodeCreator
{…
void createSource();
}
public class DB2TableCodeCreator implements TableCodeCreator
{…
public void createSource(padis.util.ClassInfoDescriptor descriptor, String workingDir)
{ // CREATES JAVA SOURCE CODE FOR tableName.java FILES}
}
public class ConcreteTablesCreator extends TablesCreator
{…
public TableCodeCreator getTableCodeCreator(String dbName)
{
if (dbName.equals (“DB2”))
return new DB2TableCodeCreator();
else if (dbName.equals (“ORACLE”))
return new ORACLETableCodeCreator();
…}
}
Factory Method Design Pattern
exemple II (suite)
[création des tables à partir d’un schéma XML]
// ConcreteTablesCreator
String dbname =
crs4.util.Configuration.getInstance().getProperty(“default.database.name”);
TableCodeCreator codeCreator = this.getTableCodeCreator(dbname); //read from
property
for (int i=0; i<this.getClassesArray().length; i++)
{
factory method
codeCreator.createSource(
this.getClassesArray()[i],
this.getWorkingDirectory());
}
Factory Method Design Pattern
Choix d’implémentation III
•
Conventions de noms (Naming conventions)
•
Bonne pratique d’utiliser des conventions de
noms qui identifient clairement les méthodes
“factory”.
Factory Method Design Pattern
Références
• E. Gamma, R. Helm, R. Johnson, J. Vlissides, Design Patterns,
Addison-Wesley Professional Computing Series, 1998.
• J.W. Cooper, Java Design Patterns – A Tutorial, AddisonWesley, 2000.
• G.S. Raj, Factory Method creational pattern,
http://gsraj.tripod.com/design/creational/factory/factory.html
Factory Method Design Pattern