Différences

Ci-dessous, les différences entre deux révisions de la page.

--- helloworld:design_pattern [2019/10/18 14:57] – [Divers] : ajout de "Décorateur" root
+++ helloworld:design_pattern [2020/03/02 22:24] (Version actuelle) – Ajout d'un lien pour État root
@@ Ligne 1: / Ligne 1: @@
-=====Architecture=====
+=====Gang of four====
-[[helloworld:design_pattern:mvc|MVC]] : modèle-vue-contrôleur : séparation du code en 3 zones (fonctions métiers, IHM, contrôleur des demandes de modification de l'IHM vers les fonctions métier). Utilise le pattern [[helloworld:design_pattern:observer|Observateur]].
-[[helloworld:design_pattern:couches|Couches / Architecture n tiers]] : le code est décomposé en couches et chaque couche ne peut communiquer qu'avec celles du dessus ou du dessous.
+[[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:microkernel|Microkernel / Plug-In Architecture]] : architecture modulable.
+{{ :helloworld:design_pattern:design_patterns_-_elements_of_reusable_object-oriented_software.pdf |Design Patterns - Elements of reusable object-oriented software}}
-=====Gestion des événements=====
+====Création====
-[[helloworld:design_pattern:observer|Observateur]] : plusieurs observateurs espionnant les modifications d'un observé. Ici, les observateurs connaissent l'observé et l'observé connait les observateurs.
+  * [[helloworld:design_pattern:singleton|Singleton]]
+Il est utilisé quand une classe ne peut être instanciée qu'une seule fois.
+  * Prototype
+Plutôt que de créer un objet de A à Z c'est à dire en appelant un constructeur, puis en configurant la valeur de ses attributs, ce patron permet de créer un nouvel objet par recopie d'un objet existant.
+  * Fabrique
+Ce patron permet la création d'un objet dont la classe dépend des paramètres de construction (un nom de classe par exemple).
+  * [[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.
-[[helloworld:design_pattern:publish_subscribe|Publier-souscrire]] : les observateurs espionnent des événements et non plus des [[helloworld:design_pattern:observer|observés]]. Les observateurs et les observés ne se connaissent pas.
+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
+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.
-[[helloworld:design_pattern:reactor|Reactor]] : proche de l'[[helloworld:design_pattern:observer|observateur]], ici, Reactor ne transmet pas de message, il exécute directement la méthode.
+====Structure====
+  * [[helloworld:design_pattern:pont|Pont]]
+Découple l'interface d'utilisation de l'API de l'implémentation.
+  * Objet [[helloworld:design_pattern:composite|Composite]]
+Une instance d'une classe peut contenir une ou plusieurs autres instances d'une même classe ou interface commune (récursion).
+  * 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.
+  * Adaptateur
+Ce patron permet d'adapter une interface existante à une autre interface.
+  * Façade
+Ce patron de conception permet de simplifier l'utilisation d'une interface complexe, généralement répartie sur plusieurs classes.
+  * [[helloworld:design_pattern:proxy|Proxy]]
+Passer par un objet intermédiaire avant d'atteindre le bon.
-=====Divers=====
+Il utilise la composition.
-[[helloworld:design_pattern:singleton|Singleton]] : une seule instance d'une classe.
+  * [[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:bean:java|Bean]] : stockage d'information.
+Il utilise l’agrégation.
-[[helloworld:design_pattern:wrapper|Adaptateur / Enveloppe / Wrapper]] : interface commune et homogène.
+====Comportement====
+  * [[helloworld:design_pattern:chain_of_responsibility|Chaîne de responsabilité]]
+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.
+  * [[helloworld:design_pattern:command|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éter un langage spécialisé.
+  * Itérateur
+Parcourir un ensemble d'objets à l'aide d'un objet de contexte (curseur).
-[[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.
+  * Mémento
+Mémoriser l'état d'un objet pour pouvoir le restaurer ensuite.
-[[helloworld:design_pattern:fabrique_abstraite|Fabrique abstraite]] : créer une instance mais ne recevoir que son interface.
+  * [[helloworld:design_pattern:observer|Observateur]] / [[helloworld:design_pattern:publish_subscribe|Publier-souscrire]] / [[helloworld:design_pattern:reactor|Reactor]]
+Intercepter un évènement pour le traiter.
-[[helloworld:design_pattern:visiteur|Visiteur]] : séparer le traitement des données et leur stockage.
+L'observateur : plusieurs observateurs espionnant les modifications d'un observé. Ici, les observateurs connaissent l'observé et l'observé connait les observateurs.
-[[helloworld:design_pattern:proxy|Proxy]] : passer par un objet intermédiaire avant d'atteindre le bon.
+PubSub / Publier-souscrire : les observateurs s'abonnent à des événements et non plus des observés. Les observateurs et les observés ne se connaissent pas.
-[[helloworld:design_pattern:request_response|Requêteur]] : masquer la nécessité d'ouvrir et de fermer une connexion.
+Reactor : proche de l'observateur, ici, Reactor ne transmet pas de message, il exécute directement la méthode.
-[[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, …).
+  * Médiateur
+Réduire les dépendances entre un groupe de classes en utilisant une classe Médiateur comme intermédiaire de communication.
-[[helloworld:design_pattern:serialize|Sérialisation ou Marshalling]] : (pattern ?)convertir des données en format binaire et inversement.
+Cela peut-être implémenté par le pattern observateur si tous les objets sont indépendants.
-[[helloworld:design_pattern:invocateur|Invocateur]] : démarrer et arrêter un service.
+  * [[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: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: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, …).
-[[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.
+  * Patron de méthode
+Définir un modèle de méthode en utilisant des méthodes abstraites.
+  * [[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.
-[[helloworld:design_pattern:chain_of_responsibility|Chaîne de responsabilité]] : liste chaînée d'intercepteurs.
+=====Architecture=====
+[[helloworld:design_pattern:mvc|MVC]] : modèle-vue-contrôleur : séparation du code en 3 zones (fonctions métiers, IHM, contrôleur des demandes de modification de l'IHM vers les fonctions métier). Utilise le pattern [[helloworld:design_pattern:observer|Observateur]].
+[[helloworld:design_pattern:couches|Couches / Architecture n tiers]] : le code est décomposé en couches et chaque couche ne peut communiquer qu'avec celles du dessus ou du dessous.
+[[helloworld:design_pattern:microkernel|Microkernel / Plug-In Architecture]] : architecture modulable.
+=====Divers=====
+[[helloworld:design_pattern:bean:java|Bean]] : stockage d'information.
+[[helloworld:design_pattern:request_response|Requêteur]] : masquer la nécessité d'ouvrir et de fermer une connexion.
+[[helloworld:design_pattern:serialize|Sérialisation ou Marshalling]] : (pattern ?)convertir des données en format binaire et inversement.
+[[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_decorator|Décorateur]] : permet d'exécuter du code avant et après l'appel d'une fonction ou des fonctions d'une classe.