【设计模式】之二十三种设计模式--建造者模式

建造者模式

Separate the construction of a complex object from its representation so that the same construction process can create different representations.
(将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。)

通用类图

产品类，实现模板方法模式，也就是模板方法和基本方法，如例子中的BenzModel和BWMModel
抽象建造者类，规范产品的组件，如例子中的CarModel
具体建造者类，继承抽象建造者类，依赖产品类。实现抽象类定义的所有方法，返回一个组建好的对象，如例子中的BenzBuilder和BWMBuilder
导演类，负责安排模块的顺序，和抽象建造者类是聚合关系。导演类起到封装的作用，避免高层模块深入到建造者内部的实现类。导演类可以有多个。

通用源代码

//产品类
class Product {
public:
    void doSomething() {
        //独立业务处理
    }
};
//抽象建造者
class Builder {
public:
    //设置产品的不同部分，以获得不同的产品
    virtual void setPart() = 0;
    //建造产品
    virtual Product buildProduct() = 0;
};
//具体建造者
class ConcreteProduct : public Builder {
private:
    Product product;
public:
    void setPart() {
        /*
         *产品类内的逻辑处理
         */
    }
    //组建一个产品
    Product buildProduct() {
        return product;
    }
};
//导演类
class Director {
private:
    Builder builder;
public:
    Product getAProduct() {
        builder.setPart();
        /*
         *设置不同的零件，产生不同的产品
         */
        return builder.buildProduct();
    }
};

优点

封装性，客户端不必知道内部组成的细节，直接获得想要的对象
建造者独立，容易扩展
便于控制细节风险

使用场景

相同的方法，不同的执行顺序，产生不同的事件结果
多个部件或零件，可以转配到一个对象中，但是产生的运行结果不相同
产品类非常复杂，或者产品类中的调用顺序不同产生不同的效能

注意事项

建造者模式关注的是零件类型和装配工艺(顺序)，这是它与工厂方法模式最大不同的地方，虽然同为创建类模式，但是注重点不同

扩展

产品类可以使用模板方法模式来实现零件的组装，使得组装顺序不同对象效能也不同
建造者模式vs工厂模式，建造者模式最主要的功能是基本方法的调用顺序安排，也就是基本方法默认已经实现；工厂方法模式的重点是创建，不关系组装顺序。

示例代码

#include <iostream>
#include <list>
#include <string>

using namespace std;

//使用模板方法模式实现零件的组装
class CarModel {
private:
    list<string> msequence;
protected:
    virtual void start() = 0;
    virtual void stop() = 0;
    virtual void alarm() = 0;
    virtual void engineBoom() = 0;
public:
    void run() {
        for(auto s : msequence) {
            if(s == "start") this->start();
            else if(s == "stop") this->stop();
            else if(s == "alarm") this->alarm();
            else if(s == "engineBoom") this->engineBoom();
            else cout << "undefined commend" << endl;
        }
    }
    void setSequence(list<string> sequence) {
        msequence = sequence;
    }
};

class BenzModel : public CarModel {
protected:
    virtual void start() {
        cout << "BenzModel start" << endl;
    }
    virtual void stop() {
        cout << "BenzModel stop" << endl;
    }
    virtual void alarm() {
        cout << "BenzModel alarm" << endl;
    }
    virtual void engineBoom() {
        cout << "BenzModel engineBoom" << endl;
    }
};

class BWMModel : public CarModel {
protected:
    virtual void start() {
        cout << "BWMModel start" << endl;
    }
    virtual void stop() {
        cout << "BWMModel stop" << endl;
    }
    virtual void alarm() {
        cout << "BWMModel alarm" << endl;
    }
    virtual void engineBoom() {
        cout << "BWMModel engineBoom" << endl;
    }
};

//抽象建造者类
class CarBuilder {
public:
    virtual void setSequence(list<string> sequence) = 0;
    virtual CarModel* getCarModel() = 0;
};

//两个具体建造者类
class BenzBuilder : public CarBuilder {
public:
    virtual CarModel* getCarModel() {
        return benz;
    }
    virtual void setSequence(list<string> sequence) {
        benz->setSequence(sequence);
    }
    ~BenzBuilder() {delete benz;}
private:
    BenzModel *benz = new BenzModel();
};

class BWMBuilder : public CarBuilder {
public:
    virtual CarModel* getCarModel() {
        return bwm;
    }
    virtual void setSequence(list<string> sequence) {
        bwm->setSequence(sequence);
    }
    ~BWMBuilder() {delete bwm;}
private:
    BWMModel* bwm = new BWMModel();
};

//导演类
class Director {
private:
    list<string> msequence;
    BenzBuilder benzBuilder;
    BWMBuilder bwmBuilder;
public:
    BenzModel* getABenzModel() {
        msequence.clear();
        msequence.push_back("start");
        msequence.push_back("stop");
        benzBuilder.setSequence(msequence);
        return dynamic_cast<BenzModel*>(benzBuilder.getCarModel());
    }
    BenzModel* getBBenzModel() {
        msequence.clear();
        msequence.push_back("engineBoom");
        msequence.push_back("start");
        msequence.push_back("stop");
        benzBuilder.setSequence(msequence);
        return dynamic_cast<BenzModel*>(benzBuilder.getCarModel());
    }
    BWMModel* getABWMModel() {
        msequence.clear();
        msequence.push_back("alarm");
        msequence.push_back("start");
        msequence.push_back("stop");
        bwmBuilder.setSequence(msequence);
        return dynamic_cast<BWMModel*>(bwmBuilder.getCarModel());
    }
    BWMModel* getBBWMModel() {
        msequence.clear();
        msequence.push_back("start");
        bwmBuilder.setSequence(msequence);
        return dynamic_cast<BWMModel*>(bwmBuilder.getCarModel());
    }
};

int main() {
    Director director;
    BWMModel *bwm = director.getABWMModel();
    bwm->run();
    return 0;
}