[스위프트 디자인패턴] 추상 팩토리 패턴(Abstract Factory Pattern)

추상 팩토리 패턴

The abstract factory pattern provides an interface of creating families of related or dependent objects without specifying their concrete classes.

이전 포스트에서 팩토리 메서드 패턴에 대해 정리해보았는데요, 추상 팩토리 패턴은 팩토리 메서드 패턴과 아주 유사합니다. 두 디자인 패턴의 차이를 이야기 한다면 팩토리 메서드 패턴은 하나의 객체를 생성하기 위해 사용하고, 추상 팩토리 패턴은 여러개의 객체를 생성하기 위해서 사용한다고 할 수 있어요.

사실 기술적으로는 팩토리 메서드 패턴과 추상 팩토리 패턴이 다른 점이 없어요. 의존성 주입 관점에서는 같은 역할을 하기 때문이죠. 하지만 용도에 따라서 팩토리 메서드 패턴과 추상 팩토리 패턴이 각각 더 유용하게 사용될 수 있습니다.

 

팩토리 메서드 패턴 vs. 추상 팩토리 패턴 

추상 팩토리 패턴에 대해 이야기하기 위해서 팩토리 메서드 패턴을 짧게 정리해보고 어떻게 추상 팩토리 패턴이 다른지 이해해볼게요.

팩토리 메서드 패턴은 팩토리의 역할을 하는 Creator가 있고, factoryMethod를 통해 어떤 객체의 인스턴스를 생성하도록합니다. 팩토리 메서드 패턴에서는 한 번에 하나의 객체만 생성되기 때문에 생성되는 모드 Concrete Product들이 서로 독립적입니다. 

이제 여러 개의 객체를 한 번에 생성해야하는 상황을 생각해볼게요.

이렇게 어떤 UI를 만들기 위해서 4개의 객체 중 두 개를 선택해 조합한다고 해볼게요. BlackView는 당연히 YellowButton과 조합이 되어야 사용성이 좋을 것이고, YellowView는 BlackButton과 조합이 되어야 사용성이 좋겠죠. 그래서 우리는 BlackView와 BlackButton, YellowView와 YellowButton이 실수로라도 조합되지 않기를 원합니다. 

팩토리 메서드 패턴을 사용하면 각 객체를 생성하는 팩토리를 만들 수 있겠죠?

이렇게 버튼을 생성하는 팩토리, 뷰를 생성하는 팩토리를 각각 만들어서 객체를 생성할 수 있겠죠. 하지만 이 팩토리를 통해서는 반드시 노란색+검은색이 조합되도록 할 수는 없습니다. 

이렇게 어떤 객체들이 서로 의존성을 가지거나 함께 사용되어야 할 때, 추상 팩토리 패턴을 사용할 수 있습니다. 버튼을 만드는 팩토리, 뷰를 만드는 팩토리를 따로 두는 것이 아니라 노란색 버튼과 검은색 뷰를 만드는 팩토리, 그리고 검은색 버튼과 노란색 뷰를 만드는 팩토리를 두는 것이죠. 포스트 가장 처음에 적었던 "families of related or dependent objects" 가 이런 의미입니다.

먼저 ButtonBoxFactory라는 인터페이스를 정의하고 내부에 두 개의 메서드를 추가합니다. 메서드는 뷰를 만들기 위한 메서드의 인터페이스, 버튼을 만들기 위한 인터페이스이죠. 

이 프로토콜을 채택하는 DarkButtonBoxFactory는 검은색 뷰를 만들어 반환하고, 노란색 버튼을 만들어 반환하도록 구현합니다. 그럼 이제는 이 팩토리를 통해서 반드시 검은색 뷰와 노란색 버튼의 조합을 생성할 수 있습니다. 

같은 방법으로 LightButtonBoxFactory는 노란색 뷰와 검은색 버튼을 만들어 반환하도록 메서드를 구현합니다. 따라서 이 팩토리를 사용하면 항상 노란색 뷰와 검은색 버튼의 조합을 만들 수 있습니다. 

 

구현해보기

위 예시를 그대로 구현해볼게요. 

먼저 Product인 View, Button과 Concrete Product인 YellowView, BlackView, YellowButton, BlackButton을 만들어줍시다.

import Foundation

protocol View: CustomStringConvertible {
    var id: String { get set }
    var color: String { get set }
}

extension View {
    var description: String {
        return "type: view id: \(id) color \(color)"
    }
}

protocol Button: CustomStringConvertible {
    var id: String { get set }
    var color: String { get set }
}

extension Button {
    var description: String {
        return "type: button id: \(id) color \(color)"
    }
}

class YellowView: View {
    var id: String
    var color: String = "Yellow"
    
    init(id: String) {
        self.id = id
    }
}

class BlackView: View {
    var id: String
    var color: String = "Black"
    
    init(id: String) {
        self.id = id
    }
}

class YellowButton: Button {
    var id: String
    var color: String = "Yellow"
    
    init(id: String) {
        self.id = id
    }
}

class BlackButton: Button {
    var id: String
    var color: String = "Black"
    
    init(id: String) {
        self.id = id
    }
}

let blackButton = BlackButton(id: "bb")
let yellowButton = YellowButton(id: "yb")
let blackView = BlackView(id: "bv")
let yellowView = YellowView(id: "yv")

print("\(blackView)\n\(blackButton)\n\(yellowView)\n\(yellowButton)")

// type: view id: bv color Black
// type: button id: bb color Black
// type: view id: yv color Yellow
// type: button id: yb color Yellow
// Program ended with exit code: 0

간단하죠? 여기서 각 Concrete Product에 대한 팩토리를 만들어주면 팩토리 메서드 패턴이 되고, 추상 팩토리 패턴은 서로 연관된 다수의 객체를 생성할 수 있는 팩토리를 만드는 것이었습니다. 

protocol ButtonBoxFactory {
    func createView() -> View
    func createButton() -> Button
}

class DarkButtonBoxFactory: ButtonBoxFactory {
    func createView() -> View {
        return BlackView(id: "bv")
    }
    
    func createButton() -> Button {
        return YellowButton(id: "yb")
    }
}

class LightButtonBoxFactory: ButtonBoxFactory {
    func createView() -> View {
        return YellowView(id: "yv")
    }
    
    func createButton() -> Button {
        return BlackButton(id: "bb")
    }
}

처음 설계했던대로 두 개의 팩토리를 만들었고, 각 팩토리에서 다크모드, 라이트모드에 맞는 뷰와 버튼 객체를 생성해 반환할 수 있게 했습니다.

그럼 이제 클라이언트 객체를 생성해서 추상팩토리 패턴이 왜 유용한지 직접 느껴보죠!

class ButtonBox {
    enum ColorTheme {
        case dark, light
    }
    
    private var colorTheme: ColorTheme
    private var buttonBoxFacotry: ButtonBoxFactory
    private var button: Button?
    private var view: View?
    
    init(colorTheme: ColorTheme) {
        self.colorTheme = colorTheme
        self.buttonBoxFacotry = colorTheme == .dark ? DarkButtonBoxFactory() : LightButtonBoxFactory()
        self.createButtonBox()
    }
    
    private func createButtonBox() {
        self.button = buttonBoxFacotry.createButton()
        self.view = buttonBoxFacotry.createView()
    }
    
    func change(colorTheme: ColorTheme) {
        self.colorTheme = colorTheme
        self.buttonBoxFacotry = colorTheme == .dark ? DarkButtonBoxFactory() : LightButtonBoxFactory()
        self.createButtonBox()
    }
    
    func printComponents() {
        print(self.view!)
        print(self.button!)
    }
}

ButtonBox라는 클래스를 하나 만들었구요, 인자로 주어지는 색상 테마 정보를 통해 팩토리가 변경되도록 했습니다. ButtonBox를 위해 필요한 두 객체인 View와 Button은 생성된 팩토리를 통해 만들어집니다.

만약 어떤 테마에서 생성해야하는 객체 달라진다면 ButtonBox가 아니라 ButtonBoxFactory로 찾아가 객체를 수정해주면 되겠죠? 그리고 change 메서드를 하나 만들어서 유연하게 모드에 따라 다른 객체가 쉽게 생성될 수 있도록 만들 수도 있었습니다.

var buttonBox = ButtonBox(colorTheme: .dark)
buttonBox.printComponents()

print("\n## Change Factory ##\n")

buttonBox.change(colorTheme: .light)
buttonBox.printComponents()

// type: view id: bv color Black
// type: button id: yb color Yellow
//
// ## Change Factory ##
//
// type: view id: yv color Yellow
// type: button id: bb color Black
// Program ended with exit code: 0

ButtonBox의 인스턴스를 생성해서 사용할 때도, 이렇게 간단하게 각 테마에 맞는 객체를 생성해 주입해줄 수 있는 것을 확인할 수 있습니다.

 

마무리

결국 추상 팩토리 패턴이 팩토리 메서드 패턴으로부터 구별되는 가장 큰 특징은 한 팩토리에서 여러 종류(Product)의 객체를 생성하고, 이 객체들이 서로 연관되어 있거나 의존성을 가지고 있는다는 것입니다. 따라서 단순히 생성과 주입의 역할만을 하는 것이 아니라 객체들을 역할에 따라 응집시키는 역할도 하고있는 것이죠. 

꽤 헷갈렸던 팩토리 패턴, 팩토리 메서드 패턴, 추상 팩토리 패턴의 정리가 이렇게 마무리되었습니다. 혹시라도 잘못된 정보가 있거나 다른 의견이 있으시다면 알려주세요! 저도 더 고민해보고 수정하도록하겠습니다.

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