Fabriekspatroon

BY admin

| januari 10, 2022

Sean Bradley

volgen

April 9, 2019 * 4 min. lezen

bij het ontwikkelen van code, kunt u objecten direct instantiate in methoden of in klassen. Hoewel dit heel normaal is, Wilt u misschien een extra abstractie toevoegen tussen de creatie van het object en waar het in uw project wordt gebruikt.

u kunt het Fabriekspatroon gebruiken om die extra abstractie toe te voegen. Het Fabriekspatroon is een van de makkelijkste patronen om te begrijpen en uit te voeren.

door een extra abstractie toe te voegen kunt u ook dynamisch klassen kiezen om te instantiëren op basis van een soort logica.

voor de abstractie zou uw klasse of methode direct een concrete klasse aanmaken. Na het toevoegen van de fabrieksabstractie wordt de betonklasse nu buiten de huidige klasse/methode gemaakt, en nu in een subklasse.

stel je een toepassing voor voor het ontwerpen van huizen en het huis heeft standaard al een stoel op de vloer. Door het fabriekspatroon toe te voegen, kunt u de gebruiker de mogelijkheid geven om verschillende stoelen te kiezen, en hoeveel tijdens runtime. In plaats van de stoel wordt hard gecodeerd in het project toen het begon, de gebruiker heeft nu de optie om te kiezen.

het toevoegen van deze extra abstractie betekent ook dat de complicaties van het instantiseren van extra objecten nu kunnen worden verborgen voor de klasse of methode die het gebruikt.

deze scheiding maakt het ook makkelijker om uw code te lezen en te documenteren.

het Fabriekspatroon gaat eigenlijk over het toevoegen van die extra abstractie tussen de objectcreatie en waar het wordt gebruikt. Dit geeft je extra opties die je in de toekomst gemakkelijker kunt uitbreiden.

Concrete Creator: de clienttoepassing, klasse of methode die de Creator aanroept (fabrieksmethode).
productinterface: de interface die de kenmerken en methoden beschrijft die de fabriek nodig heeft om het eindproduct/object te maken.
Maker: De Fabrieksklasse. Verklaart de fabriek methode die het gevraagde object zal terugkeren van het.
betonproduct: het uit de fabriek geretourneerde object. Het object implementeert de productinterface.

Factory UML Diagram

broncode

in dit conceptvoorbeeld wil de client een object met de naam b

in plaats van b direct in de client aan te maken, vraagt het de maker (factory) om het object.

de fabriek vindt de relevante klasse met behulp van een soort logica uit de attributen van het verzoek. Het vraagt dan aan de subklasse om het nieuwe object te instantieren dat het dan terug geeft als een referentie naar de cliënt die erom vraagt.

./factory/factory_concept.py

"""
The Factory Pattern Concept
https://sbcode.net/python/factory/#factoryfactory_conceptpy
"""from abc import ABCMeta, abstractmethodclass IProduct(metaclass=ABCMeta):
"A Hypothetical Class Interface (Product)" @staticmethod
@abstractmethod
def create_object():
"An abstract interface method"class ConcreteProductA(IProduct):
"A Concrete Class that implements the IProduct interface" def __init__(self):
self.name = "ConcreteProductA" def create_object(self):
return selfclass ConcreteProductB(IProduct):
"A Concrete Class that implements the IProduct interface" def __init__(self):
self.name = "ConcreteProductB" def create_object(self):
return selfclass ConcreteProductC(IProduct):
"A Concrete Class that implements the IProduct interface" def __init__(self):
self.name = "ConcreteProductC" def create_object(self):
return selfclass Creator:
"The Factory Class" @staticmethod
def create_object(some_property):
"A static method to get a concrete product"
if some_property == 'a':
return ConcreteProductA()
if some_property == 'b':
return ConcreteProductB()
if some_property == 'c':
return ConcreteProductC()
return None# The Client
PRODUCT = Creator().create_object('b')
print(PRODUCT.name)

uitvoer

python ./factory/factory_concept.py 
ConcreteProductB

Factory Pattern Overview Video

voorbeeld Use Case

bezoek Factory-Design Patterns In Python (sbcode.net) voor een voorbeeld gebruik geval van de fabriek patroon.

een voorbeeld use case is een gebruikersinterface waar de gebruiker kan kiezen uit een menu van items, zoals stoelen.

de gebruiker heeft een keuze gekregen met behulp van een soort navigatie-interface, en het is onbekend welke keuze, of hoeveel de gebruiker zal maken totdat de toepassing daadwerkelijk draait en de gebruiker het begint te gebruiken.

dus, wanneer de gebruiker de chair selecteerde, neemt de fabriek dan een eigenschap die betrokken is bij die selectie, zoals een ID, Type of ander attribuut en besluit vervolgens welke relevante subklasse te instantiëren om het juiste object te retourneren.

Real world voorbeeld van het Fabriekspatroon dat gebruikt wordt

zie bovenstaande gif voor een zeer grafisch voorbeeld van een echt voorbeeld van het gebruik van het fabriekspatroon om stoelobjecten terug te geven. Het paneel aan de linkerkant bevat stoelen, en als je een stoel naar het paneel aan de rechterkant sleept en neerzet, roept het de Stoelfabriek op om het een stoel terug te geven.