[스위프트 디자인패턴] 팩토리 메서드 패턴(Factory Method Pattern)

팩토리 패턴 (Factory Pattern)

먼저 팩토리 패턴에 대해서 정리해봅시다. 팩토리 패턴은 어떤 객체를 생성할 때, 그 객체를 사용하는 객체에서 직접 객체의 인스턴스를 생성하는 것이 아니라, 팩토리라는 객체에게 그 작업을 맡겨 의존성을 주입받는 방법입니다. 

팩토리 패턴은 왜 필요할까요? 팩토리 패턴의 가장 큰 장점은 객체의 생성을 한 번 캡슐화할 수 있다는 것입니다. 이렇게 캡슐화했을 때는 두 가지 효과를 얻을 수 있는데요, 첫번째 효과는 인스턴스의 생성에 비즈니스 로직이 끼어있을 때, 이 로직을 의존성을 가지는 객체로부터 분리할 수 있다는 것이고, 두번째 효과는 다형성을 통해 언제든지 인스턴스를 생성하는 팩토리를 유연하게 변경할 수 있다는 것입니다.

만약 어떤 인스턴스를 만드는 과정이 바뀐다고 하더라도, 의존성을 가지고 있는 개체는 수정하지 않은 채로 팩토리의 시나리오만 수정해줄 수 있죠. 만약 의존성의 인스턴스를 생성하는 방법이 여러가지가 있다고 한다면, 여러 종류의 팩토리를 구현해두고 필요한 팩토리를 선택해 사용할 수도 있습니다.

Head First Design Pattern에 따르면 팩토리 패턴 자체는 디자인 패턴으로 볼 수는 없고, 팩토리라는 객체를 사용해 코드를 정리하는 하나의 방법입니다. 그리고 팩토리 메서드 패턴과 추상 팩토리 패턴은 이 팩토리를 사용해 정의된 디자인 패턴이라고 합니다. 그럼 팩토리 메서드 패턴에 대해 자세히 알아보자구요!

 

팩토리 메서드 패턴 (Factory Method Pattern)

The Factory Method Pattern defines an interface for creating an object. But, let subsclasses decide which class to instantiate. Factory method lets the class defer instantiation to subclass.

팩토리 메서드 패턴의 핵심은 실제로 인스턴스를 생성하는 팩토리들에 대해 인터페이스를 제공하고, 이 인터페이스를 구현하는 하위 클래스들에 의해 인스턴스가 생성되는 디자인 패턴입니다.

팩토리 메서드는 팩토리의 인터페이스에서 정의되는 인스턴스를 생성하는 메서드를 의미해요. 즉, 실제로 인스턴스를 생성하는 구체적인 팩토리들은 인터페이스의 팩토리 메서드를 구현해서 인스턴스를 생성하는 것이죠.

위 그림은 팩토리 메서드 패턴의 구조를 표현하고 있습니다. 만약 우리가 상황에 따라 여러 구체 타입, ConcreteProduct의 인스턴스를 생성하고 싶다면, Product로 타입들을 추상화하고, 이 인스턴스의 생성을 팩토리인 Creator에게 맡깁니다.

Creator 역시도 이를 구현하고 있는 구체 타입이 존재해 실제로 인스턴스의 생성은 Creator를 따르는 하위 계층의 클래스인 ConcreteCreator에서 진행됩니다. "팩토리 메서드"라는 이름이 붙은 이유는 여러 팩토리들을 하나로 추상화하고 인스턴스의 생성을 담당하는 메서드를 추상화하는 것을 주요한 전략으로 사용하기 때문인 것 같네요.

 

동물카페 구현해보기

팩토리 메서드 패턴을 이용해서 간단한 예시를 만들어볼까요?

import Foundation
 
protocol Animal {
    var name: String { get set }
    func sound()
}
 
class Dog: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func sound() {
        print("\(name) Bark! 🐶")
    }
}
 
class Cat: Animal {
    var name: String
    
    init(name: String) {
        self.name = name
    }
    
    func sound() {
        print("\(name) Meow! 😸")
    }
}

먼저 이 프로그램에서 사용될 Concrete Product인 Dog 클래스와 Cat 클래스를 정의하고, 이 둘을 추상화하는 인터페이스인 Animal 프로토콜을 작성했어요. 이 프로토콜이 Product가 되겠죠. 

우리는 이제 Dog 나 Cat 인스턴스가 필요할 때 직접 인스턴스를 만들지 않고 팩토리를 통해 인스턴스를 생성하기를 원해요. 따라서 Concrete Creator는 어떤 인스턴스를 생성할지 결정하기 때문에 Dog나 Cat을 생성해서 반환하는 팩토리가 되겠죠.

protocol AnimalFactory {
    func make(with name: String) -> Animal
}
 
class RandomAnimalFactory: AnimalFactory {
    func make(with name: String) -> Animal {
        return Int.random(in: 0...1) == 0 ? Dog(name: name) : Cat(name: name)
    }
}
 
class EvenAnimalFactory: AnimalFactory {
    var previousState: Animal.Type?
    func make(with name: String) -> Animal {
        if previousState == Cat.self {
            self.previousState = Dog.self
            return Dog(name: name)
        } else {
            self.previousState = Cat.self
            return Cat(name: name)
        }
    }
}

두 종류의 팩토리를 만들었습니다. 그냥 인스턴스를 생성하는 것이 아니라 두 팩토리 모두 인스턴스를 생성하기 위한 비즈니스 로직을 가지고 있는데요, 이렇게 로직을 분리해낼 수 있는 것이 팩토리 메서드 패턴의 큰 장점입니다. RandomAnimalFactory는 랜덤하게 강아지나 고양이를 생성하고, EvenAnimalFactory는 이전에 생성한 타입을 기억해서 똑같은 동물이 연달아 나오지 않도록 하고 있습니다.

 

이제 이 팩토리를 사용해서 인스턴스를 주입받는 클라이언트 객체인 동물카페를 만들어볼게요.

class AnimalCafe {
    private var animals = [Animal]()
    private var factory: AnimalFactory
    
    init(factory: AnimalFactory) {
        self.factory = factory
    }
    
    func addAnimal(with name: String) {
        self.animals.append(self.factory.make(with: name))
    }
    
    func printAnimals() {
        self.animals.forEach { animal in
            animal.sound()
        }
    }
    
    func change(factory: AnimalFactory) {
        self.factory = factory
    }
    
    func clear() {
        self.animals = []
    }
}

구현은 간단하게 했는데요, 카페 객체를 생성할 때 사용할 팩토리 객체를 주입받고, 새로운 동물을 추가하게 되면 해당 동물의 인스턴스를 팩토리를 통해 만들고 반환받아 리스트에 추가하고 있습니다.

let animalCafe = AnimalCafe(factory: EvenAnimalFactory())
animalCafe.addAnimal(with: "A")
animalCafe.addAnimal(with: "B")
animalCafe.addAnimal(with: "C")
animalCafe.addAnimal(with: "D")
animalCafe.addAnimal(with: "E")
animalCafe.addAnimal(with: "F")
animalCafe.printAnimals()
 
animalCafe.clear()
print("\n## Change Factory ##\n")
animalCafe.change(factory: RandomAnimalFactory())
animalCafe.addAnimal(with: "A")
animalCafe.addAnimal(with: "B")
animalCafe.addAnimal(with: "C")
animalCafe.addAnimal(with: "D")
animalCafe.addAnimal(with: "E")
animalCafe.addAnimal(with: "F")
animalCafe.printAnimals()

예제 코드를 만들고 동물카페 객체를 생성해서 테스트를 해봅시다!

결과는 의도한대로 잘 나왔네요! 인스턴스 생성에 대한 의존성이 없어졌기 때문에 런타임에 새로운 팩토리를 주입해서 인스턴스 생성을 위한 다른 전략을 선택할 수도 있고, 만약 동물 카페에 새로운 동물이 추가되더라도 동물카페는 수정할 필요 없이 팩토리 메서드만 수정하면 동일하게 동물 카페 객체를 사용할 수 있습니다.

 

마무리

팩토리 패턴, 팩토리 메서드 패턴, 추상 팩토리 패턴이 항상 헷갈리죠.. 이전에 "팩토리 메서드 패턴 vs 추상 팩토리 패턴"이라는 포스트를 작성한 적이 있는데, 공부하다보니까 잘못 쓴 것 같더라구요. 일단 비공개로 돌려두었습니다ㅠ

지금까지 정리한 내용은 팩토리 패턴은 팩토리라는 인스턴스를 생성하는 객체를 따로 두는 기법이고, 팩토리 메서드 패턴은 이 팩토리를 추상화하고 팩토리 메서드에 대한 인터페이스를 제공해서 구현체가 어떤 인스턴스를 어떻게 생성할지 결정하게 하는 디자인 패턴이었습니다.

다음 포스트에서는 추상 팩토리 패턴에 대해서 공부해볼게요! 

아직 디자인 패턴에 대한 공부가 많이 부족해서 잘못된 정보가 있을 수 있어요. 혹시 잘못된 내용이나 예제가 있다면 꼭 알려주세요! 저도 다시 고민해보고 수정해보도록 하겠습니다! 

오늘도 읽어주셔서 감사합니다~!