这儿介绍一下规划形式中的生成器形式（或许称制作者形式）在iOS中的完成。

一、由什么问题引出来的？

假定创立一个杂乱的产品如轿车，创立这个轿车有很多的过程完结，比方车窗、座椅、发动机，假如这些过程放在了同一个办法里边，那么办法的入参很多，并且办法里边有制作车窗、座椅、发动机代码，可想而知这个办法是会很臃肿并且难以保护。
咱们这个时分需求把这些事务分开到不同的当地去，怎么去组织好这些去完成出产轿车这个功能呢？

二、生成器形式是怎么做的？

咱们为了能够更好的扩展和保护，会把这个杂乱产品的创立分为几个部分，每个部分专注于完结自己的事务逻辑，最后再由一个类作为指导类去指挥创立这个产品。

三、大概要一个生成器形式比如才干懂吧

假定出产一辆轿车由车身、发送机、轮轴等完结。

  1. 产品是车子
// 车子类
@objc(Car)
class Car :NSObject {
    private var wheel : String? = "wheel";// 轮子
    private var engine : String? = "engine";// 引擎
    private var frame : String? = "frame";// 车身框架
    func setWheel(wheel : String) {
        // 事务逻辑：拼装轮胎...
        self.wheel = wheel;
    }
    func setEngine(engine : String) {
        // 事务逻辑：拼装发动机引擎...
        self.engine = engine;
    }
    func setFrame(frame : String) {
        // 事务逻辑：拼装车身框架...
        self.frame = frame;
    }
    override var description: String{
        return "wheel=\(self.wheel ?? "")";
    }
}

2、不同车的不同结构器类

@objc(Builder)
protocol Builder : class {
    func getCar() -> Car;
    func buildWheel();
    func buildEngine();
    func buildFrame();
}
// 保时捷
@objc(PorscheBuilder)
class PorscheBuilder: NSObject, Builder {
    var porsche: Car = Car.init();
    func getCar() -> Car {
        return self.porsche;
    }
    func buildWheel() {
        // 出产制作porsche-wheel轮子的逻辑
        porsche.setWheel(wheel: "porsche-wheel");
    }
    func buildEngine() {
        // 出产制作porsche-engine轮子的逻辑
        porsche.setEngine(engine: "porsche-engine");
    }
    func buildFrame() {
        // 出产制作porsche-frame轮子的逻辑
        porsche.setFrame(frame: "porsche-frame");
    }
}
// 破二手车
@objc(Porsche2Builder)
class Porsche2Builder: NSObject, Builder {
    var porsche2: Car = Car.init();
    func getCar() -> Car {
        return self.porsche2;
    }
    func buildWheel() {
        // 出产制作破二手车轮子的逻辑
        porsche2.setWheel(wheel: "porsche-2-wheel");
    }
    func buildEngine() {
        // 出产制作破二手车引擎的逻辑
        porsche2.setEngine(engine: "porsche-2-engine");
    }
    func buildFrame() {
        // 出产制作破二手车车身的逻辑
        porsche2.setFrame(frame: "porsche-2-frame");
    }
}

3、指导类: 你运用时传结构器PorscheBuilder给我，我帮你一致调用出产车子需求调用的办法。

@objc(Director)
class Director : NSObject{
    private var builder : Builder?;
    @objc(director:)
    public static func director(bld : Builder) -> Director {
        let director : Director = Director.init();
        director.builder = bld;
        return director;
    }
    @objc(produceCar)
    func produceCar()  {// 假定要4个轮子
        builder?.buildEngine();
        builder?.buildFrame();
        builder?.buildWheel();
    }
    @objc(getCar)
    func getCar() -> Car {
        return (builder?.getCar())!;
    }
}

4、详细的运用, 我这儿是OC与swift混编的

PorscheBuilder *builder = [[PorscheBuilder alloc] init];
Director *director = [Director director:builder];
[director produceCar];
Car *posche = [director getCar];
NSLog(@"posche的信息：%@", posche.description);

四、对这个规划形式的一些疑问？

  1. 为什么要有Director类？把produceCar办法放到对应的结构器PorscheBuilder里边不好吗？
    答 : 出产各种车子的过程逻辑是相同的，不相同的当地是不同的结构器比方PorscheBuilder、Porsche2Builder，所以出产车的办法produceCar应该要抽取出来。
  2. 为什么要将出产车的部件PorscheBuilder 与拼装车Car分成两个类完成？
    答：由于拼装车的逻辑是相同的，只要出产车的各个部件是不相同的，这样别离事务使得咱们更方便得拓宽一个新的结构器。
  3. 综上所述，生成器形式适用的条件：

1.结构产品对象时所需求的参数比较多，结构过程能够分过程，每个过程所需参数不同。
2.项目中结构的最终产品对象都是车子，可是结构过程中运用参数不相同，特定的结构器下，运用的是特定的一组参数，比方上面比如中保时捷和破二手车。