Design Patterns: introduction

Les Design Patterns

• Les design patterns sont des solutions standard et efficaces pour les problèmes récurrents en conception orientée objet.
• Ces solutions prennent la forme de modèles de classes.
• L'objectif est de suivre le principe du patron et d'implémenter une solution adaptée au programme spécifique.
• Les design patterns sont des modèles abstraits avec un objectif et une structure de classes, afin d'être reproductibles.

Objectifs

• Faciliter la conception des modèles de classes et des architectures.
• Permettre la réutilisation des classes et du code.
• Faciliter l'évolution de la conception.
• Assure une implémentation efficace et pratique.

Historique

• Christopher Alexander a décrit le concept de « patron de conception » dans « A Pattern Language: Towns, Buildings, Construction ».
• L'ouvrage a inventé un « langage » pour la conception d'environnements urbains, où les unités sont des patrons.
• Erich Gamma, John Vlissides, Ralph Johnson et Richard Helm ont repris l’idée dans la programmation orientée objet.
• En 1994, les design patterns ont été formalisés par le « Gang of Four » (GoF) avec leur livre "Design Patterns : elements of reusable software".
• Le livre contenait 22 patrons pour résoudre les problèmes de conception orientée objet et est rapidement devenu un best-seller.

Classification des Design Patterns du GoF

• Il existe 22 design patterns, répartis en trois catégories.

Patrons de création (creational patterns)

• Relatifs aux mécanismes de création de classes et d’objets, augmentant la flexibilité et la réutilisation du code.
• Catégorie de patterns : Singleton, Factory, Abstract factory, Builder, Prototype.

Singleton

• Assure une unique instance d'une classe à l'exécution, offrant un accès global.

Factory

• Définit une interface pour la création d'objets dans une classe mère, déléguant le choix aux sous-classes.
• Permet la création de familles d'objets dont le type est déterminé à l'exécution.

Fabrique abstraite

• Sert à créer des familles d'objets liés sans spécifier leurs classes concrètes, généralisant le modèle de fabrique simple.

Monteur

• Permet la simplification de la création d’objets complexes en séparant le processus de construction.
• L'objet est créé étape par étape, avec les attributs nécessaires uniquement.

Prototype

• Permet la création de nouveaux objets à partir d'objets existants sans dépendance au code de la classe.
• Utilise le clonage d'objets, en modifiant les attributs nécessaires pour différencier les copies.
• Accélère la création d'objets similaires.

Patrons de structure (structural patterns)

• Relatifs à l’assemblage d’objets et de classes en structures plus vastes, maintenant flexibilité et efficacité.
• Catégorie de patterns : Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy.

Adaptateur

• Permet la collaboration entre des objets aux interfaces normalement incompatibles.

Pont

• Sépare les aspects liés à l'abstraction d'une classe de ceux liés à l'implémentation.
• Facilite l’évolution indépendante des deux représentations.

Composite

• Sert à la création d'une arborescence d'objets sous forme de structure en arbre (nœud/feuille).
• Permet de manipuler les éléments, les branches et l'arbre de manière uniforme.

Décorateur

• Sert à l'affectation dynamique de comportements supplémentaires à des objets.
• Place les objets dans des décorateurs enveloppants, ce qui rend possible l'implémentation du comportement.

Façade

• Fournit une interface simplifiée pour accéder à une librairie, un framework ou un sous-système.

Poids mouche

• Il sert à l'utilisation d'un type d'objet pour représenter une gamme de petits objets, permettant ainsi la réutilisation.

Procuration

• Fournit un substitut d'un objet, contrôlant l'accès à l'objet original pour effectuer des manipulations avant ou après la demande.

Patrons de comportement (behavioral patterns)

• Relatifs au comportement des objets de classes dans les algorithmes : communication et répartition des responsabilités.
• Catégorie de patterns : Chain of responsability, Command, Iterator, Mediator, Observer, Strategy, State, Memento, Template method, Visitor.

Stratégie

• Sert à la définition d’une famille d'algorithmes et les intègre dans des méthodes de classes séparées selon le contexte.
• Il est alors possible de sélectionner dynamiquement une stratégie d'exécution.

État

• Sert à la modification du comportement d'un objet selon son état interne.
• Il peut être utilisé pour implémenter un système à état.

Itérateur

• Permet de parcourir les éléments d'une collection sans révéler la représentation interne

Médiateur

• Sert à réduire les dépendances de communications entre les objets.
• Celui ci force la collaboration par le biais d'un médiateur.

Mémento

• Permet de sauvegarder et de rétablir l'état précédent d'un objet sans en divulguer les détails d'implémentation.

Observateur

• Implémente un mécanisme de souscription entre un observateur et un objet observé.
• L'observateur est notifié et mis à jour lors de changements dans le sujet.

Patron de méthode

• Simplifie l'écriture d'algorithmes complexes en structurant le squelette dans une méthode d'une classe mère.
• Permettre aux sous-classes de redéfinir certaines étapes de l'algorithme.

Chaîne de responsabilité

• Fait circuler les demandes dans une chaîne de handlers.
• Un handler décide s'il traite la demande ou la transmet au suivant.

Commande

• Transforme une action à effectuer en un objet autonome contenant tous les détails.
• Permet de paramétrer les méthodes, planifier l'exécution, mettre en file d'attente ou annuler les opérations.

Visiteur

• Sert à l'ajout de nouvelles opérations aux classes existantes sans modifier leurs structures.
• Utilise une classe « visitant ».
• Utile avec des classes fermées, pour lesquelles de nouveaux traitements sont souhaités.

Évolution des Design Patterns

• Avec l'évolution des langages orientés objet, de nouveaux design patterns ont émergé après la publication du livre GoF.
• Certains sont spécifiques à certains langages ou architectures.

Pourquoi Utiliser les Design Patterns

• L'utilisation des design patterns est un choix de conception avec des avantages.
• Permet l'accès à des solutions fiables et éprouvées pour les problèmes de conception objet.
• Facilite l'apprentissage de techniques pour résoudre les problèmes liés à la conception orientée objet.
• Les design patterns définissent un langage commun pour les développeurs.
• Il suffit de nommer le pattern utilisé pour communiquer son fonctionnement dans la documentation d'un projet.

Patron de création singleton

• Sert à obtenir l'instance unique d'une classe.
• La classe comporte une méthode pour obtenir elle ainsi qu'un mécanisme pour empêcher la création d'autres instances.

Recommandations en Java

• L'attribut singleton est déclaré en static dans la classe Singleton afin de stocker une instance unique en mémoire
• Le constructeur de la classe doit être privé.
• Déclarer un getter static pour renvoyer ou créer l'instance (getInstance()).
• Déclarer final (car un singleton ne doit pas avoir d'héritier).
• Avec multithread il faut s'assurer de la création d'un seul objet.
• En Java, synchronized est utilisé à l'instanciation (empêchant l'instanciation multiple même par différents threads)

Utilités du Singleton

• Il garantit l'unicité d'une instance de classe.
• Il se présente quand on veut contrôler l'accès à une ressource unique ou partagée.
• Il protège l’instance durant l’exécution du programme.
• Si des clients veulent manipuler le même objet, celui qui existe déjà est récupéré.
• Avec un constructeur normal (public)ce comportement ne peut pas être implémenter.
• Il permet d’accéder à l’objet de n’importe où dans le programme.
• Il s'agit d'un point d’accès global utilisé comme une variable globale.

Exemples d'utilisation du singleton

• Classes de configurations.
• Accès à des ressources partagées.
• Gestion des logs.

Analogie concrète

• Un gouvernement est aussi un singleton en étant l’unique instance à fonctionner dans un pays.

Avantages

• Il garantit l’unicité de l’instance de la classe.
• Il a un point d’accès global à l’instance.
• L’objet du singleton est uniquement initialisé à sa première demande.

Désavantages

• Requiert une gestion unique de multithread.
• Il en résulte que le singleton dans plusieurs exemples à la fois peut s'avérer difficile.

Patron de création: Fabrique (Factory)

• Objectif: Créer des familles d'objets à partir de types abstraits.
• But: Séparer la création et l'utilisation des objets dérivés d'une classe mère.
• Particularité: L'objet retourné est de la classe mère, mais les traitements sont ceux de l'instance créée.
• Avantage: Créer des objets sans exposer la logique au client, en utilisant une classe commune.

Modèle de fabrique simple

• Classes impliquées:
  • AbstractFactory: Contient les méthodes pour créer un produit.
  • ProductFactoryX: Crée le produit X souhaité.
  • AbstractProduct: Contient les méthodes pour réaliser les actions sur le produit (peut être une interface).
  • ProductX: Le produit créé par la fabrique X.

Utilité de la fabrique (Factory)

• Elle est utilisée quand le client détermine le type d'objet à créer à l'exécution.
• Caractéristique: Le code du constructeur est ainsi plus évolutif et indépendant.
• Permet l'ajout d'un nouveau produit par ajout d'une sous-classe de la fabrique abstraite et la redéfinition la méthode de fabrique (createProduct).
• Il est nécessaire de centraliser la création des objets.

Remarques sur le modèle

• getproductx() retourne l'instance du produit créé par la fabrique avec le renvoi de ProductX()
• La méthode createProduct() renvoie un objet de type du produit souhaité
• Notamment lorsque plusieurs produits abstraits regroupent des sous-produits
• chaque ProductFactory va instancier le produit concret correspondant.
• Abstract Factory en est une version détaillée.

Fonctionnement général

• Le customer passe par la classe Factory de façon abstraite, puis pour la manipulation il utilise la classe Abstract Produit.

ShapeFactory en Java

• La classe ShapeFactory est une usine de forme qui retourne une instance de class de forme souhaité (cercle, rectangle, carré) à partir de l'argument de chaîne passé

Points forts :

• Les méthodes de création d’objets sont séparée, mais gardent tout les code des créations.
• Possibilité de rajouter toute sortes de produits est maintenu.
• La fabrique est une spécialisation du patron de méthode, et peut y être intégrée.

Points faibles :

• Peut devenir plus complexe quand tu utilise nombreuse sous-classes pour la mis en place du design pattern.
• Les patron de code devrais mieux être mis en place pour utilisation des codes de fabric.

Patron de création : Builder (Monteur)

• Objectif: Simplifier la création d'objets complexes avec un constructeur complexe.
• Solution: Utiliser un monteur pour créer les objets étape par étape avec les paramètres nécessaires.

Illustration

• Problème: Construire une voiture avec divers attributs (portes, vitres, moteur, etc.), certains facultatifs.
• Solution: Extraire le code dans une classe Builder, avec des méthodes pour construire les parties.
• Classe Director: Définit l'ordre d'exécution des étapes de construction.

Classes impliquées (Version 1)

• Builder: Classe de base du monteur, définissant les étapes communes de la construction.
• ConcreteBuilder: Implémente les étapes pour les représentations spécifiques du produit, contient un attribut du type de produit à monter.
• Director: Gère l'ordonnancement des étapes (facultatif, utilisé pour placer et réutiliser les routines de construction).

Version 2 (avec Interface)

• le patron de création est l'instanciation client, on instancie des director , il y passe paramètre un builder
• On appelle ensuite la méthode de construction des objets par étape ( make à partir du modele 2)

Etapes finales et utilité

• L'étape finale : consiste à récupérer l'objet construit, à l'aide de la version getResult et de type produit est la phase finale.
• L'intérêt d'éviter la construction complexe des paramètres, car plusieurs constructeurs peuvent demander plus de fonctionnalités.

Intérêts

• Utilser une construction plus adapté pour les étapes de ressemblance des étapes par les representations du produits.
• Le monteur permet une manipulation plus dynamique et peut appeler des étapes de manières recursives

Points forts:

• Désaccord complexe : des codes de création et la logique des produits.
• Permet une réutilisation sans réprésentation de produits, car cela permet d'une construction simple.

Points négatif :

• Cela nécessitent les créations de beaucoup de nouvelles classes.

Prototypes

• Objectifs : Le patterns permet d'envoyer des copies d'objets de manières plus rapide.
• On utilise une class de prototypes avec des méthodes de clonage.

Modèle:

• Pour procéder des copies d'un nouveaux objet , il faut les modèles concret .

• Le client ayants clonage , il peut faire appelle à la méthode clone.

• Les classes impliqués dans ces modèles sont des class abstraite de type modèle.

• Classe conc rètes; specialise leur methodes et cela renvoie une class concerné.

• Les etapes de la methode clone dans un class consistees a créer une instance existante.

Utilisation

• Cela permet un conséquation et simplification plus facile.
• Eviter la redondance des codes d'initialisations.

Les points forts :

• la clonage peut s'avérer utile pour structuré une copie en arboresence