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

J'apprends GoF Java Design Patterns et je veux en voir des exemples réels. Quels sont de bons exemples de ces modèles de conception dans les bibliothèques principales de Java?

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

Modèles de création

Usine abstraite ^{_{(reconnaissable par les méthodes de création renvoyant l'usine elle-même qui à son tour 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()

Builder ^{_{(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()(aussi CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBufferet 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 les méthodes de création renvoyant une implémentation d'un 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) (Renvoie un objet singleton par protocole)
• java.util.EnumSet#of()
• javax.xml.bind.JAXBContext#createMarshaller() et d'autres méthodes similaires

Prototype ^{_{(reconnaissable par les méthodes de création renvoyant une instance différente de lui-même 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 la même instance (généralement d'elle-même) à chaque fois)}}

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

Modèles structurels

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

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

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

• Personne ne me vient encore à l'esprit. Un exemple fictif serait celui new LinkedHashMap(LinkedHashSet<K>, List<V>)qui retourne une carte liée non modifiable qui ne clone pas les éléments, mais les utilise . Les java.util.Collections#newSetFromMap()et singletonXXX()méthodes vient cependant à proximité.

Composite ^{_{(reconnaissable par les méthodes comportementales prenant une instance du même type abstrait / interface dans une structure arborescente)}}

• java.awt.Container#add(Component) (pratiquement partout Swing ainsi)
• javax.faces.component.UIComponent#getChildren() (pratiquement partout dans l'interface utilisateur JSF donc)

Décorateur ^{_{(reconnaissable par les méthodes de création prenant une instance du même type abstrait / interface qui ajoute un comportement supplémentaire)}}

• Toutes les sous - classes de java.io.InputStream, OutputStream, Readeret Writeront un constructeur de prendre une instance de même type.
• java.util.Collections, Les checkedXXX(), synchronizedXXX()et les unmodifiableXXX()méthodes.
• javax.servlet.http.HttpServletRequestWrapper et HttpServletResponseWrapper
• javax.swing.JScrollPane

Façade ^{_{(reconnaissable par les méthodes comportementales qui utilisent en interne des instances de différents types d'abrégés / d'interfaces indépendants)}}

• javax.faces.context.FacesContext, Il utilise en interne entre autres les types d'interface abstrait / LifeCycle, ViewHandler, NavigationHandleret bien d' autres sans que l'utilisateur final doit inquiéter à ce sujet (qui sont cependant par injection dérogation possible ).
• javax.faces.context.ExternalContext, Qui utilise en interne ServletContext, HttpSession, HttpServletRequest, HttpServletResponse, etc.

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

• java.lang.Integer#valueOf(int)(aussi Boolean, Byte, Character, Short, Longet BigDecimal)

Proxy ^{_{(reconnaissable par les méthodes de création qui renvoie une implémentation du type abstrait / interface donné qui à son tour délègue / utilise une implémentation différente du type abstrait / interface donné)}}

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

Modèles comportementaux

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

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

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

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

Interpréteur ^{_{(reconnaissable par les méthodes comportementales renvoyant une instance / un type structurellement différent de l'instance / du type donné; notez que l'analyse / le formatage ne fait pas partie du modèle, déterminant le modèle et comment l'appliquer)}}

• 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 les méthodes comportementales renvoyant séquentiellement des instances d'un type différent à partir d'une file d'attente)}}

• Toutes les implémentations de java.util.Iterator(donc entre autres aussi java.util.Scanner!).
• Toutes les implémentations de java.util.Enumeration

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

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

Memento ^{_{(reconnaissable par les méthodes comportementales qui modifient en interne l'état de l' instance entière )}}

• java.util.Date(les méthodes setter font cela, Dateest représenté en interne par une longvaleur)
• Toutes les implémentations de java.io.Serializable
• Toutes les implémentations de javax.faces.component.StateHolder

Observer (ou Publish / Subscribe) ^{_{(reconnaissable par les méthodes comportementales qui invoquent une méthode sur une instance d' un autre type abstrait / interface, selon son propre état)}}

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

État ^{_{(reconnaissable par les méthodes comportementales qui modifient son comportement en fonction de l'état de l'instance qui peut être contrôlé en externe)}}

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

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

• java.util.Comparator#compare(), exécuté par entre autres Collections#sort().
• javax.servlet.http.HttpServlet, la service()et toutes les doXXX()méthodes prennent HttpServletRequestet HttpServletResponsel'implémenteur doit les traiter (et non les saisir comme variables d'instance!).
• javax.servlet.Filter#doFilter()

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

• Toutes les méthodes de non abstraites java.io.InputStream, java.io.OutputStream, java.io.Readeret java.io.Writer.
• Toutes les méthodes non abstraites de java.util.AbstractList, java.util.AbstractSetet java.util.AbstractMap.
• javax.servlet.http.HttpServlet, toutes les doXXX()méthodes envoient par défaut une erreur HTTP 405 "Méthode non autorisée" à la réponse. Vous êtes libre d'implémenter aucun ou aucun d'entre eux.

Visiteur ^{_{(reconnaissable par deux types d' abrégés / d'interfaces différents qui ont défini des méthodes qui prennent chacun l' autre type d' abrégé / d'interface; l'un appelle en fait la méthode de l'autre et l'autre exécute la stratégie souhaitée dessus)}}

• 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

1. Modèle d'observateur tout au long du swing ( Observable, Observer)
2. MVC aussi en swing
3. Motif adaptateur: InputStreamReader et OutputStreamWriter REMARQUE: ContainerAdapter, ComponentAdapter, FocusAdapter, KeyAdapter, MouseAdaptersont pas des adaptateurs; ce sont en fait des objets nuls. Mauvais choix de nom par Sun.
4. Modèle de décorateur ( BufferedInputStreampeut décorer d'autres flux tels que FilterInputStream)
5. AbstractFactory Pattern pour l'AWT Toolkit et les classes de look-and-feel enfichables Swing
6. java.lang.Runtime#getRuntime() est Singleton
7. ButtonGroup pour motif Mediator
8. Action, AbstractAction peut être utilisé pour différentes représentations visuelles pour exécuter le même code -> Modèle de commande
9. Chaînes internées ou CellRender dans JTable pour Flyweight Pattern (Pensez également à différents pools - Pools de threads, pools de connexions, pools d'objets EJB - Flyweight concerne vraiment la gestion des ressources partagées)
10. Le modèle d'événement Java 1.0 est un exemple de chaîne de responsabilité, tout comme les filtres de servlet.
11. Modèle d'itérateur dans Collections Framework
12. Les conteneurs imbriqués dans AWT / Swing utilisent le modèle Composite
13. Les gestionnaires de mise en page dans AWT / Swing sont un exemple de stratégie

et bien d'autres je suppose

1. Flyweight est utilisé avec certaines valeurs de Byte, Short, Integer, Long et String.
2. La façade est utilisée à de nombreux endroits, mais la plus évidente est les interfaces de script.
3. Singleton - java.lang.Runtime vient à l'esprit.
4. Abstract Factory - Également script et API JDBC.
5. Commande - Annuler / Rétablir de TextComponent.
6. Interprète - RegEx (java.util.regex. ) Et SQL (java.sql. API ).
7. Prototype - Je ne suis pas sûr à 100% de ce nombre, mais je pense que la clone()méthode peut être utilisée à cette fin.

RMI est basé sur Proxy.

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

1. Abstract Factory: les interfaces java.sql obtiennent toutes leurs implémentations concrètes de JDBC JAR lorsque le pilote est enregistré.
2. Générateur: 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. Adapter: classes d'adaptateurs 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: partout dans le package java.io.
10. Façade: ExternalContext se comporte comme une façade pour effectuer des cookies, une portée 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. Itérateur: interface java.util.Iterator; ne peut pas être plus clair que cela.
17. Médiateur: JMS?
18. Mémento:
19. Observateur: java.util.Observer/Observable (mal fait, cependant)
20. Etat:
21. Stratégie:
22. Modèle:
23. Visiteur:

Je ne peux pas penser à des exemples en Java pour 10 sur 23, mais je vais voir si je peux faire mieux demain. C'est à ça que sert l'édition.

Le motif Abstract Factory est utilisé à divers endroits. Par exemple, DatagramSocketImplFactory, PreferencesFactory. Il y en a beaucoup plus --- recherchez dans Javadoc des interfaces qui ont le mot "Factory" dans leur nom.

Il existe également de nombreuses instances du modèle Factory.

Même si je suis en quelque sorte une horloge cassée avec celle-ci, l'API Java XML utilise beaucoup Factory. Je veux juste dire 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.

• Méthode d'usine

java.util.Collection # Iterator est un bon exemple de méthode d'usine. En fonction de la sous-classe concrète de Collection que vous utilisez, elle créera une implémentation Iterator. Parce que la superclasse Factory (Collection) et l'itérateur créé sont des interfaces, il est parfois confondu avec AbstractFactory. La plupart des exemples pour 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 d'usine est réduite et l'usine utilise d'autres moyens pour choisir le produit à retourner.

• Usine abstraite

Une usine abstraite a plusieurs méthodes d'usine, chacune créant un produit différent. Les produits fabriqués par une seule usine sont destinés à être utilisés ensemble (il est préférable que votre imprimante et vos cartouches proviennent de la même usine (abstraite)). Comme mentionné dans les réponses ci-dessus, les familles de composants AWT GUI, différentes d'une plateforme à l'autre, en sont un exemple (bien que sa mise en œuvre diffère de la structure décrite dans Gof).