Modèle d'usine, comme son nom l'indique, nous pouvons obtenir le "produit" comme requis par une "usine" désignée.
En mode de conception, il est principalement utilisé pour créer des objets abstraits, permettant aux utilisateurs de spécifier leurs propres objets sans avoir à faire attention aux objets d'objets.
Les avantages de ce sont
Les utilisateurs doivent avoir une instance d'un objet avec une interface fixe au lieu d'appeler l'initialisation de la classe, cacher la complexité des règles de Cenerator Spectacles. Découvrez les exemples de production et l'utilisation d'exemples, réduisez la complexité de la maintenance.
Premier, simplePremièrement, prenez un exemple d'une simple usine:
] Supposons que nous disposons de deux "produits". Voitures Mercedes et BMW. S'il n'y a pas de "usine" pour les produire, nous devons montrer leur code, tel que:
#!/usr/bin/env python# ~*~ coding: utf-8 ~*~class Mercedes(object): """梅赛德斯 """ def __repr__(self): return "Mercedes-Benz" class BMW(object): """宝马 """ def __repr__(self): return "BMW" #!/usr/bin/env python# ~*~ coding: utf-8 ~*~mercedes = Mercedes()bmw = BMW() Une scène: Mais en fait, vous pouvez faire face à de nombreux produits de voiture et les paramètres de construction de chaque produit sont encore différents, rencontreront des problèmes lors de la création d'une instance. À ce stade, vous pouvez créer une "usine simple" pour emballer tous les processus d'initialisation de la voiture interne.
Après la classe SimpleCarffactory, vous pouvez obtenir l'exemple d'objet souhaité en combinant les paramètres dans l'interface fixe, comme suit:
#!/usr/bin/env python# ~*~ coding: utf-8 ~*~class SimpleCarFactory(object): """简单工厂 """ @staticmethod def product_car(name): if name == 'mb': return Mercedes() elif name == 'bmw': return BMW() #!/usr/bin/env python# ~*~ coding: utf-8 ~*~c1 = SimpleCarFactory.product_car('mb')c2 = SimpleCarFactory.product_car('bmw')
#!/usr/bin/env python# ~*~ coding: utf-8 ~*~import abcclass AbstractFactory(object): """抽象工厂 """ __metaclass__ = abc.ABCMeta @abc.abstractmethod def product_car(self): pass class Mercedes(object): """梅赛德斯 """ def __repr__(self): return "Mercedes-Benz" class BMW(object): """宝马 """ def __repr__(self): return "BMW"class MercedesFactory(AbstractFactory): """梅赛德斯工厂 """ def product_car(self): return Mercedes() class BMWFactory(AbstractFactory): """宝马工厂 """ def product_car(self): return BMW() Bien qu'il existe une simple usine, Nous trouverons de nouveaux problèmes dans l'utilisation effective de l'usine:
#!/usr/bin/env python# ~*~ coding: utf-8 ~*~c1 = MercedesFactory().product_car()c2 = BMWFactory().product_car() Scénario 2:
Si nous devons ajouter un "produit", tel que la voiture d'Audi, nous devons modifier le Méthode de produit_car en simplicité en dehors de la nouvelle classe Audi. Cela viole le principe de l'ouverture et de la fin de la conception logicielle, ce qui signifie lors de l'élargissement de la nouvelle couche, essayez de ne pas modifier le code d'origine. Par conséquent, Nous avons mis une abstraction SimpleCarffactoryEntrer dans différentes usines sur la base de simples usines et chaque usine devrait créer ses propres produits, c'est la méthode d'usine.
Nous abstraits usine avec un module ABC pour réaliser une classe de base abstraite abstraite afin que vous puissiez obtenir des cas de produits spécifiques via une machine spécifique:
#!/usr/bin/env python# ~*~ coding: utf-8 ~*~import abc# 两种小汽车class Mercedes_C63(object): """梅赛德斯 C63 """ def __repr__(self): return "Mercedes-Benz: C63" class BMW_M3(object): """宝马 M3 """ def __repr__(self): return "BMW: M3" # 两种SUVclass Mercedes_G63(object): """梅赛德斯 G63 """ def __repr__(self): return "Mercedes-Benz: G63" class BMW_X5(object): """宝马 X5 """ def __repr__(self): return "BMW: X5" class AbstractFactory(object): """抽象工厂 可以生产小汽车外，还可以生产SUV """ __metaclass__ = abc.ABCMeta @abc.abstractmethod def product_car(self): pass @abc.abstractmethod def product_suv(self): pass class MercedesFactory(AbstractFactory): """梅赛德斯工厂 """ def product_car(self): return Mercedes_C63() def product_suv(self): return Mercedes_G63() class BMWFactory(AbstractFactory): """宝马工厂 """ def product_car(self): return BMW_M3() def product_suv(self): return BMW_X5() #!/usr/bin/env python# ~*~ coding: utf-8 ~*~c1 = MercedesFactory().product_car()s1 = MercedesFactory().product_suv()print(c1, s1)s2 = BMWFactory().product_suv()c2 = BMWFactory().product_car()print(c2, s2) .
. [ Chaque usine est responsable de la production de vos propres produits, évite également lorsque vous ajoutez un produit, vous devez corriger Il modifie le code d'usine et vous pouvez augmenter l'usine correspondante. Si vous ajoutez un produit Audi, ajoutez simplement une classe Audi Classe et Auditifactory. Mardi, Abstract Factory Méthode de résolution de l'usine Résolution de notre problème "Modifier le code". Scène 3: MaisNous devons produire de nombreux produits, nous constaterons que nous devons également écrire beaucoup d'usines correspondantes. Par exemple, si Mercedesfactory et BMWFactory produisent non seulement des voitures, mais produisent également le SUV, nous devons construire deux couches d'usines produites par les VUS dans des méthodes de plantes. Donc, pour résoudre ce problème, nous avons à plus de classes d'usine abstraites, permettant à une usine de produire de nombreux produits du même type, qui est une usine abstraite. La mise en œuvre est la suivante: Nous permettons à la classe de base d'abstraction de produire des voitures et des VUS simultanées, puis de laisser Mercedesfactory et BMWFactory hériter des méthodes abstraites et une substitution des méthodes_car et des méthodes Product_SUV. Méthode de modèle usine et modale de l'usine abstraite La plus grande différence est un objet végétal dans des usines abstraites pouvant être responsables de la création de nombreux objets de produit, le mode de mode plus simpleune usine. Efficace. L'application effective de trois usines de modèle est confuse, en fait, il y a des avantages et des inconvénients de trois modèles. Les scènes ne sont pas identiques: le modèle d'usine simple s'applique à moins d'objets qui seront créés et ne provoquent pas la logique commerciale en mode usine trop compliquée et que les utilisateurs ne se soucient que du type de catégorie créé et ne se soucient pas du processus d'initialisation, comme une instance de plusieurs bases de données (MySQL / MongoDB), analyseur (XML / JSON), etc. De plusieurs fichiers format. Modèle Méthode d'usine successorée Les avantages des modèles d'usine simples et améliorés, ne sont plus transmis à une couche d'usine pour être responsables de tous les produits, mais la gestion de la création spécifique fonctionne avec la sous-classe correspondante. Cela permet aux modèles de méthode d'usine de permettre au système de se développer plus efficacement. Les applications réelles peuvent être utilisées pour déployer des systèmes de journal de système, tels que le journal d'exécutionProgrammes spécifiques, journaux de réseau, journaux de base de données, V.V.Peut être créé avec des classes d'usine spécifiques.Abstract Factory Extension de l'extension des usines Pour de nombreux produits basées sur des méthodes d'usine, convient à certains grands systèmes, plus d'une famille de ce produit et de ces produits de produit doivent obtenir la même interface, comme différents serrures, boîtes de texte, zones de texte, Boîtes de texte, polices, etc.