Exemples de modèles de conception GoF dans les bibliothèques principales Java

Question

J'apprends le GoF Java Design Patterns et je souhaite en voir des exemples concrets. Quels sont quelques bons exemples de ces modèles de conception dans les bibliothèques principales de Java?

Answer 1

Vous pouvez trouver un aperçu de nombreux modèles de conception dans Wikipedia . Il mentionne également quels modèles sont mentionnés par le GoF. Je vais les résumer ici et essayer d’affecter autant d’implémentations de modèles que possible, que ce soit dans les API Java SE et Java EE.

---

Modèles de création

Fabrique abstraite ^{_{(reconnaissable par les méthodes de création renvoyant la fabrique elle-même qui peut être utilisée pour créer un autre type abstrait/interface)}}

• javax.xml.parsers.DocumentBuilderFactory#newInstance()
• javax.xml.transform.TransformerFactory#newInstance()
• javax.xml.xpath.XPathFactory#newInstance()

Générateur ^{_{(reconnaissable par les méthodes de création renvoyant l'instance elle-même)}}

• Java.lang.StringBuilder#append() (non synchronisé)
• Java.lang.StringBuffer#append() (synchronisé)
• Java.nio.ByteBuffer#put() (également sur CharBuffer , ShortBuffer , IntBuffer , LongBuffer , FloatBuffer et DoubleBuffer )
• javax.swing.GroupLayout.Group#addComponent()
• Toutes les implémentations de Java.lang.Appendable
• Java.util.stream.Stream.Builder

Méthode d'usine ^{_{(reconnaissable par des méthodes de création renvoyant une implémentation de type abstrait/interface)}}

• Java.util.Calendar#getInstance()
• Java.util.ResourceBundle#getBundle()
• Java.text.NumberFormat#getInstance()
• Java.nio.charset.Charset#forName()
• Java.net.URLStreamHandlerFactory#createURLStreamHandler(String) (Retourne un objet singleton par protocole)
• Java.util.EnumSet#of()
• javax.xml.bind.JAXBContext#createMarshaller() et autres méthodes similaires

Prototype ^{_{(reconnaissable par les méthodes de création renvoyant une instance différente == avec les mêmes propriétés)}}

• Java.lang.Object#clone() (la classe doit implémenter Java.lang.Cloneable )

Singleton ^{_{(reconnaissable par les méthodes de création renvoyant l'instance same (généralement d'elle-même) à chaque fois)}}

• Java.lang.Runtime#getRuntime()
• Java.awt.Desktop#getDesktop()
• Java.lang.System#getSecurityManager()

---

Structures structurelles

Adaptateur ^{_{(reconnaissable par des méthodes de création prenant une instance de différent type abstrait/interface et renvoyant une implémentation de type propre/autre type abstrait/interface qui décore/substitue l'instance donnée)}}

• Java.util.Arrays#asList()
• Java.util.Collections#list()
• Java.util.Collections#enumeration()
• Java.io.InputStreamReader(InputStream) (retourne un Reader)
• Java.io.OutputStreamWriter(OutputStream) (retourne un Writer)
• javax.xml.bind.annotation.adapters.XmlAdapter#marshal() et #unmarshal()

Pont ^{_{(reconnaissable par des méthodes de création prenant une instance de différent type abstrait/interface et renvoyant une implémentation de son propre type abstrait/interface qui délégués/utilise l'instance donnée)}}

• Aucun ne me vient à l'esprit pour l'instant. Un exemple fictif serait new LinkedHashMap(LinkedHashSet<K>, List<V>) qui retourne une carte liée non modifiable qui ne clone pas les éléments, mais utilise eux. Les méthodes Java.util.Collections#newSetFromMap() et singletonXXX() se rapprochent toutefois.

Composite ^{_{(reconnaissable par des méthodes comportementales prenant une instance de same abstrait/type d'interface dans une structure arborescente)}}

• Java.awt.Container#add(Component) (pratiquement sur tout le Swing donc)
• javax.faces.component.UIComponent#getChildren() (pratiquement sur toute l'interface utilisateur JSF)

Décorateur ^{_{(reconnaissable par des méthodes créatives prenant une instance de same abstrait/type d'interface qui ajoute un comportement supplémentaire)}}

• Toutes les sous-classes de Java.io.InputStream , OutputStream , Reader et Writer avoir un constructeur prenant une instance du même type.
• Java.util.Collections , le checkedXXX() , synchronizedXXX() et unmodifiableXXX() méthodes.
• javax.servlet.http.HttpServletRequestWrapper et HttpServletResponseWrapper
• javax.swing.JScrollPane

Façade ^{_{(reconnaissable par des méthodes comportementales qui utilisent en interne des instances de différent types abstraits indépendants/interfaces)}}

• javax.faces.context.FacesContext , il utilise en interne, entre autres, les types abstrait/interface LifeCycle , ViewHandler , NavigationHandler et bien d’autres encore sans que l’utilisateur final ait à s’en soucier (qui sont toutefois écrasables par injection).
• javax.faces.context.ExternalContext , qui utilise en interne ServletContext , HttpSession , HttpServletRequest , HttpServletResponse , etc.

poids mouche ^{_{(reconnaissable par les méthodes de création renvoyant une instance en cache, un peu l'idée "multiton")}}

• Java.lang.Integer#valueOf(int) (également sur Boolean , Byte , Character , Short , Long et BigDecimal )

Proxy ^{_{(reconnaissable par des méthodes creational qui retourne une implémentation de type abstrait/interface donné qui délégués/utilise a différent implémentation donnée type abstrait/interface)}}

• Java.lang.reflect.Proxy
• Java.rmi.*
• javax.ejb.EJB ( explication ici )
• javax.inject.Inject ( explication ici )
• javax.persistence.PersistenceContext

---

Patterns comportementaux

Chaîne de responsabilité ^{_{(reconnaissable par des méthodes comportementales qui (indirectement) invoquent la même méthode dans autre implémentation de same type abstrait/interface dans une file d'attente)}}

• Java.util.logging.Logger#log()
• javax.servlet.Filter#doFilter()

Commande ^{_{(reconnaissable par des méthodes comportementales dans un type abstrait/interface qui appelle une méthode dans une implémentation de type différent abstrait/interface qui a été encapsulé par l'implémentation de la commande lors de sa création)}}

• Toutes les implémentations de Java.lang.Runnable
• Toutes les implémentations de javax.swing.Action

interprète ^{_{(reconnaissable par les méthodes comportementales renvoyant une structurellement instance/type différente de l'instance/du type donné; notez que l'analyse/la mise en forme ne fait pas partie du modèle, ce qui détermine le modèle et comment l'appliquer c'est)}}

• Java.util.Pattern
• Java.text.Normalizer
• Toutes les sous-classes de Java.text.Format
• Toutes les sous-classes de javax.el.ELResolver

Itérateur ^{_{(reconnaissable par des méthodes comportementales renvoyant séquentiellement les instances d'un type différent à partir d'une file d'attente)}}

• Toutes les implémentations de Java.util.Iterator (donc parmi d'autres également Java.util.Scanner !).
• Toutes les implémentations de Java.util.Enumeration

médiateur ^{_{(reconnaissable par des méthodes comportementales prenant une instance de type abstrait/interface différent (en utilisant généralement le modèle de commande) qui délègue/utilise l'instance donnée)}}

• Java.util.Timer (toutes les méthodes scheduleXXX())
• Java.util.concurrent.Executor#execute()
• Java.util.concurrent.ExecutorService (les méthodes invokeXXX() et submit())
• Java.util.concurrent.ScheduledExecutorService (toutes les méthodes scheduleXXX())
• Java.lang.reflect.Method#invoke()

Mémento ^{_{(reconnaissable par des méthodes comportementales qui changent en interne l'état de l'instance whole )}}

• Java.util.Date (les méthodes de définition le font, Date est représenté en interne par une valeur long)
• Toutes les implémentations de Java.io.Serializable
• Toutes les implémentations de javax.faces.component.StateHolder

Observateur (ou publication/abonnement) ^{_{(reconnaissable par des méthodes comportementales qui invoquent une méthode sur une instance de autre type abstrait/interface, en fonction de son propre état)}}

• Java.util.Observer / Java.util.Observable (rarement utilisé dans le monde réel)
• Toutes les implémentations de Java.util.EventListener (pratiquement sur tout le Swing donc)
• javax.servlet.http.HttpSessionBindingListener
• javax.servlet.http.HttpSessionAttributeListener
• javax.faces.event.PhaseListener

Etat ^{_{(reconnaissable par des méthodes comportementales qui changent de comportement en fonction de l'état de l'instance pouvant être contrôlé de manière externe)}}

• javax.faces.lifecycle.LifeCycle#execute() (contrôlé par FacesServlet , le comportement dépend de la phase actuelle (état) du cycle de vie de JSF)

Stratégie ^{_{(reconnaissable par des méthodes comportementales dans un type abstrait/interface qui invoque une méthode dans une implémentation d'un différent type abstrait/interface qui a été transmis comme argument de méthode dans l'implémentation de la stratégie)}}

• Java.util.Comparator#compare() , exécuté entre autres Collections#sort().
• javax.servlet.http.HttpServlet , les méthodes service() et toutes les méthodes doXXX() prennent HttpServletRequest et HttpServletResponse et le réalisateur doit les traiter (et ne pas les obtenir en tant que variables d'instance!).
• javax.servlet.Filter#doFilter()

Méthode de modèle ^{_{(reconnaissable par des méthodes comportementales qui ont déjà un comportement "par défaut" défini par un type abstrait)}}

• Toutes les méthodes non abstraites de Java.io.InputStream , Java.io.OutputStream , Java.io.Reader et Java.io.Writer .
• Toutes les méthodes non abstraites de Java.util.AbstractList , Java.util.AbstractSet et Java.util.AbstractMap .
• javax.servlet.http.HttpServlet , toutes les méthodes doXXX() envoie par défaut une erreur HTTP 405 "Méthode non autorisée" à la réponse. Vous êtes libre de n'en implémenter aucune ou aucune.

Visiteur ^{_{(reconnaissable par deux différent types abstraits/interfaces dont les méthodes sont définies et qui prennent chacun autres types abstraits/interfaces; celui en fait appelle la méthode de l'autre et l'autre exécute la stratégie souhaitée)}}

• javax.lang.model.element.AnnotationValue et AnnotationValueVisitor
• javax.lang.model.element.Element et ElementVisitor
• javax.lang.model.type.TypeMirror et TypeVisitor
• Java.nio.file.FileVisitor et SimpleFileVisitor
• javax.faces.component.visit.VisitContext et VisitCallback

Answer 2

1. Motif d'observateur pendant toute la durée du mouvement (Observable, Observer)
2. MVC aussi en swing
3. Modèle d'adaptateur: InputStreamReader et OutputStreamWriter REMARQUE: ContainerAdapter, ComponentAdapter, FocusAdapter, KeyAdapter, MouseAdapter sont non adaptateurs; ce sont en fait des objets nuls. Mauvais choix de nommage par Sun.
4. Motif de décorateur (BufferedInputStream peut décorer d'autres flux tels que FilterInputStream)
5. Modèle AbstractFactory pour la classe AWT Toolkit et les classes de style et de fonctionnalité enfichables Swing
6. Java.lang.Runtime#getRuntime() est Singleton
7. ButtonGroup pour le motif Mediator
8. Action, AbstractAction peut être utilisé pour différentes représentations visuelles afin d'exécuter le même code -> Modèle de commande
9. Interned Strings ou CellRender dans JTable pour le modèle Flyweight (Pensez également à différents pools - pools de threads, pools de connexion, pools d'objet EJB - Flyweight concerne réellement la gestion des ressources partagées).
10. Le modèle d'événement Java 1.0 est un exemple de chaîne de responsabilité, au même titre que les filtres de servlet.
11. Motif Itérateur dans le cadre des collections
12. Les conteneurs imbriqués dans AWT/Swing utilisent le modèle Composite.
13. Les gestionnaires de disposition dans AWT/Swing sont un exemple de stratégie

et beaucoup plus je suppose

Answer 3

1. Poids mouche est utilisé avec certaines valeurs de Byte, Short, Integer, Long et String.
2. Façade est utilisé dans de nombreux endroits, mais le plus évident est les interfaces de script.
3. Singleton - Java.lang.Runtime vient à l'esprit.
4. Usine abstraite - Aussi Script et API JDBC.
5. Commander - Annuler/Rétablir TextComponent.
6. Interprète - RegEx (Java.util.regex .) et SQL (Java.sql.).
7. Prototype - Je ne suis pas sûr à 100% que cela compte, mais je pense que la méthode clone() peut être utilisée à cette fin.

Answer 4

RMI est basé sur le proxy.

Il devrait être possible d'en citer un pour la plupart des 23 modèles de GoF:

1. Abstract Factory: Les interfaces Java.sql obtiennent toutes leurs implémentations concrètes à partir du fichier JAR JDBC lors de l’enregistrement du pilote.
2. Constructeur: Java.lang.StringBuilder.
3. Méthode d'usine: usines XML, entre autres.
4. Prototype: Peut-être clone (), mais je ne suis pas sûr de l'acheter.
5. Singleton: Java.lang.System
6. Adaptateur: classes d'adaptateur dans Java.awt.event, par exemple WindowAdapter.
7. Bridge: Classes de collection dans Java.util. Liste implémentée par ArrayList.
8. Composite: Java.awt. Java.awt.Component + Java.awt.Container
9. Décorateur: Dans tout le package Java.io.
10. Façade: ExternalContext se comporte comme une façade permettant d'exécuter des cookies, une étendue de session et des opérations similaires.
11. Poids mouche: entier, caractère, etc.
12. Proxy: package Java.rmi
13. Chaîne de responsabilité: filtres de servlet
14. Commande: éléments de menu Swing
15. Interprète: Non, directement dans JDK, mais JavaCC l’utilise certainement.
16. Iterator: interface Java.util.Iterator; ne peut pas être plus clair que cela.
17. Médiateur: JMS?
18. Mémento:
19. Observer: Java.util.Observer/Observable (mal fait cependant)
20. Etat:
21. Stratégie:
22. Modèle:
23. Visiteur:

Je ne peux pas penser aux exemples de Java pour 10 des 23, mais je verrai si je peux faire mieux demain. C'est à quoi sert l'édition.

Answer 5

Le motif Abstract Factory est utilisé à divers endroits. Par exemple, DatagramSocketImplFactory, PreferencesFactory. Il en existe beaucoup d'autres --- recherchez dans le Javadoc des interfaces portant le mot "Factory" dans leur nom.

En outre, il existe également quelques exemples du motif Factory.

Answer 6

Bien que je sois en quelque sorte une horloge cassée avec celle-ci, Java API XML utilise beaucoup Factory. Je veux dire juste regarder ceci:

Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(source);
String title = XPathFactory.newInstance().newXPath().evaluate("//title", doc);

...et ainsi de suite.

De plus, divers tampons (StringBuffer, ByteBuffer, StringBuilder) utilisent Builder.

Answer 7

• méthode d'usine

Java.util.Collection # Iterator est un bon exemple de méthode Factory. En fonction de la sous-classe concrète de Collection que vous utilisez, cela créera une implémentation d'Iterator. Étant donné que la superclasse Factory (Collection) et l'Iterator créés sont des interfaces, il est parfois confondu avec AbstractFactory. La plupart des exemples de AbstractFactory dans la réponse acceptée (BalusC) sont des exemples de Factory , une version simplifiée de Factory Method, qui ne fait pas partie des modèles GoF d'origine. Dans Facory, la hiérarchie des classes fabrique est réduite et la fabrique utilise d'autres moyens pour choisir le produit à retourner.

• Usine abstraite

Une fabrique abstraite dispose de plusieurs méthodes, chacune créant un produit différent. Les produits fabriqués par une usine sont destinés à être utilisés ensemble (votre imprimante et vos cartouches doivent provenir de la même usine (abstraite)). Comme mentionné dans les réponses ci-dessus, les familles de composants d'interface graphique AWT, qui diffèrent d'une plate-forme à l'autre, en sont un exemple (bien que sa mise en œuvre diffère de la structure décrite dans Gof).