Le document présente une introduction aux design patterns, leur définition et classification en trois familles : créateurs, structurels et comportementaux. Il détaille également les patterns Singleton et Factory, enexplique leurs avantages, mise en œuvre, et fournies des exemples de code Java et d'exercices pratiques. L'objectif est de simplifier le code, améliorer son efficacité et instaurer un langage commun entre développeurs.

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