Les modèles de conception GoF sont également masqués dans les bibliothèques Java que vous utilisez le plus souvent. Il est facile d'oublier le travail quotidien chargé, mais de temps en temps, profitons du beau design qui peut être considéré comme une sorte d'art.
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Text;
...
...
//Générer un nouveau document XML en mémoire
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.newDocument();
//Générer des éléments XML
Element element = document.createElement("element");
Text text = document.createTextNode("text");
Attr attribute = document.createAttribute("attribute");
...
C'est une scène où des documents et des éléments XML sont générés en Java, mais quand je la regarde à nouveau, je me retrouve dans une interface profonde et mystérieuse.
Au lieu de créer directement une instance de XML Document, nous prenons la peine de passer par les classes DocumentBuilderFactory et DocumentBuilder. C'est une interface de 3 newXXX consécutifs rappelant l'attaque jet stream par Dom (attaque par un trio de pilotes de Dom) [^ 1] qui a affligé Gundam avec Mobile Suit Gundam, mais honnêtement, la redondance est perceptible. Ça n'a pas l'air très beau. Cependant, si vous lisez le code source caché, vous pouvez ressentir quelque chose. Explorons ensemble les sentiments du créateur.
Commençons par générer des documents et des éléments XML avec le code le plus intuitif. Notez que le code source de cette section contient des classes fictives à des fins d'illustration.
Modèle d'usine
//Le document correspond à la classe Factory de l'élément
Document document = new Document();
//Générer des éléments XML
XMLElement element = document.createXMLElement("element");
XMLText text = document.createXMLTextNode("text");
XMLAttr attribute = document.createXMLAttribute("attribute");
...
Il n'y a pas de problème particulier à cet effet uniquement. Maintenant, rendons possible la génération d'éléments SOAP [^ 2] en plus des éléments XML.
Continuation du modèle d'usine
//Créer un élément SOAP
SOAPElement element = document.createSOAPElement("element");
SOAPText text = document.createSOAPTextNode("text");
SOAPAttr attribute = document.createSOAPAttribute("attribute");
...
Ensuite, il y aura plus de variantes createXXX ..., telles que createSOAP .... Ce n'est pas beau d'avoir à ajouter beaucoup de méthodes createXXX ... à une classe existante (Document) simplement en ajoutant un autre type de document tel que XML / SOAP.
Appliquons maintenant le modèle Abstract Factory. Le premier est la génération de documents XML.
AbstractFactory pattern (Usine)
//Lors de la génération d'un document XML (Document est équivalent à la classe Factory)
Document document = new XMLDocument(); //Sous-classe de document
Le document SOAP est généré comme suit.
AbstractFactory pattern (Usine)
//Lors de la génération d'un document SOAP (le document correspond à la classe Factory)
Document document = new SOAPDocument(); //Sous-classe de document
Dans les deux cas, l'élément est généré comme suit.
AbstractFactory pattern (éléments générés par Factory)
//Générer un élément
Element element = document.createElement("element");
Text text = document.createTextNode("text");
Attr attribute = document.createAttribute("attribute");
Héritez de la classe Document qui correspond à la fabrique abstraite et créez les classes XMLDocument et SOAPDocument qui correspondent à la fabrique concrète. (Cette classe est fictive.) Ensuite, même si vous augmentez les types de documents tels que XML / SOAP, vous n'avez plus besoin d'ajouter la méthode createXXX .... Dans le même temps, les choses générées par Factory (ʻElement, Text, ʻAttr, etc.) sont également abstraites, donc elles peuvent être traitées de la même manière quel que soit le type d'élément tel que XMLElement / SOAPElement. Je vais. C'est simple et beau.
La définition GoF du modèle Abstract Factory est "fournit une interface qui crée une famille d'objets liés ou dépendants sans spécifier leur classe concrète [^ 3]". La "famille d'objets liés ou dépendants" correspond ici à ʻElement, Text et ʻAttr. De plus, "une interface générée sans spécifier sa classe concrète" équivaut à "Document".
Le modèle Abstarct Factory est très simple comme mentionné ci-dessus, mais il est souvent considéré comme "difficile". Quand j'étais dans ma première et deuxième année en tant qu'ingénieur, je n'étais pas tout à fait sûr. (D'accord, que [Hiroshi Yuki](https://www.amazon.co.jp/%E7%B5%90%E5%9F%8E-%E6%B5%A9/e/B003UW60OA/ref=pd_sim_14_bl_1? _encoding = UTF8 & refRID = YDTDY91X8NYH1QKXNTMF) est le modèle que j'ai trouvé le plus difficile.) La raison pour laquelle je trouve cela difficile est qu'il y a beaucoup de classes qui apparaissent, mais plus que cela, ** il est difficile de comprendre ce qui me plaît * * Je pense que c'est là.
Pour être honnête, dans l'exemple ci-dessus, WEB qui est une introduction aux modèles de conception, et l'exemple des livres, même si vous utilisez le modèle Abstract Factory, vous n'êtes pas si heureux. Il n'y en a pas. Dans ceux-ci, le programme est simplifié pour rendre l'essence du modèle plus facile à comprendre, mais les avantages réels du modèle Abstract Factory sont lorsque le programme est quelque peu complexe.
En conclusion, je pense que la meilleure scène pour bénéficier du modèle Abstract Factory est lorsque vous souhaitez masquer la génération de la classe Factory abstraite.
La figure est la suivante. "Utilisation minimale" et "Comment montrer votre vrai potentiel".
AbstractFactory (utilisation minimale)
|Votre interlocuteur|
↓ ↓
↓ Utilisez ↓ Sélectionnez Factory pour générer
↓ ↓
↓ |Une usine abstraite|
↓ |Usine spécifique à hériter|
↓ ↓
↓ ↓ Générer
↓ ↓
|Choses faites avec Factory|
AbstractFactory (Comment l'utiliser)
|Votre interlocuteur|
↓ ↓
↓ Utiliser ↓ Utiliser
↓ ↓
↓ |Usine abstraite|
↓ ↓
↓ ↓ Sélectionnez Factory pour générer
↓ ↓
↓ |Usine spécifique|
↓ ↓
↓ ↓ Générer
↓ ↓
|Choses faites avec Factory|
La partie «sélectionner et générer l'usine» est différente entre «utilisation minimale» et «comment démontrer son véritable potentiel». Au minimum, l'appelant détermine la classe d'implémentation de la Factory abstraite. D'un autre côté, dans le monde réel, la classe Factory abstraite utilise le chargement de classe dynamique [^ 4] et le fichier de configuration pour déterminer la classe d'implémentation Factory. Par conséquent, l'appelant peut remplacer la classe d'implémentation Factory concrète sans changer le code source.
Examinons maintenant à nouveau le code au début de la page.
//Générer le document correspondant à la classe Element Factory
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document document = builder.newDocument();
//Générer un élément
Element element = document.createElement("element");
Text text = document.createTextNode("text");
Attr attribute = document.createAttribute("attribute");
DocumentBuilderFactory est équivalent à la" Abstract Factory "du modèle Abstract Factory. La méthode newInstance crée une" fabrique concrète "qui est une sous-classe de ce DocumentBuilderFactory. Vous pouvez choisir la classe d'implémentation Factory spécifique parmi les fournisseurs suivants.
Ces classes d'implémentation se trouvent automatiquement dans la méthode newInstance de DocumentBuilderFactory dans l'ordre suivant:
lib / jaxp.properties dans le répertoire JREMETA-INF / services / javax.xml.parsers.DocumentBuilderFactory dans le fichier jar (le mécanisme Java ServiceLoader est utilisé)com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl)Par conséquent, ** la modification de la classe d'implémentation ne nécessite aucune modification du code appelant **. Je ne peux m'empêcher de ressentir de l'art dans ce mécanisme.
De plus, deux patterns Abstract Factory sont cachés dans le code au début [^ 5]. Chacun a la configuration suivante. (Pour le mot Factory, la chose fabriquée par Factory est exprimée en tant que produit.)
De nombreux experts ont également commenté le modèle Abstract Factory.
Alan Sharoway, James R. Trot
Par exemple, si vous développez une interface utilisateur pour un système qui s'exécute sur plusieurs plates-formes, vous utiliserez un groupe d'objets d'interface préparés pour chaque système d'exploitation que vous utilisez. De cette manière, vous pouvez utiliser le modèle Abstract Factory pour utiliser différents objets en fonction de la situation.
["Esprit orienté objet"](https://www.amazon.co.jp/%E3%82%AA%E3%83%96%E3%82%B8%E3%82%A7%E3%82 % AF% E3% 83% 88% E6% 8C% 87% E5% 90% 91% E3% 81% AE% E3% 81% 93% E3% 81% 93% E3% 82% 8D-SOFTWARE-PATTERNS-% E3% 82% A2% E3% 83% A9% E3% 83% B3-% E3% 82% B7% E3% 83% A3% E3% 83% AD% E3% 82% A6% E3% 82% A7% E3 À partir de% 82% A4 / dp / 4621066048 /)
Jiggs Co., Ltd.
Il existe un pattern "Factory Method" qui est très similaire, mais le pattern "Factory Method" est un pattern qui se concentre sur l'abstraction de la "génération d'objet", tandis que le pattern "Abstract Factory" est "lié". C'est dans l'abstraction des "Procédures pour générer collectivement un groupe d'objets à utiliser".
Depuis IT Senka - Introduction aux modèles de conception> Modèles de fabrique abstraite
C'est le vrai plaisir d'un programmeur de pouvoir profiter d'un plaisir intellectuel rien qu'en regardant quelques lignes de code sans avoir à se rendre au musée.
Si vous êtes un ingénieur qui sympathise avec l'art du modèle Abstract Factory, veuillez contacter le responsable du recrutement de notre société (Qualysite Technologies Co., Ltd.). Merci de bien vouloir me contacter!
[^ 1]: [Black Triple Star-Wikipedia](https://ja.wikipedia.org/wiki/Black Triple Star)
[^ 2]: Protocole de communication avec XML. Utilisé sur HTTP.
[^ 3]: ["Modèle de conception à réutiliser dans l'orientation objet"](https://www.amazon.co.jp/%E3%82%AA%E3%83%96%E3%82%B8 % E3% 82% A7% E3% 82% AF% E3% 83% 88% E6% 8C% 87% E5% 90% 91% E3% 81% AB% E3% 81% 8A% E3% 81% 91% E3 % 82% 8B% E5% 86% 8D% E5% 88% A9% E7% 94% A8% E3% 81% AE% E3% 81% 9F% E3% 82% 81% E3% 81% AE% E3% 83 % 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% 91% E3% 82% BF% E3% 83% BC% E3% 83% B3-% E3% 82% AC% E3% 83% B3% E3% 83% 9E-% E3% 82% A8% E3% 83% AA% E3% 83% 83% E3% 82% AF / dp / 479731126 / ref = sr_1_1? = 1495503419 & sr = 8-1 & mots-clés =% E3% 82% AA% E3% 83% 96% E3% 82% B8% E3% 82% A7% E3% 82% AF% E3% 83% 88% E6% 8C% 87% E5% 90% 91% E3% 81% AB% E3% 81% 8A% E3% 81% 91% E3% 82% 8B% E5% 86% 8D% E5% 88% A9% E7% 94% A8% E3% 81% AE% E3% 81% 9F% E3% 82% 81% E3% 81% AE% E3% 83% 87% E3% 82% B6% E3% 82% A4% E3% 83% B3% E3% 83% À partir de 91% E3% 82% BF% E3% 83% BC% E3% 83% B3)
[^ 4]: Je l'ai écrit entre parenthèses, mais c'est juste le standard Java ClassLoader Est une méthode de création d'une instance à partir d'un nom de package et d'un nom de classe codés en dur sous forme de chaînes dans le code source à l'aide de.
[^ 5]: Strictement parlant, le premier Abstract Factory n'est pas le modèle Abstract Factory défini dans GoF, car il n'y a qu'un seul type de produit abstrait, DocumentBuilder.
Recommended Posts