Modele de conception Fabrique [Java]

[Résolu/Fermé]
Signaler
Messages postés
95
Date d'inscription
mardi 9 mars 2004
Statut
Contributeur
Dernière intervention
29 octobre 2009
-
Messages postés
23
Date d'inscription
dimanche 23 mars 2008
Statut
Membre
Dernière intervention
26 septembre 2011
-
Bonsoir à tous,

J'ai trouvé une documentation variée sur le design pattern Factory (ou en français modèle de conception Fabrique) sans pouvoir trouver un exemple de base simple et complet.

Celui qui s'en rapproche, c'est le squelette fourni dans le livre J2EE de Jérôme MOLIERE que voici :

Les entetes des différents fichiers :

public class FooFactory // La factory
public interface IFoo // L'interface
public class FooImpl implements IFoo // L'implementation

L'explication de cette conception :

1- Obtenir une référence sur la Factory => Comment ?

2- Appeler la méthode createObject() sur la Factory de manière à récupérer une implémentation de l'interface IFoo => la factory a une méthode createObject() => quelle est l'entete complète de cette méthode qui renvoie un objet ? pour moi :

public Object obj createObject() // est-ce cela ?
et pour récupérer, je finis par :
return new FooImpl(); // est-ce vraiment cela ?

3- Puis invoquer le service désiré sur l'instance créée par la Fabrique => utiliser une méthode de l'objet fabriqué.

L'objectif de cette conception étant de réduire au minimum les modifications éventuelles : l'idéal uniquement dans la méthode createObject().

Voila les questions que je me pose sur l'utilisation de la Fabrique.
Une petite dernière : je veux utiliser plutôt une fabrique concrète.



Merci d'avance pour tout ceux qui m'aideront à y voir plus clair.


Cordialement,


Vincent

6 réponses

Messages postés
618
Date d'inscription
vendredi 26 juillet 2002
Statut
Membre
Dernière intervention
13 juillet 2013
971
Salut Vincent!


Le but d'une Factory est de te renvoyer des objets concrets qui implémentes une interface commune.

C'est bien beau, mais comment ça marche?

Imagine que tu développes une application est que les utilisateurs doivent pouvoir exporter les données de plusuieurs types d'objets (disons les objets Person, Company, Vehicle) dans un format spécifique (choisissons XML).

Ces objets ne doivent même pas avoir connaissance du fait qu'il peuvent être exportés. Il contiennent juste des variables d'instance, des getters et setters et peut-être quelques autres méthode, mais en tout cas aucune méthode export() ou quelque chose du style.

Ton application doit connaître une factory. Appelons cette classe ExportFactory. Elle ne comporte qu'une seule méthode:
public static ExportObject createExportable(Object source)


ExportObject est une interface que tous les objets exportés concrets doivent implémenter. Elle ne contient qu'une méthode (du moins dans cet exemple):
public String export();


Dans la méthode, createExportable, tu instancies dynamiquement des objets en fonction du paramètre source:
public static ExportObject createExportable(Object source){
  if(source instanceof Person){
    return new PersonExport();
  }else if(source instanceof Company){
    return new FactoryExport();
  }else if(source instanceof Vehicle){
    return new VehicleExport();
  }
  return null;
}


Imaginons que la classe Person ressemble à ceci (restons simples ;-) ):
public class Person{
  private String firstName;
  private String lastName;

  public Person(){
    super();
  }

  public String getFirstName(){
   return firstName;
  }

  public String getLastName(){
    return lastName;
  }

  public String getFirstName(){
   return firstName;
  }

  public void setLastName(String lastName){
    this.lastName=lastName;
  }

  public void setFirstName(String firstName){
    this.firstName=firstName;
  }
}


La classe PersonExport ressemblera à ceci:
public class ExportPerson implements ExportObject {
  private Person person;

  public ExportPerson(Person person){
    super();
    this.person=person;
  }

  public String export(){
    StringBuffer xml = new StringBuffer();
    xml.append("<?xml version='1.0'?>");
    xml.append("<person>");
    xml.append("<firstname>");
    xml.append(person.getFirstName());
    xml.append("</firstname>");
    xml.append("<lastname>");
    xml.append(person.getLastName());
    xml.append("</lastname>");
    xml.append("</person>");
   return xml.toString();
  }
}


De même pour CompanyExport et VehicleExport.

Maintenant, assemblons le tout.

Imaginons qu'un utilisateur sélectionne une personne et demande à l'exporter (en XML, donc).

La méthode ExportFactory.createExportable(Object source)est appelée. La méthode te renvoie un ExportObject sur lequel tu peux appeler la méthode export(); même sans savoir quel type d'objet (concret) tu exportes.

Exemple:
Person hacktrack = new Person();
hacktrack.setFirstName("Hack");
hacktrack.setLastName("Track");

Vehicle veh = new Vehicle();
veh.setMark("Seat");
veh.setColor(java.awt.Color.RED);

ExportObject expObj=ExportFactory.createExportable(hacktrack);
System.out.println(expObj.export());

expObj=ExportFactory.createExportable(veh);
System.out.println(expObj.export());


L'étape suivante consiste à créer une AbstractFactory.
C'est en fait une factory qui te génère... des Factory!

A quoi ça sert?

Imagine que les utilisateurs doivent pouvoir exporter, au choix, en XML, PDF, HTML.
Tu crées une Factory (même principe que ci-dessus) qui te renvoie une interface Factory.

Dans cette factory, tu généres une Factory suivant un paramètre spécifié par l'utilisteur (imaginons une combobox dans une page Web qui contient les types d'export possible: "XML", "PDF","HTML")

Sur la factory que tu récupères, tu appelles la méthode createExportable(Object source) qui te renvoie un ExportObject sur le quel tu appelles à nouveau la méthode export().

L'intérêt est que tu passes un objet à ta Factory et que c'est elle qui choisit l'ExportObject adéquat et que, grâce à l'AbstractFactory, tu puisses exporter dans différent format.
Inconvénient: beaucoup de classes / d'interfaces
Avantage: tu peux facilement ajouter un type d'export (par exemple Excel ou CSV) en créant une nouvelle ExportFactory et les classes qui implémentent ExportObject. il te faudra juste modifier ton AbstractFactory afin d'y ajouter un "if":
if (source instanceof String && ((String)source).equalsIgnoreCase("EXCEL"))...


J'espère que ceci pourra t'aider


;-)
HackTrack
38
Merci

Quelques mots de remerciements seront grandement appréciés. Ajouter un commentaire

CCM 41713 internautes nous ont dit merci ce mois-ci

Messages postés
95
Date d'inscription
mardi 9 mars 2004
Statut
Contributeur
Dernière intervention
29 octobre 2009
3
Merci HackTrack,

la réponse est royale, c'est exactement ce que je voulais savoir, cela confirme bien ce que je pensais.

Maintenant y a plus qu'à ....


Cordialement,

Vincent
Messages postés
23
Date d'inscription
dimanche 23 mars 2008
Statut
Membre
Dernière intervention
26 septembre 2011

merci HackTrack ,

tu ma sauvais vraiment je suis entrains de prendre les DP c'est vraiment ta reponse ma aidé beacoup merci une autre fois .

coordialemnet
Bravo HackTrack.
Bravo HackTrack!
C'est pas trés 'jolie' ça :
xml.append("<?xml version='1.0'?>");
Il existe des librairies pour gérer le xml. Ajouter des balises en tant que String ... çca n'est pas vraiment conseillé

Patrick
Dommage que cette discussion date..Dis nous patrick comment ferai tu pour écrire le XML avec tes fameuse librairies, et en quoi c'est pas conseillé de ne pas rajouter des balises en tant que String! tu penses que ça va s'écrire tout seul :-),
Messages postés
618
Date d'inscription
vendredi 26 juillet 2002
Statut
Membre
Dernière intervention
13 juillet 2013
971
Salut!

C'est pas très joli mais le but ici n'était pas d'utiliser un parser XML... restons simples.

Tu peux peut-être donner le code adapté avec Xerces ou une autre librairie pour les utilisateurs qui sont intéressés.

;-)
Merci infiniment vraiment c bien précis ;)