| Les deux révisions précédentesRévision précédenteProchaine révision | Révision précédente |
| helloworld:design_pattern [2020/02/09 19:32] – WIP : refactoring root | helloworld:design_pattern [2020/03/02 22:24] (Version actuelle) – Ajout d'un lien pour État root |
|---|
| =====Gang of four==== | =====Gang of four==== |
| | |
| | [[https://rpouiller.developpez.com/tutoriel/java/design-patterns-gang-of-four/|Design Patterns du Gang of Four appliqués à Java]] {{ :helloworld:design_pattern:designpatternsgof.pdf |Archive du 08/11/2019 le 10/02/2020}} |
| | |
| | {{ :helloworld:design_pattern:design_patterns_-_elements_of_reusable_object-oriented_software.pdf |Design Patterns - Elements of reusable object-oriented software}} |
| | |
| ====Création==== | ====Création==== |
| * [[helloworld:design_pattern:singleton|Singleton]] | * [[helloworld:design_pattern:singleton|Singleton]] |
| * [[helloworld:design_pattern:fabrique_abstraite|Fabrique abstraite]] | * [[helloworld:design_pattern:fabrique_abstraite|Fabrique abstraite]] |
| Ce patron permet de gérer différentes fabriques concrètes à travers l'interface d'une fabrique abstraite. | Ce patron permet de gérer différentes fabriques concrètes à travers l'interface d'une fabrique abstraite. |
| | |
| | C'est la généralisation de la Fabrique. On demande la fabrication à une interface (et donc on ne sait pas à quelle classe précisément). |
| * Monteur | * Monteur |
| Ce patron permet la construction d'objets complexes en construisant chacune de ses parties sans dépendre de la représentation concrète de celles-ci. | Ce patron permet la construction d'objets complexes en construisant chacune de ses parties sans dépendre de la représentation concrète de celles-ci. |
| |
| ====Structure==== | ====Structure==== |
| * Pont | * [[helloworld:design_pattern:pont|Pont]] |
| Utilisation d'interface à la place d'implémentation spécifique pour permettre l'indépendance entre l'utilisation et l'implémentation. | Découple l'interface d'utilisation de l'API de l'implémentation. |
| * Objet composite | * Objet [[helloworld:design_pattern:composite|Composite]] |
| Ce patron permet de manipuler des objets composites à travers la même interface que les éléments dont ils sont constitués. | Une instance d'une classe peut contenir une ou plusieurs autres instances d'une même classe ou interface commune (récursion). |
| * Poids-mouche | * Poids-mouche |
| Ce patron permet de diminuer le nombre de classes créées en regroupant les classes similaires en une seule et en passant les paramètres supplémentaires aux méthodes appelées. | Ce patron permet de diminuer le nombre de classes créées en regroupant les classes similaires en une seule et en passant les paramètres supplémentaires aux méthodes appelées. |
| Ce patron permet d'adapter une interface existante à une autre interface. | Ce patron permet d'adapter une interface existante à une autre interface. |
| * Façade | * Façade |
| Ce patron de conception permet de simplifier l'utilisation d'une interface complexe. | Ce patron de conception permet de simplifier l'utilisation d'une interface complexe, généralement répartie sur plusieurs classes. |
| * Proxy | * [[helloworld:design_pattern:proxy|Proxy]] |
| Ce patron permet de substituer une classe à une autre en utilisant la même interface afin de contrôler l'accès à la classe (contrôle de sécurité ou appel de méthodes à distance). | Passer par un objet intermédiaire avant d'atteindre le bon. |
| |
| Il utilise la composition. | Il utilise la composition. |
| * Décorateur | * [[helloworld:design_pattern_decorator|Décorateur]] |
| Ce patron permet d'attacher dynamiquement de nouvelles responsabilités à un objet. | Permet d'exécuter du code avant et après l'appel d'une fonction ou des fonctions d'une classe. |
| |
| Il utilise l’agrégation. | Il utilise l’agrégation. |
| |
| ====Comportement==== | ====Comportement==== |
| * Chaîne de responsabilité | * [[helloworld:design_pattern:chain_of_responsibility|Chaîne de responsabilité]] |
| Permet de construire une chaîne de traitement d'une même requête. | Permet de construire une chaîne de traitement pour une même requête. L'implémentation peut être sous la forme d'une machine à états finis. |
| * Commande | * [[helloworld:design_pattern:command|Commande]] |
| Encapsule l'invocation d'une commande. | Exécuter une commande par l'intermédiaire d'un [[helloworld:design_pattern:command:invocateur|invocateur]]. On peut également implémenter un [[helloworld:design_pattern:command:undomanager|Undomanager]] (undo/redo). |
| * Interpréteur | * Interpréteur |
| Interpréter un langage spécialisé. | Interpréter un langage spécialisé. |
| * Itérateur | * Itérateur |
| Parcourir un ensemble d'objets à l'aide d'un objet de contexte (curseur). | Parcourir un ensemble d'objets à l'aide d'un objet de contexte (curseur). |
| * Médiateur | |
| Réduire les dépendances entre un groupe de classes en utilisant une classe Médiateur comme intermédiaire de communication. | |
| * Mémento | * Mémento |
| Mémoriser l'état d'un objet pour pouvoir le restaurer ensuite. | Mémoriser l'état d'un objet pour pouvoir le restaurer ensuite. |
| | |
| * [[helloworld:design_pattern:observer|Observateur]] / [[helloworld:design_pattern:publish_subscribe|Publier-souscrire]] / [[helloworld:design_pattern:reactor|Reactor]] | * [[helloworld:design_pattern:observer|Observateur]] / [[helloworld:design_pattern:publish_subscribe|Publier-souscrire]] / [[helloworld:design_pattern:reactor|Reactor]] |
| Intercepter un évènement pour le traiter. | Intercepter un évènement pour le traiter. |
| Reactor : proche de l'observateur, ici, Reactor ne transmet pas de message, il exécute directement la méthode. | Reactor : proche de l'observateur, ici, Reactor ne transmet pas de message, il exécute directement la méthode. |
| |
| * État | * Médiateur |
| Gérer différents états à l'aide de différentes classes. | Réduire les dépendances entre un groupe de classes en utilisant une classe Médiateur comme intermédiaire de communication. |
| * Stratégie | |
| Changer dynamiquement de stratégie (algorithme) selon le contexte. | Cela peut-être implémenté par le pattern observateur si tous les objets sont indépendants. |
| | |
| | * [[helloworld:design_pattern:etat|État]] |
| | Une classe gère différents états à l'aide de différentes classes. Il permet de créer des machines à états finis. |
| | |
| | * [[helloworld:design_pattern:strategie|Stratégie]] |
| | Changer dynamiquement de stratégie (algorithme) selon le contexte. Sur la base d'une interface commune, chaque classe fait la même chose mais avec un algorithme différent (télécharger un fichier depuis le protocole HTTPS ou FTP, choix de l'algorithme de compression, …). |
| * Patron de méthode | * Patron de méthode |
| Définir un modèle de méthode en utilisant des méthodes abstraites. | Définir un modèle de méthode en utilisant des méthodes abstraites. |
| * [[helloworld:design_pattern:visiteur|Visiteur]] | * [[helloworld:design_pattern:visiteur|Visiteur]] |
| Découpler classes et traitements, afin de pouvoir ajouter de nouveaux traitements sans ajouter de nouvelles méthodes aux classes existantes. | Découpler classes et traitements, afin de pouvoir ajouter de nouveaux traitements sans ajouter de nouvelles méthodes aux classes existantes. |
| |
| |
| =====Architecture===== | =====Architecture===== |
| =====Divers===== | =====Divers===== |
| [[helloworld:design_pattern:bean:java|Bean]] : stockage d'information. | [[helloworld:design_pattern:bean:java|Bean]] : stockage d'information. |
| |
| [[helloworld:design_pattern:composite|Composite]] : une instance d'une classe pouvant contenir une ou plusieurs autres instances d'une même classe ou interface commune. Idéale pour générer un arbre. | |
| |
| [[helloworld:design_pattern:proxy|Proxy]] : passer par un objet intermédiaire avant d'atteindre le bon. | |
| |
| [[helloworld:design_pattern:request_response|Requêteur]] : masquer la nécessité d'ouvrir et de fermer une connexion. | [[helloworld:design_pattern:request_response|Requêteur]] : masquer la nécessité d'ouvrir et de fermer une connexion. |
| |
| [[helloworld:design_pattern:strategie|Stratégie]] : sélectionner pendant l'exécution la bonne méthode. Sur la base d'une interface commune, chaque classe fait la même chose mais avec un algorithme différent (télécharger un fichier depuis le protocole HTTPS ou FTP, choix de l'algorithme de compression, …). | |
| |
| [[helloworld:design_pattern:serialize|Sérialisation ou Marshalling]] : (pattern ?)convertir des données en format binaire et inversement. | [[helloworld:design_pattern:serialize|Sérialisation ou Marshalling]] : (pattern ?)convertir des données en format binaire et inversement. |
| |
| [[helloworld:design_pattern:invocateur|Invocateur]] : démarrer et arrêter un service. | |
| |
| [[helloworld:design_pattern:command|Commande]] : exécuter une commande, éventuellement par l'intermédiaire d'un [[helloworld:design_pattern:invocateur|invocateur]]. On peut également implémenter un [[helloworld:design_pattern:command:undomanager|Undomanager]] (undo/redo). | |
| |
| [[helloworld:design_pattern:interceptor|Intercepteur]] : ajouter des fonctionnalités, avant et après l'appel d'une méthode et voir pourquoi pas appeler une autre méthode à la place. | [[helloworld:design_pattern:interceptor|Intercepteur]] : ajouter des fonctionnalités, avant et après l'appel d'une méthode et voir pourquoi pas appeler une autre méthode à la place. |
| |
| [[helloworld:design_pattern:chain_of_responsibility|Chaîne de responsabilité]] : liste chaînée d'intercepteurs. | |
| |
| [[helloworld:design_pattern_decorator|Décorateur]] : permet d'exécuter du code avant et après l'appel d'une fonction ou des fonctions d'une classe. | |
| |
| [[helloworld:design_pattern:pont|Pont]] : découple l'interface de l'implémentation. | |
