Design Pattern in Swift [ 생성 패턴 ]

 

 

1) 빌더 패턴 (Builder Pattern) 

 

- 어떤 Product 와 이를 만드는 Builder로 구성

- 이 패턴은 Swift에 그렇게까지 유효한 패턴은 아님 -> 대부분 초기화 메서드와 프로퍼티 기본값을 활용하여 해결 가능 

- 프로퍼티의 개수가 굉장히 많아지고 복잡해지는 경우에 유용

 

struct MacBook {
    let color: String
    let memory: Int
    let storage: String
    let hasTouchBar: Bool
}

class MacBookBuilder {
    private var color = "Space Gray"
    private var memory = 16
    private var storage = "256GB"
    private var hasTouchBar = false
    
    func setColor(_ color: String) -> MacBookBuilder {
        self.color = color
        return self
    }
    
    func setMemory(_ memory: Int) -> MacBookBuilder {
        self.memory = memory
        return self
    }
    
    func setStorage(_ storage: String) -> MacBookBuilder {
        self.storage = storage
        return self
    }
    
    func setHasTouchBar(_ has: Bool) -> MacBookBuilder {
        self.hasTouchBar = has
        return self
    }
    
    func build() -> MacBook {
        return MacBook(color: color, memory: memory, storage: storage, hasTouchBar: hasTouchBar)
    }
}

let builder = MacBookBuilder()
let macBook1 = builder.setColor("Silver").setMemory(32).setStorage("512").setHasTouchBar(true).build()
let macBook2 = builder.setMemory(32).setStorage("1TB").build()
let macBook3 = builder.build()

 

 

2) 프로토타입 패턴 (Prototype Pattern) 

 

- 기존의 객체를 복제하기 위한 패턴 -> 자기 자신을 복제하는 패턴 

 

protocol Prototype: AnyObject {
    func clone() -> Self
}

class Seongah: Prototype {
    
    var age: Int
    
    init(age: Int) {
        self.age = age
    }
    
    func clone() -> Self {
        return Seongah(age: self.age) as! Self
    }
}

let seongah = Seongah(age: 26)
seongah.age += 10
print("10년뒤 나의 나이 = \(seongah.age)")

let seongah2 = seongah.clone()
seongah2.age += 30
print("30년 뒤 나의 나이 = \(seongah2.age)")

 

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

 

- Creator : Factory 에 기본 역할을 정의하는 객체 

- Concrete Creator: Creator를 채택하고 있으며 Product에 맞는 구체적 기능을 구현 

- Product : Concrete Product 가 해야할 동작들을 선언하는 객체 

- Concrete Product: Product를 채택하며 그에 맞게 만든 실제 객체 

 

•  장점 : 프로토콜로 기본 기능을 정의해주었기 때문에 기존 코드를 변경하지 않고 새로운 하위클래스 추가가 가능하기 떄문에 유연 + 확장성 좋음 
• 단점: Product가 추가될 때마다 새로운 하위클래스를 정의해주어야 하기 때문에 불필요하게 많은 클래스가 정의되어질 수 있음 / 중첩되어 사용하면 매우 복잡해질 우려 있음 

 

// Creator : Factory 에 기본 역할을 정의하는 객체
protocol AppleFactory {
    func createElectronics() -> Product
}

// Concrete Creator : Creator를 채택하고 있으며 Product에 맞는 구체적 기능을 구현
class iphonFactory: AppleFactory {
    func createElectronics() -> Product {
        return Iphone()
    }
}

class IpadFactory: AppleFactory {
    func createElectronics() -> Product {
        return Ipad()
    }
}

// Product : Concrete Product가 해야할 동작들을 선언하는 객체
protocol Product {
    func produceProduct()
}

// Concrete Product : Product를 채택하며 그에 맞게 만든 실제 객체
class Iphone: Product {
    func produceProduct() {
        print("Hello Iphone was made")
    }
}

class Ipad: Product {
    func produceProduct() {
        print("Hello Ipad was made")
    }
}

class Client {
    func order(factory: AppleFactory) {
        let electronicsProduct = factory.createElectronics()
        electronicsProduct.produceProduct()
    }
}

var client = Client()
client.order(factory: IpadFactory())
client.order(factory: iphonFactory())

 

4) 추상 팩토리 패턴 (Abstract Factory Method) 

 

- Factory가 추가되고 기존에 존재하는 Product로 Factory를 구성할 때는 매우 효과적인 패턴

- 한계: 새로운 종류의 Product가 추가되면 각각의 Factory에도 추가해줘야 하는 경우도 생김 / Product의 추가나 변동이 잦아진다면 모든 Factory에 변동이 생길 위험이 있음 

// 1. 생성을 담당할 Factory 구현
// 1) 추상화된 Factory
protocol UIFactoryalbe {
    func createButton() -> Buttonalbe
    func createLabel() -> Labelable
}

// 2) 연관된 제품군을 실제로 생성하는 구체 factory
final class ipadUIFactory: UIFactoryalbe {

    func createButton() -> Buttonalbe {
        return IpadButton()
    }
    
    func createLabel() -> Labelable {
        return IpadLabel()
    }
    
}

final class iphoneUIFactory: UIFactoryalbe {
    func createButton() -> Buttonalbe {
        return IphoneButton()
    }
    
    func createLabel() -> Labelable {
        return IPhoneLabel()
    }
    
    
}

// 2. 생성될 Product 구현
// 1) 추상화된 Product
protocol Buttonalbe {
    func touchUP()
}

protocol Labelable {
    var title: String { get }
}

// 2) 실제로 생성될 구체 Product, 객체가 가질 기능과 상태를 구현
final class IphoneButton: Buttonalbe {
    func touchUP() {
        print("iphoneButton")
    }
}

final class IPhoneLabel: Labelable {
    var title: String = "iPhoneLabel"
}

final class IpadButton: Buttonalbe {
    func touchUP() {
        print("IpadButton")
    }
}

final class IphoneLabel: Labelable {
    var title: String = "IphoneLabel"
}

final class IpadLabel: Labelable {
    var title: String = "ipadLabel"
}

// Factory 를 통해 UI를 만들고 가지고 있는 Class
class UIContent {
    var uiFactory: UIFactoryalbe
    var label: Labelable?
    var button: Buttonalbe?
    
    // 사용할 UI의 Default값은 iphone
    init(uiFactory: UIFactoryalbe = iphoneUIFactory()) {
        self.uiFactory = uiFactory
        setupUI()
    }
    
    func setupUI() {
        label = uiFactory.createLabel()
        button = uiFactory.createButton()
    }
}

class ViewController: UIViewController {
    
    var iPadUIContent = UIContent(uiFactory: ipadUIFactory())
    var iphonUICOntent = UIContent()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        touchupButton()
        printLabelTitle()
    }
    
    func touchupButton() {
        iPadUIContent.button?.touchUP()
        iphonUICOntent.button?.touchUP()
    }
    
    func printLabelTitle() {
        print(iPadUIContent.label?.title ?? "")
        print(iphonUICOntent.label?.title ?? "")
    }
}

 

5) 싱글턴 패턴 

- 앱 전체에 걸쳐서 유일한 객체를 만들기 위해서 사용 -> 어디에서나 전역적으로 접근할 수 있는 유일한 객체 

- 일반적으로 싱글턴 패턴의 목적인 유일한 객체를 사용하기 위해 Class 를 사용 

- 구조체로 싱글턴을 구현하게 된다면 만약 싱글턴 객체를 인스턴스화하게 될 때 유일하지 못한 객체가 됨 

 

• 장점 : 유일한 객체를 만들어서 다양한 객체들에게 공유되는 객체를 만들 수 있다는 장점 / 재사용이 가능하여 메모리 낭비를 방지 
• 단점: 객체 지향 관점에서 본다면 인스턴스들 간에 결합도가 높아져서 OCP(개방-폐쇄 원칙, Open-Closed Principle) 을 위배하게 된다는 단점이 있음 (OCP는 모듈의 확장에는 열려있어야 하고, 변경에는 닫혀있어야 한다는 객체 지향 설계의 원칙 중 하나)