Génie Logiciel

Chapitre 4- Patrons de conception

“Design patterns”

Préparé et présenté par

Pr. N. ASSAD

1
 • Définition des design patterns
• Les modèles de création
- Fabrique de création
- Singleton
- Builder
• Les modèles de structure
- Adapter
- Proxy
- Composite
• Les modèles de comportement
- Iterator
- Template
• Conclusion

2
 Patron de conception - Définition

• Un patron de conception décrit à la fois un problème qui se produit très

fréquemment dans un environnement, basé sur l’approche par objet, et
l’architecture de la solution à ce problème pour un scénario particulier.

• Les patrons de conception représentent les Bonnes Pratiques utilisées par

les développeurs de logiciels.

• Les patrons de conception sont des solutions aux problèmes généraux

rencontrés par les développeurs de logiciels.

• Les patrons de conception sont définis pour pouvoir être utilisés avec un
maximum de langages orientés objets

3
 Utilisation des Patrons de conception

Les patrons de conception ont deux utilisations principales dans le

développement de logiciels :

• Plateforme partagée pour les développeurs

Les patrons de conception fournissent une terminologie standard et chaque

modèle est spécifiques à un scénario particulier.

• Les meilleures pratiques

Les patrons de conception ont évolué sur une longue période de temps et ils
fournissent les meilleures solutions à certains problèmes rencontrés lors du
développement de logiciels.
L'apprentissage de ces modèles aide les développeurs inexpérimentés à
apprendre la conception de logiciels de manière simple et plus rapide.
4
 Patrons de conception - Type

N Pattern & Description

Modèles de création (Creational Patterns)
1 Ces modèles sont très courants pour désigner une classe chargée de créer et
construire des objets. Cela donne plus de flexibilité pour décider quels objets
doivent être créés pour un cas d'utilisation donné.

Modèles de structure (Structural Patterns)

2 Ces modèles sont utiliser pour concevoir des agglomérations de classes avec
des macro-composants.

Modèles de comportement (Behavioral Patterns)

3 Ces modèles de conception sont conçus pour répartir les tâches entre classe.

5
 Modèles de création (Creational patterns) :
Fabrique (Factory)

Problème de déterminer dynamiquement, lors de l’exécution, quel objet doit

être instancié parmi d’un ensemble de sous-classes.
Solution : utilisation de patron de conception « Fabrique/Abstraite_Fabrique»

Une Fabrique est une classe qui n'a pour rôle que
de créer et de construire des objets.

• Il est utilisable lorsque :

- On ne peut déterminer le type d'objet à créer qu'à l'exécution
- Il y a une volonté de centraliser la création des objets
- Il est nécessaire de masquer l'origine des objets.

6
 Modèles de création (Creational patterns) :
Fabrique (Abstract Factory)

Implémentation :

• L’implémentation de la Fabrique/Abstraire_Fabrique prend plusieurs

formes dont les deux principales sont :

- Déclarer la Fabrique Abstraite/Interface, où ses méthodes sont destinées à

être implémentées dans les sous-classes, et laisser une de ses sous-classes
créer l'objet;
- Déclarer une Fabrique dont la méthode de création de l'objet attend les
données nécessaires pour déterminer le type de l'objet à instancier.

• Le patron de conception Fabrique est invoqué à chaque création d’objet, et

cela permet de rendre l'instanciation d'objets plus flexible que de passer par
l’intermédiaire de l’opérateur « new».
7
 Modèles de création (Creational patterns) :
Fabrique (Abstract Factory)

Structure

8
 Modèles de création (Creational patterns) :
Fabrique (Abstract Factory)
/** Interface de description d'un point */
public interface Point {
public int getX();
public int getY();
}
/** Interface de description d'une ligne */
public interface Line {
public int getX1();
public int getY1();
public int getX2();
public int getY2();
}
/** Fabrique retournant des objets de types point ou ligne */
public class PointLineFactory {
/** Retourne un Point aux coordonnées x,y */
public Point getPoint( int x, int y ) {
return new PointImpl( x, y );
}
/** Retourne une Ligne aux coordonnées x1,y1,x2,y2 */
public Line getLine( int x1, int y1, int x2, int y2 ) {
9 return new LineImpl( x1, y1, x2, y2 );}}
 Modèles de création (Creational patterns) : Singleton

Ce Patron de conception a pour rôle de n'avoir qu'une seule et unique instance

d'une classe dans une application.

Le design pattern Singleton supporte plusieurs formes d’implémentation qui :

• assurer qu'il n'existe qu'une seule et unique instance de la classe;
• fournir un moyen d'obtenir cette instance.

10
 Modèles de création (Creational patterns) : Singleton

Structure

11
 Modèles de création (Creational patterns) : Singleton

Implémentation classique

• Tout constructeur de la classe est de visibilité « private »

pour empêcher toute instanciation de l'extérieur de la classe.

• L'unique instance est une variable de classe.

• Un getter static permet de renvoyer l'instance et de la créer au besoin.

• La classe est déclarée final pour empêcher la création d'une classe dérivée.

• Redéfinir la méthode clone pour empêcher son utilisation.

12
 Modèles de création (Creational patterns) : Singleton

Implémentation classique

public final class MonSingleton {

private static MonSingleton instance;

private MonSingleton() {
// traitement du constructeur
}

public static MonSingleton getInstance() {

if (instance == null) {
instance = new MonSingleton();
}
return instance;
}
}
13
 Modèles de création (Creational patterns) : Singleton

Exemple :
Le bureau du Président d’Etat est un Singleton. La Constitution de l’Etat
précise les moyens par lesquels est élu un président, limite la durée du mandat,
et définit l'ordre de succession. En conséquence, il peut y avoir au plus un
président actif à un moment donné. Quelle que soit l'identité personnelle du
président actif, le titre, « Le Président» est un point d'accès global qui identifie
la personne dans le bureau.

14
 Modèles de création (Creational patterns) : Singleton

• Quelle est la différence entre une classe statique et une classe singleton ?

• Est-ce qu’on peut créer un clone d'un objet singleton ?

• Comment empêcher le clonage d'un objet singleton ?

15
 Modèles de création (Creational patterns) : Singleton

Empêcher le clonage d'un objet singleton :

public final class MonSingleton {
private static MonSingleton instance;

private MonSingleton() {
// traitement du constructeur
}

public static MonSingleton getInstance() {

if (instance == null) {
instance = new MonSingleton();
}
return instance;
}

@Override
public Object clone() throws CloneNotSupportedException {
throw new CloneNotSupportedException();
}
}

16
 Modèles de création (Creational patterns) : Builder

• Le Builder ou Monteur est une classe offrant des moyens de construction

d'un objet.

• Le problème de patron de conception ‘Factory’, c'est qu'elle ne permet pas

de définir comment un objet va être construit.

• Il est toujours possible de passer x paramètres dans la méthode de création

d'une fabrique mais cela s'avère souvent trés réducteurs voire délicat pour
la maintenance.

17
 Modèles de création (Creational patterns) : Builder

Exemple :

Exemple à l’usage :

18
 Modèles de création (Creational patterns) : Adapter

Adapter :
• L'Adaptateur ou Adapter est un moyen commode de faire fonctionner un
objet avec une interface qu'il ne possède pas.

• L'idée est de concevoir une classe supplémentaire qui se charge

d'implémenter la bonne interface (L'Adaptateur) et d'appeler les méthodes
correspondantes dans l'objet à utiliser (L'adapté).

19
 Modèles de création (Structural patterns) : Adapter

Exemple :

20
 Modèles de création (Structural patterns) : Adapter

21
 Modèles de création (Structural patterns) : Adapter

22
 Modèles de création (Structural patterns) : Adapter

23
 Modèles de création (Structural patterns) : Proxy

• Assez proche de l'Adaptateur, le Proxy cherche à ajouter un niveau de

redirection entre l'appel d'une méthode d'un objet et l'action associée.

• Ce type de structure vise à pouvoir changer l'objet cible sans changer l'objet
source (manipulé).

24
 Modèles de création (Structural patterns) : Proxy

Problème :
Prendre en charge les objets gourmands en ressources et vous ne voulez pas
instancier ces objets tant qu'ils ne sont pas réellement demandés par le client.

25
 Modèles de création (Structural patterns) : Proxy

• Identifiez le levier ou "l'aspect" qui est le mieux implémenté comme un

wrapper ou un substitut;
• Définissez une interface qui rendra le proxy et le composant d'origine
interchangeables;
• Envisagez de définir une fabrique qui peut encapsuler la décision de savoir
si un proxy ou un objet d'origine est souhaitable;
• La classe wrapper contient un pointeur sur la classe réelle et implémente
l'interface;
• Le pointeur peut être initialisé lors de la construction ou lors de la première
utilisation;
• Chaque méthode wrapper contribue son effet de levier et délègue à l'objet
wrappee.

26
 Modèles de création (Structural patterns) : Proxy

En définissant une interface Subject, la présence de l'objet Proxy à la place du

Subject réel est transparente pour le client.

27
 Modèles de création (Structural patterns) : Proxy

Exemple :
• Le proxy fournit un substitut ou un espace réservé pour fournir l'accès à un
objet.
• Un chèque ou une traite bancaire est un proxy pour les fonds dans un compte.
• Un chèque peut être utilisé à la place de l'argent pour faire des achats et, en
fin de compte, contrôler l'accès à l'argent dans le compte de l'émetteur.

28
 Modèles de création (Structural patterns) : Proxy

Exemple :

29
 Modèles de création (Structural patterns) : Composite

• Le modèle Composite cherche à éliminer toute différence entre un groupe

d'objets et un objet.
• Il s'agit d'une démarche récurrente valable pour tous les problèmes qui font
émerger de nouvelles structure par association.
• La manière la plus simple pour gérer ces modèles est l'exploitation d'une
interface unique pour les éléments simples et l'élément "composé".

30
 Modèles de création (Structural patterns) : Composite

• Composez les objets dans les structures arborescentes pour représenter les
hiérarchies de parties entières.

• Composite permet aux clients de traiter des objets individuels et des

compositions d'objets de manière uniforme.

• Composition récursive "Les répertoires contiennent des entrées, dont

chacune pourrait être un répertoire.«

• 1-to-many "has a" up the "is a" hierarchy

31
 Modèles de création (Structural patterns) : Composite

Problème
• L'application doit manipuler une collection hiérarchique d'objets
"primitifs" et "composites".

• Le traitement d'un objet primitif est géré dans un sens et le traitement

d'un objet composite est géré différemment.

• Avoir à interroger le "type" de chaque objet avant de tenter de le traiter

n'est pas souhaitable.

32
 Modèles de création (Structural patterns) : Composite

Structure :
Les composites qui contiennent des composants, chacun pouvant être un
composite.

• Menus contenant des éléments de menu,

chacun pouvant être un menu.

• Répertoires contenant des fichiers,

chacun pouvant être un répertoire.

• Conteneurs contenant des éléments,

chacun pouvant être un conteneur.

33
 Modèles de création (Structural patterns) : Composite

Exemple :

34
 Modèles de Comportement « behavioral patterns» :
Iterator

• L'Itérateur ou Iterator est le plus comun des modèles de comportement.

• L'idée étant de limiter la vision d'une collection par un utilisateur.

Typiquement une collection contient un ensemble d'objets stocké par
différentes méthodes (un tableau, un vecteur...).

• La collection offre donc un point d'accès unique sous la forme

d'une interface Iterator.

35
 Modèles de Comportement « behavioral patterns» :
Iterator

Exemple :

36
 Modèles de Comportement « behavioral patterns» :
Template

• Ce modèle utilise simplement les mécanismes de surcharge pour déléguer à

d'autres classes certaines parties d'un algorithme.

• L'idée ressemble un peu au modèle Builder sauf qu'ici, il sert à construire

un traitement et non un objet.

37
 Modèles de Comportement « behavioral patterns» :
Template

Exemple :

38
 Conclusion

• Les Design Patterns représentent un espace trés riche de composition ou de

simplification de votre développement
objet.

• Les Design Patterns peuvent rendre de grands services à condition de ne

pas les exploiter excessivement.

• De nombreux modèles de conception existent et restent aussi à découvrir.

39