Swift - 生成器模式(Builder Pattern)

//被构建的产品对象的接口
class Product {
    var parts: String = ""
}
//生成器接口，定义创建一个产品对象所需的各个部件的操作
//Builder模式是把复杂对象的创建和部件的创建分别开来
protocol Builder {
    //创建部件
    func buildPart()
    //返回最后组装成品结果 (返回最后装配好的汽车)
    func getProduct() -> Product
}
//指导者，指导使用生成器的接口来构建产品对象
class Director {
    let concreteBuilder: Builder
    init(concreteBuilder: Builder) {
        self.concreteBuilder = concreteBuilder
    }
    //将部件part最后组成复杂对象
    func construct() ->Product{
        concreteBuilder.buildPart()
        return concreteBuilder.getProduct()
    }
}

//Builder的具体实现ConcreteBuilder,通过具体完成接口Builder来构建或装配产品的部件;
//定义并明确它所要创建的是什么具体东西;提供一个可以重新获取产品的接口:
class ConcreteBuilder: Builder{
    
    var product = Product()
    //这里是具体如何构建partA的代码
    func buildPart() {
        product.parts = "adding part succss!"
    }
    //返回最后组装成品结果
    func getProduct() -> Product{
        return product
    }
}

let director = Director(concreteBuilder: ConcreteBuilder())
let product = director.construct()
print(product.parts)//adding part succss!

//最终产品为房子
class Room {
    var window: String  //窗户
    var floor: String  //地板
    
    init(window: String, floor: String) {
        self.window = window
        self.floor = floor
    }
}
//创建者
protocol Builder{
    //制作窗户
    func makeWindow()
    //制作地板
    func makeFloor()
    //房子建成
    func getRoom() ->Room?
}

//设计师其实就是指导者
class Designer{
    func commandOrder(builder: Builder){
        builder.makeWindow()
        builder.makeFloor()
    }
}

//具体创建者
class MinGong: Builder {
    var window: String?  //窗户
    var floor: String?  //地板
    
    func makeWindow() {
        window = "window"
    }
    func makeFloor() {
        floor = "floor"
    }
    func getRoom() -> Room?{
        if window == "window" && floor == "floor" {
            let room = Room(window: window!, floor: floor!)
            return room
        }
        return nil
    }
}

  //找到民工
  let minGong = MinGong()
  //找到设计师
  let designer = Designer()
  //民工遵守设计师的命令制作房子
  designer.commandOrder(builder: minGong)
  //房子建成
  if  let room = minGong.getRoom(){
      print("window: \(room.window), floor: \(room.floor)")
      //window: window, floor: floor
  }

KFC吃汉堡包

声明汉堡包

// MARK: - Product
public struct Hamburger {
    public let meat: Meat
    public let sauce: Sauces
    public let toppings: Toppings
}

extension Hamburger: CustomStringConvertible {
    public var description: String {
        return meat.rawValue + " burger"
    }
}

// 肉类
public enum Meat: String {
    case beef
    case chicken
    case kitten
    case tofu
}

// 酱汁
public struct Sauces: OptionSet {
    public static let mayonnaise = Sauces(rawValue: 1 << 0)
    public static let mustard = Sauces(rawValue: 1 << 1)
    public static let ketchup = Sauces(rawValue: 1 << 2)
    public static let secret = Sauces(rawValue: 1 << 3)

    public let rawValue: Int
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}

// 浇头
public struct Toppings: OptionSet {
    public static let cheese = Toppings(rawValue: 1 << 0)
    public static let lettuce = Toppings(rawValue: 1 << 1)
    public static let pickles = Toppings(rawValue: 1 << 2)
    public static let tomatoes = Toppings(rawValue: 1 << 3)

    public let rawValue: Int
    public init(rawValue: Int) {
        self.rawValue = rawValue
    }
}

// MARK: - Builder
public class HambugerBuilder {

    public private(set) var meat: Meat = .beef
    public private(set) var sauces: Sauces = []
    public private(set) var toppings: Toppings = []

    private var soldOutMeats: [Meat] = [.kitten]

    public func addSauces(_ sauce: Sauces) {
        sauces.insert(sauce)
    }

    public func removeSauces(_ sauce: Sauces) {
        sauces.remove(sauce)
    }

    public func addToppings(_ topping: Toppings) {
        toppings.insert(topping)
    }

    public func removeToppgins(_ topping: Toppings) {
        toppings.remove(topping)
    }

    public func setMeat(_ meat: Meat) throws {
        guard isAvailable(meat) else {
            throw Error.soldOut
        }
        self.meat = meat
    }

    public func isAvailable(_ meat: Meat) -> Bool {
        return !soldOutMeats.contains(meat)
    }

    // 创建方式
    public func build() -> Hamburger {
        return Hamburger(meat: meat, sauce: sauces, toppings: toppings)
    }

    public enum Error: Swift.Error {
        case soldOut
    }
}

// MARK: - Director
// 由员工来点单需要什么类型的汉堡包
public class Employee {
    public func createCombo1() throws -> Hamburger {
        let builder = HambugerBuilder()
        try builder.setMeat(.beef)
        builder.addSauces(.secret)
        builder.addToppings([.lettuce, .tomatoes, .pickles])
        return builder.build()
    }

    public func createKittenSpecial() throws -> Hamburger {
        let builder = HambugerBuilder()
        try builder.setMeat(.kitten)
        builder.addSauces(.mustard)
        builder.addToppings([.lettuce, .tomatoes])
        return builder.build()
    }
}

// MARK: - Example
let burgerFipper = Employee()

if let combo1 = try? burgerFipper.createCombo1() {
    print(combo1.description)
}

if let kittenBurger = try? burgerFipper.createKittenSpecial() {
    print(kittenBurger.description)
} else {
    print("Sorry, no kitten burgers here...")
}