Head First Design Pattern - 제 4장 팩토리 패턴

 

피자 가게를 운영하며 팩토리 패턴에 대해 알아가보겠습니다.

 

 

 

먼저 피자를 주문받습니다.

 

주문을 받으면 피자 타입을 결정하고,

준비하고 포장하고 피자를 반환하는 과정입니다.

 

protocol Pizza {
    var name: String { get }
    func prepare()
    func bake()
    func cut()
    func box()
}

class CheesePizza: Pizza {
    var name: String { return "Cheese Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

class PepperoniPizza: Pizza {
    var name: String { return "Pepperoni Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

func orderPizza(type: String) -> Pizza {
    var pizza: Pizza

    if type == "cheese" {
        pizza = CheesePizza()
    } else if type == "greek" {
        pizza = GreekPizza()
    } else if type == "pepperoni" {
        pizza = PepperoniPizza()
    } else {
        fatalError("Unsupported pizza type")
    }

    pizza.prepare()
    pizza.bake()
    pizza.cut()
    pizza.box()

    return pizza
}

let cheesePizza = orderPizza(type: "cheese")

 

종류에 따라 반환할 피자를 분기처리 하고있습니다.

 

 

분기하여 피자 타입을 결정하는 부분을

캡슐화하여 따로 분리 해두면 좋다고 합니다.

 

 

이점

- 단순화된 인터페이스 제공

- 수정을 하려고 할때 한군데만 확인하면됨

 

 

 

 

 

개선된 orderPizza 함수

 

protocol Pizza {
    var name: String { get }
    func prepare()
    func bake()
    func cut()
    func box()
}

class CheesePizza: Pizza {
    var name: String { return "Cheese Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

class PepperoniPizza: Pizza {
    var name: String { return "Pepperoni Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

// Simple Factory
class SimplePizzaFactory {
    func createPizza(type: String) -> Pizza {
        if type == "cheese" {
            return CheesePizza()
        } else if type == "greek" {
            return GreekPizza()
        } else if type == "pepperoni" {
            return PepperoniPizza()
        } else {
            fatalError("Unsupported pizza type")
        }
    }
}

class PizzaStore {
    let pizzaFactory: SimplePizzaFactory

    init(factory: SimplePizzaFactory) {
        self.pizzaFactory = factory
    }

    func orderPizza(type: String) -> Pizza {
        let pizza = pizzaFactory.createPizza(type: type)

        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()

        return pizza
    }
}

let simpleFactory = SimplePizzaFactory()
let pizzaStore = PizzaStore(factory: simpleFactory)

let cheesePizza = pizzaStore.orderPizza(type: "cheese")
let greekPizza = pizzaStore.orderPizza(type: "greek")
let pepperoniPizza = pizzaStore.orderPizza(type: "pepperoni")

 

B 피자집에서 이 코드를 사용할 경우 SimpleFactory (피자 종류) 부분만 수정하면 된다.

 

이렇게 캡슐화 하는것을 'Simple Factory'

 

객체를 생성하는 역할을

하나의 팩토리 클래스가 전담하는 형태라고 볼 수 있습니다.

 

 

 

 

만약

현재 가게(SimplePizzaFactory)에서는 cheese, greek, pepperoni 3종류인데,

C 피자집에서는 greek피자는 안팔고 veggie를 팔고 싶으면 어떻게 할까?

 

 

피자 종류를 추가하게 될 경우 else if type == "어떤 피자" 이런식으로 수정하게 됩니다.

'변경 사항에 닫혀 있지 않다'고 볼 수 있음

 

 

 

 

// Simple Factory
class SimplePizzaFactory {
    func createPizza(type: String) -> Pizza {
        if type == "cheese" {
            return CheesePizza()
        } else if type == "greek" {
            return GreekPizza()
        } else if type == "pepperoni" {
            return PepperoniPizza()
        } else {
            fatalError("Unsupported pizza type")
        }
    }
}

 

 

저수준 모듈인 피자 Class가 변경되면,

고수준 모듈인 SimplePizzaFactory가 영향을 받으므로 DIP 원칙에 어긋남

-> 추상화 수준이 높은것에 의존하도록 구현을 해야한다고 합니다

 

 

 

이 부분을

 

변경 사항에 닫혀있고,

확장에 용이하게 + DIP 준수하도록 수정한다면 

 

 

 

protocol Pizza {
    var name: String { get }
    func prepare()
    func bake()
    func cut()
    func box()
}

class NYStyleCheesePizza: Pizza {
    var name: String { return "NYStyle Cheese Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

class NYStylePepperoniPizza: Pizza {
    var name: String { return "NYStyle Pepperoni Pizza" }
    func prepare() { print("Preparing \(name)") }
    func bake() { print("Baking \(name)") }
    func cut() { print("Cutting \(name)") }
    func box() { print("Boxing \(name)") }
}

protocol PizzaFactory {
    func createPizza() -> Pizza
}

class NYStyleCheesePizzaFactory: PizzaFactory {
    func createPizza() -> Pizza {
        return CheesePizza()
    }
}

class NYStylePepperoniPizzaFactory: PizzaFactory {
    func createPizza() -> Pizza {
        return PepperoniPizza()
    }
}

class PizzaStore {
    let pizzaFactory: PizzaFactory

    init(factory: PizzaFactory) {
        self.pizzaFactory = factory
    }

    func orderPizza() -> Pizza {
        let pizza = pizzaFactory.createPizza()

        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()

        return pizza
    }
}

let cheeseFactory = CheesePizzaFactory()
let pepperoniFactory = PepperoniPizzaFactory()

let cheesePizzaStore = PizzaStore(factory: cheeseFactory)
let pepperoniPizzaStore = PizzaStore(factory: pepperoniFactory)

let cheesePizza = cheesePizzaStore.orderPizza()
let pepperoniPizza = pepperoniPizzaStore.orderPizza()

 

createPizza를 인터페이스에 선언해두고, 인터페이스를 채택하여 

하위 피자 클래스(NYStyleCheesePizzaFactory)에서 create의 구체적인 구현을 하도록 해줬습니다

 

그러고 PizzaStore(factory: PizzaFactroy) 이런식의 외부 의존성 주입(DI)을 통해

저수준 모듈(피자 종류)가 변경되어도 고수준 모듈(PizzaStore)가 변경되지 않도록 수정 가능합니다.

 

 

 

 

위 방식이 '팩토리 패턴(팩토리 메소드 패턴)'으로

클래스 인스턴트 만드는 일을 서브 클래스에서 하도록 설계하는 방법입니다.

 

PizzaFactory 내부에서 어떤 피자든 상관없이 다 피자를 반환 할 수 있으므로 유연하다고 볼 수 있습니다.

 

 

 

 

 

 

 

 

마지막으로

 

추상 팩토리 패턴

: 구상 클래스에 의존하지 않고도 서로 의존적인 객체로 이루어진 제품군을 생산하는 인터페이스를 제공하는 패턴

-> A 객체(시카고 피자)와 B 객체(뉴욕 피자) 모두 쓰이는 요소(피자 도핑 재료)를 인터페이스로 선언해두는걸 추상팩토리 패턴이라고 하는것 같아요

 

 

 

 

 

감사합니다