팩토리(Factory) 패턴 : 심화The Factory Pattern: Advanced

Types of Factory Patterns

The pattern we looked at earlier is the most basic structure, known as the SimpleFactory pattern. This time, let’s look at the other two patterns.

1. MethodFactory
2. AbstractFactory

The Method Factory Pattern

It encapsulates object creation logic in subclasses, which gives you flexibility and extensibility. It defines an interface for creating objects, but lets the subclasses decide which class to instantiate.

The Situation

Our pizza shop has been doing incredibly well. Let’s say we’re opening a branch in every city. Even for the same menu item, each branch gets ingredients processed at the factory with a local twist, and then delivered.

The Code

First, let’s make a pizza for each region. We’ll also create an enum type to use when branching on the pizza type.

from abc import ABC

class Pizza(ABC):
    name = "Pizza"

class NYStyleCheesePizza(Pizza):
    name = "New York Cheese Pizza"

class ChicagoStyleCheesePizza(Pizza):
    name = "Chicago Cheese Pizza"

from enum import StrEnum

class PizzaType(StrEnum):
    CHEESE = "cheese"

Now let’s write the most important part: the factory class. The heart of this pattern is that the interface declares an object creation method, and the subclasses implement that method.

In other words, you can have several factory classes, and each one can add whatever implementation it wants.

from abc import ABC, abstractmethod
from typing import override
class MethodFactory(ABC):
    @abstractmethod
    def make_pizza(self, pizza_type):
        pass

class NYPizzaFactory(MethodFactory):
    @override
    def make_pizza(self, pizza_type):
        match pizza_type:
            case PizzaType.CHEESE:
                return NYStyleCheesePizza()

class ChicagoPizzaFactory(MethodFactory):
    @override
    def make_pizza(self, pizza_type):
        self.cut_rectangle()

        match pizza_type:
            case PizzaType.CHEESE:
                return ChicagoStyleCheesePizza()

    def cut_rectangle(self):
        print("Chicago pizza is cut into squares.")

Now the client that uses the factory just receives the right factory object for each situation through injection. Want to open a New York branch? Pass in the New York factory to make pizza. Want a Chicago branch? Pass in the Chicago factory.

class PizzaStore:
    def __init__(self, factory: MethodFactory) -> None:
        self.factory = factory

    def order(self, pizza_type: PizzaType) -> Pizza:
        pizza = self.factory.make_pizza(pizza_type)
        return pizza

if __name__ == "__main__":
    ny_factor = NYPizzaFactory()
    ny_store = PizzaStore(ny_factor)
    ny_store.order(PizzaType.CHEESE)

    ch_factory = ChicagoPizzaFactory()
    ch_store = PizzaStore(ch_factory)
    ch_store.order(PizzaType.CHEESE)

Even the same cheese pizza can take on different characteristics depending on the factory.

You ordered a New York Cheese Pizza.

Chicago pizza is cut into squares.
You ordered a Chicago Cheese Pizza.

Class Diagram: MethodFactory

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    class PizzaStore{
        -MethodFactory factory
        +order() Pizza
    }

    class MethodFactory {
        <<interface>>
        +makePizza(type) Pizza*
    }

    class NYPizzaFactory {
        +makePizza(type) Pizza
    }

    class ChicagoPizzaFactory {
        +makePizza(type) Pizza
        +cut_rectangle()
    }

    PizzaStore o-- MethodFactory
    MethodFactory <|.. NYPizzaFactory
    MethodFactory <|.. ChicagoPizzaFactory

    class Pizza {
        <<abstract>>
        str name
    }

    class NYStyleCheesePizza {
        str name
    }

    class ChicagoStyleCheesePizza {
        str name
    }

    NYStyleCheesePizza --|> Pizza
    ChicagoStyleCheesePizza --|> Pizza

    NYPizzaFactory *-- NYStyleCheesePizza
    ChicagoPizzaFactory *-- ChicagoStyleCheesePizza

Abstract Factory

The Abstract Factory pattern is a creational pattern that provides an interface for creating families of related objects. Its defining trait is that it groups together and creates objects that are related to or depend on each other.

The Situation

Let’s think about factories that make each ingredient a pizza needs. A factory makes the dough and the cheese for a pizza, and each factory makes a different dough and cheese.

• The New York factory makes ThinCrustDough and ReggianoCheese.
• The Chicago factory makes ThickCrustDough and MozzarellaCheese.

Each branch simply makes pizza with the ingredients it gets from its factory.

The Code

First, let’s create each ingredient. We define dough and cheese in abstract form and implement them in concrete ingredient classes.

• Dough : ThinCrustDough / ThickCrustDough
• Cheese : ReggianoCheese / MozzarellaCheese

from abc import ABC, abstractmethod
from typing import override

class Dough(ABC):
    @abstractmethod
    def __str__(self) -> str:
        pass

class ThinCrustDough(Dough):
    @override
    def __str__(self) -> str:
        return "ThinCrustDough"

class ThickCrustDough(Dough):
    @override
    def __str__(self) -> str:
        return "ThickCrustDough"

class Cheese(ABC):
    @abstractmethod
    def __str__(self) -> str:
        pass

class ReggianoCheese(Cheese):
    def __str__(self) -> str:
        return "ReggianoCheese"

class MozzarellaCheese(Cheese):
    def __str__(self) -> str:
        return "MozzarellaCheese"

Next we need a factory interface that declares a method for creating each ingredient object. Think of it as declaring one abstract method per category. The concrete factories then implement related or interdependent objects for each category.

Here, each factory picks one ingredient per category and bundles them together.

• New York factory : ThinCrustDough + ReggianoCheese
• Chicago factory : ThickCrustDough + MozzarellaCheese

from abc import ABC, abstractmethod

class AbstractFactory(ABC):
    name = "Factory"

    @abstractmethod
    def make_dough(self) -> Dough:
        pass

    @abstractmethod
    def make_cheese(self) -> Cheese:
        pass

class NYPizzaFactory(AbstractFactory):
    name = "the New York factory"

    def make_dough(self) -> Dough:
        return ThinCrustDough()

    def make_cheese(self) -> Cheese:
        return ReggianoCheese()
class ChicagoPizzaFactory(AbstractFactory):
    name = "the Chicago factory"

    def make_dough(self) -> Dough:
        return ThickCrustDough()

    def make_cheese(self) -> Cheese:
        return MozzarellaCheese()

Now the client can get a set of related ingredients through each factory. With cheese and dough from the New York factory, it makes a New York-style pizza! With cheese and dough from the Chicago factory, it makes a Chicago-style pizza!

class PizzaStore:
    def __init__(self, factory: AbstractFactory):
        self.factory = factory

    def order(self):
        cheese = self.factory.make_cheese()
        dough = self.factory.make_dough()

        return self.make_pizza(cheese, dough)

    def make_pizza(self, cheese, dough):
        print(f"Using ingredients from {self.factory.name},")
        print(f"making a pizza with {cheese} cheese and {dough} dough.")

if __name__ = "__main__":
    ny_factor = NYPizzaFactory()
    ny_store = PizzaStore(ny_factor)
    ny_store.order()

    ch_factory = ChicagoPizzaFactory()
    ch_store = PizzaStore(ch_factory)
    ch_store.order()

Using ingredients from the New York factory,
making a pizza with ReggianoCheese cheese and ThinCrustDough dough.
Using ingredients from the Chicago factory,
making a pizza with MozzarellaCheese cheese and ThickCrustDough dough.

Class Diagram: Abstract Factory

%%{
  init: {
    'theme': 'base',
    'themeVariables': {
      'primaryColor': '#2a3844',
      'lineColor': '#fff',
      'primaryTextColor': '#fff',
      'tertiaryColor': '#fff'
    }
  }
}%%

classDiagram
    direction RL

    class Dough {
        <<abstract>>
    }

    class Cheese {
        <<abstract>>
    }

    class ThinCrustDough {
        
    }

    class ThickCrustDough {
        
    }

    ThinCrustDough --|> Dough
    ThickCrustDough --|> Dough

    class AbstractFactory {
        <<interface>>
        +makeDough() Dough*
        +makeCheese() Cheese*
    }

    class NYPizzaFactory {
        +makeDough() Dough
        +makeCheese() Cheese
    }
    
    class ChicagoPizzaFactory {
        +makeDough() Dough
        +makeCheese() Cheese
    }
    
    class ReggianoCheese {
    }

    class MozzarellaCheese {

    }

    class PizzaStore{
        -AbstractFactory factory
        +order() Pizza
        -make_pizza(cheese, dough) Pizza
    }

    ReggianoCheese --|> Cheese
    MozzarellaCheese --|> Cheese

    NYPizzaFactory *-- ReggianoCheese
    NYPizzaFactory *-- ThinCrustDough

    ChicagoPizzaFactory *-- MozzarellaCheese
    ChicagoPizzaFactory *-- ThickCrustDough

    AbstractFactory <|.. NYPizzaFactory
    AbstractFactory <|.. ChicagoPizzaFactory

    AbstractFactory --o PizzaStore

Wrapping Up

The Factory Method Pattern

• Creates a single product using a single method
• Typically defines an interface or abstract class containing one abstract method
• Each concrete factory class implements this method to create a specific object

The Abstract Factory Pattern

• Creates several related products using several methods
• Defines an interface or abstract class containing several abstract methods
• Each concrete factory class implements these methods to create several related objects

You can think of an abstract factory as something that actually contains several “factory methods.”