设计模式-生成器

这里介绍一下设计模式中的生成器模式（或者称建造者模式）在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. 综上所述，生成器模式属于业务逻辑非常复杂的情形使用，生成器部分的业务逻辑不一样，其他两部分是一样的。