Fabriksmönster

när du utvecklar kod kan du initiera objekt direkt i metoder eller i klasser. Även om detta är helt normalt kanske du vill lägga till en extra abstraktion mellan skapandet av objektet och var det används i ditt projekt.

du kan använda Fabriksmönstret för att lägga till den extra abstraktionen. Fabriksmönstret är ett av de enklaste mönstren att förstå och implementera.

om du lägger till en extra abstraktion kan du också dynamiskt välja klasser att instantiera baserat på någon form av logik.

innan abstraktionen skulle din klass eller metod direkt skapa en konkret klass. Efter att ha lagt till fabriksabstraktionen skapas nu betongklassen utanför den nuvarande klassen / metoden och nu i en underklass.

Föreställ dig en applikation för att designa hus och huset har en stol som redan lagts till på golvet som standard. Genom att lägga till fabriksmönstret kan du ge användaren möjlighet att välja olika stolar och hur många vid körning. Istället för att stolen är hårdkodad i projektet när den startade, har användaren nu möjlighet att välja.

att lägga till denna extra abstraktion innebär också att komplikationerna med att instantiera extra objekt nu kan döljas från klassen eller metoden som använder den.

denna separation gör också din kod lättare att läsa och dokumentera.

Fabriksmönstret handlar verkligen om att lägga till den extra abstraktionen mellan objektskapandet och var det används. Detta ger dig extra alternativ som du lättare kan utöka i framtiden.

• Concrete Creator: klientapplikationen, klassen eller metoden som kallar skaparen (Fabriksmetod).
• Produktgränssnitt: gränssnittet som beskriver de attribut och metoder som fabriken kommer att kräva för att skapa slutprodukten/objektet.
• skapare: fabriken klassen. Förklarar Fabriksmetoden som returnerar objektet som begärs från det.
• betongprodukt: objektet återvände från fabriken. Objektet implementerar produktgränssnittet.

fabrik UML Diagram

källkod

i det här konceptexemplet vill klienten ha ett objekt som heter b

istället för att skapa b direkt i klienten, frågar den skaparen (fabriken) för objektet istället.

fabriken hittar den relevanta klassen med hjälp av någon form av logik från attributen för begäran. Den ber sedan underklassen att instansiera det nya objektet som det sedan returnerar som referens tillbaka till klienten som ber om det.

./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)

utgång

python ./factory/factory_concept.py 
ConcreteProductB

Fabriksmönsteröversikt Video

exempel användningsfall

besök fabrik-designmönster i Python (sbcode.net) för ett exempel använd fall av Fabriksmönstret.

ett exempel på användningsfall är ett användargränssnitt där användaren kan välja från en meny med objekt, till exempel stolar.

användaren har fått ett val med någon form av navigeringsgränssnitt, och det är okänt vilket val eller hur många användaren kommer att göra tills applikationen faktiskt körs och användaren börjar använda den.

så, när användaren valde stolen, tar fabriken sedan någon egenskap som är involverad i det valet, till exempel ett ID, typ eller annat attribut och bestämmer sedan vilken relevant underklass som ska instansieras för att returnera lämpligt objekt.

se ovanstående gif för ett mycket grafiskt exempel på ett verkligt världsexempel på att använda fabriksmönstret för att returnera stolobjekt. Panelen till vänster innehåller stolar, och när du drar och släpper en stol till panelen till höger kallar den Stolfabriken att returnera den till en stol.

Fabriksmönster användningsfall Video

sammanfattning

• Fabriksmönstret är ett gränssnitt som skjuter upp skapandet av det slutliga objektet till en underklass.
• Fabriksmönstret handlar om att infoga ett annat lager/abstraktion mellan att instansera ett objekt och var i din kod det faktiskt används.
• det är okänt vad eller hur många objekt som behöver skapas fram till körning.
• du vill lokalisera kunskap om detaljerna för att instantiera ett visst objekt till underklassen så att klienten inte behöver vara oroad över detaljerna.
• du vill skapa en extern ram, att ett program kan importera/referens, och dölja detaljerna i detaljerna inblandade i att skapa det slutliga objektet / produkten.
• den unika faktorn som definierar Fabriksmönstret är att ditt projekt nu skjuter upp skapandet av objekt till den underklass som fabriken hade delegerat den till.

designmönster i Python (bok)

ibland vill du bara stänga av datorn och läsa från en bok. Så, detta mönster, plus alla andra GoF-mönster diskuteras i mina designmönster i Python-boken ASIN B08XLJ8Z2J