Factory Design Patterns Factory Method

1. Factory Design PatternsFactory Method

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

3. 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 sous-classes. Factory Method Design Pattern

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

5. Exemple I Factory Method Design Pattern

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

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

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

9. Collaboration • La classe Creators’appuie sur ses sous-classes pour définir une méthode “factory” qui rend une instance de la classe appropriée ConcreteProduct Factory Method Design Pattern

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

11. Implémentations - Variations • __ • Une classe abstraite définit la méthode “factory” abstraite • Alternative: une interface contient les signatures de création • Les sous-classes de la classe abstraite implémentent l’interface • __ • 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

12. factory method Factory Method: diagramme de classe I Factory Method Design Pattern

13. factory method Factory Method: diagramme de classe II • Invocation de la factory methodcreateDocument() qui est responsable de la construction des objets Factory Method Design Pattern

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

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

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

17. Choix d’implémentation I • Deux variantes principales • La classeCreatorest une classe abstraite et ne fournit pas d’implémentation par défaut de la méthode “factory” • La classeCreatorest une classe concrète et fournit une implémentation par défaut de la méthode “factory” Factory Method Design Pattern

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

19. Classe abstraite interface Classe concrète Classe concrète Factory Method: exemple II 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

20. factory method 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 (inti=0; i<this.getClassesArray().length; i++) { codeCreator.createSource( this.getClassesArray()[i], this.getWorkingDirectory()); } Factory Method Design Pattern

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

22. 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, Addison-Wesley, 2000. • G.S. Raj, Factory Method creational pattern, http://gsraj.tripod.com/design/creational/factory/factory.html Factory Method Design Pattern