Présentation à la nAcademy (Mai 2011) : Design Patterns Introduction par Cédric Mourouvin

1. nAccademy
Design Patterns Introduction
Présentation par Frédéric Salembier
Le 5 mai 2011

2. Plan
 Qu’est ce qu’un design pattern ?
 Comment les classer ?
 Le singleton
 La factory

3. Qu’est ce qu’un design pattern ?
 Définition
◦ Solution empirique pour résoudre un problème identifié et partagé
◦ Equivalent à une bibliothèque de coups d’un logiciel d’échecs
 Mise en place
◦ Premiers sont apparus fin années 70
◦ Un domaine très vaste
◦ Il s’applique au monde objet
◦ Indépendant du langage
 Attention ce n’est pas une science
◦ Le principe est de plaquer une méthode connu pour résoudre un
problème
◦ La difficulté est de reconnaitre les cas d’utilisations
◦ Le risque est d’en mettre partout

4. Les trois familles
 Patterns créateurs
◦ Utilisés pour construire des objets découplés du système de
mise en œuvre.
◦ Exemples : Factory, Builder, Singleton
 Patterns structurels
◦ Utilisés pour former des structures objet de grande taille entre
de nombreux objets disparates.
◦ Exemples : Proxy, Decorateur, Facade
 Patterns comportementaux
◦ Permettent de gérer des algorithmes ou relations entre objets
indépendamment de l’objet sur lequel ils s’appuient.
◦ Exemples : Iterator, Strategy, Observer

5. Singleton : présentation
 Avantages pour l’architecte
◦ Garantir qu’une classe ne possède qu’une seule instance
 Avantages pour le développeur
◦ Avoir un point d’accès global à l’instance
 Utilisations
◦ Accès de n’importe où à un système de log
◦ Accès à un lecteur de configurations pour ne pas rouvrir à chaque
fois le fichier

6. Singleton : mise en place
 Principes
◦ Une auto référence privée dans l’objet
◦ Un constructeur privé
◦ Une méthode public (getter) d’accès à l’instance qui teste
l’initialisation
 Code java
// Classe basée sur le pattern Singleton qui permet la journalisation de l'application.
public class Journalisation
{
private static Journalisation uniqueInstance;// Stockage de l'unique instance de cette classe.
private Integer nbAppel; // Entier représentant le nb d'appel.
// Constructeur en privé (donc inaccessible à l'extérieur de la classe).
private Journalisation()
{
this.nbAppel = new Integer(0);
}
// Méthode statique qui sert de pseudo-constructeur
public static Journalisation getInstance()
{
if (uniqueInstance == null)
{
uniqueInstance = new Journalisation();
}
return uniqueInstance;
}
public void ajouterAppel(String log) { this.nbAppel++; }
public String getNbAppel() { return this.nbAppel; }
}

7. Singleton : exercice
 Dans l’exemple précédent une notion
fondamentale à été oubliée, laquelle ?

8. Factory : présentation
 Avantages pour l’architecte
◦ Isolation du code métier
◦ Factorisation des algorithmes
 Avantages pour le développeur
◦ Abstraction des méthodes : principe de la boite noire
◦ Utilisation de méthodes générique

9. Factory : exemple
CalculateurFactory
+ getTarificateur(contexte)
{
// algo de détermination du calculateur
// renvoie d’une instance de la classe
concrète choisie
} Calculateur
+ getTarif(params);
<< instantiate >>
CalculateurAuto CalculateurMRH CalculateurSante
+ getTarif(params) + getTarif(params) + getTarif(params)
{ { {
// code d’implémentation // code d’implémentation // code d’implémentation
} } }

10. Factory : utilisation
 Schéma pour la formule
Calculateur
+List<String> getFormules();
CalculateurAuto CalculateurMRH CalculateurSante CalculateurScolaire
+List<String> getFormules() +List<String> getFormules()
{ {
// implémentation // implémentation
} }
 Exemple d’algo de formules
Pour le calculateurAuto :
return {‘Confort’, ‘Maxi’}
Pour le CalculateurMRH
return {‘Sérénité’, ‘Essentiel’, ‘Complete’}

11. Factory : exercices (plus loin dans la généricité)
 1/ Comment gérer des contextes différents dans la
même factory ?
 2/ Implémentez cet algorithme :
Voici les fractionnements proposés pour les produits
Auto classique -> [‘A’, ‘T’, ‘M’]
Auto bon conducteur -> [‘A’, ‘T’, ‘M’]
Auto jeune -> [‘A’, ‘S’, ‘T’, ‘M’]
Auto malussé -> [‘U’]

12. Factory : exercice 1
Généralisation du contexte :
ContexteBean contexte = new ContexteBean(client, vehicule, conducteurs, contrat);
Calculateur tarification = CalculateurFactory.getTarificateur(codeOperation);
DevisResultBean devisResult = (DevisResultT9Bean) tarification.getTarif(contexte);
CalculateurBean
CalculateurBeanContexte CalculateurBeanAuto CalculateurBeanTarifResult
- int idPolice; - Client cli; - String Formule;
- String login; - Vehicule veh; - String fractionnement;
- String codeOperation; - <Conducteur> conducts; - Float prime;
- String login; - Float taxes;
// les getters et setters // les getters et setters // les getters et setters

13. Factory : exercice 2
 Implémentation
ProduitAlgo implements ProduitAlgoInterface
{
public List<String> getFractionnements()
{
return {‘A’, ‘T’, ‘M’};
}
}
ProduitAlgoClassique extends ProduitAlgo
{
ø
}
ProduitAlgoMalusse extends ProduitAlgo
{
public List<String> getFractionnements()
{
return {‘U’};
}
}
ProduitAlgoJeune extends ProduitAlgo
{
public List<String> getFractionnements()
{
List<String> list = super.getFractionnements();
list.add(‘T’);
return list;
}
}

14. Conclusion
 Souvent utilisés sans même le savoir
 Buts
◦ Simplifier le code
◦ Le rendre plus efficace et robuste
◦ Permettre un langage commun entre développeurs
 Gain
◦ obtenir de la généricité pour pérenniser les développements
 Attention
◦ ce ne sont pas des solutions miracles
◦ aux abus, tout n’est pas design pattern
 Aller plus loin avec le wiki neuros