Cours design pattern m youssfi partie 7 facade bridge flyweight

DDeessiiggnn PPaatttteerrnnss
PPaarrtt 77
Mohamed Youssfi
Laboratoire Signaux Systèmes Distribués et Intelligence Artificielle (SSDIA)
ENSET, Université Hassan II Casablanca, Maroc
Email : med@youssfi.net
Supports de cours : http://fr.slideshare.net/mohamedyoussfi9
Chaîne vidéo : http://youtube.com/mohamedYoussfi
Recherche : http://www.researchgate.net/profile/Youssfi_Mohamed/publications
med@youssfi.net

PPaatttteerrnnss ::
- FFaaccaaddee
-- BBBBrrrriiiiddddggggeeee
- FFllyyWWeeiigghhtt

Problème :: SSyyssttèèmmee ccoommpplleexxee
Un sous système est complexe s’il fait appel à plusieurs interfaces
Client Client Client
med@youssfi.net
A
C
B
E F
D
Système complexe
??!!

PPaatttteerrnn FFaaççaaddee
Créer une seule façade pour ce sous-système.
Facade
Client
Client Client
med@youssfi.net
A
C
B
E F
D
Système complexe
??!!

PPaatttteerrnn FFaaccaaddee
Catégorie :
◦ Structure
Objectif du pattern
◦ Fournir une interface unique en remplacement d'un
eennsseemmbbllee dd''iinntteerrffaacceess dd''uunn ssoouuss--ssyyssttèèmmee..
◦ Définir une interface de haut niveau pour rendre le sous-système
plus simple d'utilisation..
Résultat :
◦ Le Design Pattern permet d'isoler les
fonctionnalités d'un sous-système utiles à la
partie cliente.
med@youssfi.net

Diagramme de ccllaasssseess dduu ppaatttteerrnn FFaaccaaddee
med@youssfi.net

RRaaiissoonn dd’’uuttiilliissaattiioonn
Le système comporte un sous-système complexe avec
plusieurs interfaces.
Certaines de ces interfaces présentent des opérations qui
ne sont pas utiles au reste du système.
Cela peut être le cas d'un sous-système communiquant
aavveecc ddeess oouuttiillss ddee mmeessuurree oouu dd''uunn ssoouuss--ssyyssttèèmmee dd''aaccccèèss àà
la base de données.
Il serait plus judicieux de passer par une seule interface
présentant seulement les opérations utiles.
Une classe unique, la façade, présente ces opérations
réellement nécessaires.
med@youssfi.net

RReessppoonnssaabbiilliittééss
ClasseA et ClasseB : implémentent diverses
fonctionnalités.
Facade : présente certaines fonctionnalités. Cette classe
utilise les implémentations des objets ClasseA et ClasseB.
Elle expose une version simplifiée du sous-système
CCllaasssseeAA--CCllaasssseeBB..
La partie cliente fait appel aux méthodes présentées par
l'objet Facade. Il n'y a donc pas de dépendances entre la
partie cliente et le sous-système ClasseA-ClasseB.
med@youssfi.net

IImmpplléémmeennttaattiioonn
public class ClasseA {
public void operation1(){
System.out.println(Opération 1 de la classe A);
}
System.out.println(Opération 2 de la classe A);
}
}
/* ClasseA.java */
med@youssfi.net
public class ClasseB {
System.out.println(Opération 3 de la classe B);
}
System.out.println(Opération 4 de la classe B);
}
}
/* ClasseB.java */

/* Facade.java */
public class Facade {
private ClasseA a=new ClasseA();
private ClasseB b=new ClasseB();
System.out.println(Opération 2 de Facade :);
a.operation2();
}
System.out.println(Opération 41 de Facade :);
b.operation4();
a.operation1();
}
}
med@youssfi.net

/* Application.java */
public class Application {
public static void main(String[] args) {
Facade facade=new Facade();
facade.operation2(); facade.operation41();
}
}
Opération 2 de Facade :
Opération 2 de la classe A
Opération 41 de Facade :
Opération 4 de la classe B
Opération 1 de la classe A
med@youssfi.net
::CClliieenntt
::FFaaccaaddee
Créer
operation41
::CCllaassssAA
Créer
operation4
::CCllaassssBB
Créer

PPAATTTTEERRNN
BBBBRRRRIIIIDDDDGGGGEEEE
med@youssfi.net

PPaatttteerrnn BBrriiddggee
Catégorie :
◦ Structure
Objectif du pattern
◦ Découpler l'abstraction d'un concept de son
iimmpplléémmeennttaattiioonn..
◦ Permettre à l'abstraction et l'implémentation de varier
indépendamment.
Résultat :
◦ Le Design Pattern permet d'isoler le lien entre
une couche de haut niveau et celle de bas niveau.
med@youssfi.net

DDiiaaggrraammmmee ddee ccllaassssee
med@youssfi.net

Le système comporte une couche bas niveau réalisant
l'implémentation et une couche haut niveau réalisant l'abstraction. Il
est nécessaire que chaque couche soit indépendante.
Cela peut être le cas du système d'édition de documents d'une
application. Pour l'implémentation, il est possible que l'édition
aboutisse à une sortie imprimante, une image sur disque, un document
PPDDFF,, eettcc......
Pour l'abstraction, il est possible qu'il s'agisse d'édition de factures, de
rapports de stock, de courriers divers, etc...
Chaque implémentation présente une interface pour les opérations de
bas niveau standard (sortie imprimante)
Chaque abstraction hérite d'une classe effectuant le lien avec cette
interface.
Ainsi les abstractions peuvent utiliser ce lien pour appeler la couche
implémentation pour leurs besoins (imprimer facture).
med@youssfi.net

Implementation : définit l'interface de l'implémentation. Cette
interface n'a pas besoin de correspondre à l'interface de l'Abstraction.
L'Implementation peut, par exemple, définir des opérations primitives
de bas niveau et l'Abstraction des opérations de haut niveau qui
utilisent les opérations de l'Implementation.
ImplementationA et ImplementationB : sont des sous-classes
concrètes de l'implémentation.
Abstraction : définit l'interface de l'abstraction. Elle possède une
rrééfféérreennccee vveerrss uunn oobbjjeett IImmpplleemmeennttaattiioonn.. CC''eesstt eellllee qquuii ddééffiinniitt llee lliieenn
entre l'abstraction et l'implémentation. Pour définir ce lien, la classe
implémente des méthodes qui appellent des méthodes de l'objet
Implementation.
AbstractionA et AbstractionB : sont des sous-classes concrètes
de l'abstraction. Elle utilise les méthodes définies par la classe
Abstraction.
La partie cliente fournit un objet Implementation à l'objet
Abstraction. Puis, elle fait appel aux méthodes fournit par l'interface de
l'abstraction.
med@youssfi.net

package impl;
public interface ImplementationInteface {
public void operationImpl1(String p);
public void operationImpl2(int p);
}
/* ImplementationInterface.java */
/* ImplementationA.java */
package impl;
public class ImplemationA implements ImplementationInteface {
@Override
public void operationImpl1(String p) {
System.out.println(operationImpl1 de ImplementationA :+p);
}
@Override
public void operationImpl2(int p) {
System.out.println(operationImpl2 de ImplementationA :+p);
}
}
med@youssfi.net

/* ImplementationB.java */
package impl;
public class ImplemationB implements ImplementationInteface {
@Override
System.out.println(operationImpl1 de ImplementationB :+p);
}
@Override
System.out.println(operationImpl2 de ImplementationB :+p);
}
}
med@youssfi.net

/* Abstraction.java */
package abs;
import impl.ImplementationInteface;
public abstract class Abstraction {
private ImplementationInteface implementation;
implementation.operationImpl1(p);
}
med@youssfi.net
implementation.operationImpl2(p);
}
public Abstraction(ImplementationInteface implementation) {
this.implementation = implementation;
}
public abstract void operation();
}

/* AbstractionA.java */
package abs;
public class AbstractionA extends Abstraction{
public AbstractionA(ImplementationInteface implementation) {
super(implementation);
}
@Override
public void operation() {
System.out.println(Méthode operation de AbstractionA);
operationImpl1(X);
operationImpl2(5);
operationImpl1(Y);
med@youssfi.net
}
}

/* AbstractionB.java */
package abs;
public class AbstractionB extends Abstraction{
public AbstractionB(ImplementationInteface implementation) {
super(implementation);
}
@Override
med@youssfi.net
public void operation() {
System.out.println(Méthode operation de AbstractionB);
operationImpl2(9);
operationImpl2(4);
operationImpl1(Z);
}
}

/* Application.java */
import abs.*; import impl.*;
public class Application {
ImplementationInteface implA=new ImplemationA();
ImplementationInteface implB=new ImplemationB();
Abstraction absAA=new AbstractionA(implA); Abstraction absAB=new AbstractionA(implB);
Abstraction absBA=new AbstractionB(implA); Abstraction absBB=new AbstractionB(implB);
System.out.println(---------------------); absAA.operation();
System.out.println(---------------------); absAB.operation();
System.out.println(---------------------); absBA.operation();
System.out.println(---------------------); absBB.operation();
} }
---------------------
Méthode operation de AbstractionA
operationImpl1 de ImplementationA :X
operationImpl2 de ImplementationA :5
operationImpl1 de ImplementationA :Y
---------------------
Méthode operation de AbstractionA
operationImpl1 de ImplementationB :X
operationImpl2 de ImplementationB :5
operationImpl1 de ImplementationB :Y
---------------------
Méthode operation de AbstractionB
operationImpl1 de ImplementationA :Z
---------------------
Méthode operation de AbstractionB
operationImpl1 de ImplementationB :Z

PPAATTTTEERRNN
FFFFLLLLYYYYWWWWEEEEIIIIGGGGHHHHTTTT
PPOOIIDDSS MMOOUUCCHHEE
med@youssfi.net

PPaatttteerrnn FFllyyWWeeiigghhtt
Catégorie :
◦ Structure
Objectif du pattern
◦ UUttiilliisseerr llee ppaarrttaaggee ppoouurr ggéérreerr eeffffiiccaacceemmeenntt uunn ggrraanndd
nombre d' objets de faible granularité.
Résultat :
◦ Le Design Pattern permet d'isoler des
objets partageables.
med@youssfi.net

Un système utilise un grand nombre d' instances. Cette
quantité occupe une place très importante en mémoire.
Or, chacune de ces instances a des attributs extrinsèques
(propre au contexte) et intrinsèques (propre à l'objet).
Cela peut être les caractéristiques des traits dans un
logiciel de DAO.
LLee ttrraaiitt aa uunnee ééppaaiisssseeuurr ((ssiimmppllee oouu ddoouubbllee)),, uunnee ccoonnttiinnuuiittéé
(continu, en pointillé), une ombre ou pas, des coordonnées.
Les caractéristiques d'épaisseur, de continuité et d'ombre
sont des attributs intrinsèques à un trait,
Tandis que les coordonnées sont des attributs
extrinsèques.
Plusieurs traits possèdent des épaisseurs, continuité et
ombre similaires. Ces similitudes correspondent à des
styles de trait. med@youssfi.net

En externalisant les attributs intrinsèques des objets (style de trait), on
peut avoir en mémoire une seule instance correspondant à un groupe
de valeurs (simple-continu-sans ombre, double-pointillé-ombre).
Chaque objet avec des attributs extrinsèques (trait avec les
coordonnées) possède une référence vers une instance d'attributs
intrinsèques (style de trait).
OOnn oobbttiieenntt ddeeuuxx ttyyppeess ddee ppooiiddss--mmoouucchhee :: lleess ppooiiddss--mmoouucchhee ppaarrttaaggééss
(style de trait) et les poids mouche non partagés (le trait avec ses
coordonnées).
La partie cliente demande le poids-mouche qui l'intéresse à la fabrique
de poids-mouche. S'il s'agit d'un poids mouche non partagé, la fabrique
le créera et le retournera.
S'il s'agit d'un poids-mouche partagé, la fabrique vérifiera si une
instance existe. Si une instance existe, la fabrique la retourne, sinon la
fabrique la crée et la retourne.
med@youssfi.net

PoidsMouche : déclare l'interface permettant à l'objet de recevoir et
d'agir en fonction de données extrinsèques. On externalise les
données extrinsèques d'un objet PoidsMouche afin qu'il puisse être
réutilisé.
ConcretePoidsMouche : implémente l'interface poids-mouche. Les
informations contenues dans un ConcretePoidsMouche sont
intrinsèques (sans lien avec son contexte). Puisque, ce type de poids
mouche est obligatoirement partagé.
CCoonnccrreetteePPooiiddssMMoouucchheeNNoonnPPaarrttaaggee :: iimmpplléémmeennttee ll''iinntteerrffaaccee
poids-mouche. Ce type de poids-mouche n'est pas partagé. Il possède
des données intrinsèques et extrinsèques.
PoidsMoucheFabrique : fournit une méthode retournant une
instance de PoidsMouche. Si les paramètres de l'instance souhaitée
correspondent à un PoidsMouche partagé, l'objet
PoidsMoucheFabrique retourne une instance déjà existante. Sinon
l'objet PoidsMoucheFabrique crée une nouvelle instance.
La partie cliente demande à PoidsMoucheFabrique de lui fournir un
PoidsMouche.
med@youssfi.net

public interface PoidsMouche {
public void afficher(String context);
}
/* PoidsMouche.java */
/* ImplementationA.java */
public class PoidsMoucheConcret implements PoidsMouche {
private String valeur;
public PoidsMoucheConcret(String valeur) {
this.valeur = valeur;
}
@Override
public void afficher(String context) {
System.out.println(Poids mouche avec la valeur +valeur+
,context=+context);
}
}
med@youssfi.net

/* PoidsMoucheNonPartage.java */
public class PoidsMoucheNonPartage implements PoidsMouche {
private String valeur1;
private String valeur2;
public PoidsMoucheNonPartage(String valeur1, String valeur2) {
this.valeur1 = valeur1;
this.valeur2 = valeur2;
med@youssfi.net
}
@Override
public void afficher(String context) {
System.out.println(Poids mouche avec valeut1=+valeur1+
,valeur2=+valeur2);
}
}

/* FabriquePoidsMouche.java */
import java.util.HashMap;
import java.util.Map;
public class FabriquePoidsMouche {
private MapString, PoidsMouche poidsMouchesPartages=
new HashMapString,PoidsMouche();
public FabriquePoidsMouche() {
poidsMouchesPartages.put(je,new PoidsMoucheConcret(je));
poidsMouchesPartages.put(suis,new PoidsMoucheConcret(suis));
poidsMouchesPartages.put(poids,new PoidsMoucheConcret(poids));
poidsMouchesPartages.put(mouche,new PoidsMoucheConcret(mouche));
}
med@youssfi.net
public PoidsMouche getPoidsMouche(String val){
PoidsMouche pm=poidsMouchesPartages.get(val);
if (pm==null){
pm=new PoidsMoucheConcret(val);
poidsMouchesPartages.put(val, pm);
}
return pm;
}
public PoidsMouche getPoidsMouche(String val1,String val2){
return new PoidsMoucheNonPartage(val1, val2);
}
}

/* Client.java */
public class Client {
FabriquePoidsMouche fabrique=new FabriquePoidsMouche();
PoidsMouche pm=fabrique.getPoidsMouche(poids);
PoidsMouche pmBis=fabrique.getPoidsMouche(poids);
System.out.println(------------------);pm.afficher(Context1); pmBis.afficher(Context2);
System.out.println(pm==pmBis); System.out.println(------------------);
PoidsMouche pm2=fabrique.getPoidsMouche(flyweight);
PoidsMouche pm2Bis=fabrique.getPoidsMouche(flyweight);
pm2.afficher(Context1); pm2Bis.afficher(Context2);
System.out.println(pm2==pm2Bis); System.out.println(------------------);
PoidsMouche pm3=fabrique.getPoidsMouche(A,B);
PoidsMouche pm3Bis=fabrique.getPoidsMouche(A,B);
pm3.afficher(null); pm3Bis.afficher(null);
System.out.println(pm3==pm3Bis); System.out.println(------------------);
}
} ------------------
Poids mouche avec la valeur poids ,context=Context1
Poids mouche avec la valeur poids ,context=Context2
true
------------------
Poids mouche avec la valeur flyweight ,context=Context1
Poids mouche avec la valeur flyweight ,context=Context2
true
------------------
Poids mouche avec valeut1=A ,valeur2=B
Poids mouche avec valeut1=A ,valeur2=B
false
------------------

Cours design pattern m youssfi partie 7 facade bridge flyweight

Contenu connexe

Tendances (20)

En vedette (9)

Similaire à Cours design pattern m youssfi partie 7 facade bridge flyweight (20)

Plus de ENSET, Université Hassan II Casablanca (6)

Cours design pattern m youssfi partie 7 facade bridge flyweight