漫谈设计模式之建造者模式（Builder）

建造者模式（Builder）又叫生成器模式，属于对象创建型模式。

建造者模式的目的是要将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示（产品）。说得通俗点就是一个产品（表示）的构建（生产）过程是一样的，但是同样的生产过程却可以生产出不同的表示（产品）。比如，建房子都要做门窗，砌墙等流程，但是同样的流程（做门窗、砌墙）造出来的房子可能是公寓也可以是别墅。

建造者模式的参与角色：

建造者（Builder）：给出一系列抽象接口，规范建造者对于生产的产品的各个组成部分的建造。这个接口只是定一个规范，不涉及具体的建造，具体的建造让继承于它的子类（ConcreteBuilder）去实现。

具体的建造者（ConcreteBuilder）：继承自Builder，实现Builder接口，针对不同的商业逻辑，具体化对象各部分的建造，最后返回一个建造好的产品。

导演（Director）：Director也可叫指挥官吧，指挥官负责规范流程。指挥官不负责产品的创建，只负责保证复杂对象各部分被创建或按照某种顺序被创建。

产品（Product）：复杂对象。由指挥官指挥继承自建造者的具体建造者创建的具体复杂对象。

建造者模式UML结构类图：





//以下部分是摘录自网络上和上面建造者模式的参与角色可能有雷同，但是LZ觉得以下的总结更好！！！



四个要素
产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。



示例代码：

#include <iostream>

using namespace std;

/**
* @brief The House class
* 事物的表示
*/
class House
{
public:
void setDoor(string door) {
this->m_door = door;
//cout<<this->m_door<<endl;
}

void setWall(string wall) {
this->m_wall = wall;
//cout<<this->m_wall<<endl;
}

void setWindow(string window) {
this->m_window = window;
//cout<<this->m_window<<endl;
}

string getDoor() {
cout<<this->m_door<<endl;
return this->m_door;
}

string getWall() {
cout<<this->m_wall<<endl;
return this->m_wall;
}

string getWindow() {
cout<<this->m_window<<endl;
return this->m_window;
}

private:
string m_door;
string m_wall;
string m_window;
};

/**
* @brief The Builder class
* 抽象建造者：负责构建产品的各个部分
*/
class Builder
{
public:
virtual ~Builder() {}
virtual void makeDoor()=0;
virtual void makeWall()=0;
virtual void makeWindow()=0;
virtual House* getHouse()=0;
};

/**
* @brief The FlatBuilder class
* 具体的建造者：构建具体的产品（公寓）
*/
class FlatBuilder : public Builder
{
public:
FlatBuilder() {
m_house = new House();
}

virtual void makeDoor() {
m_house->setDoor("flat house door");
}

virtual void makeWall() {
m_house->setWall("flar house wall");
}

virtual void makeWindow() {
m_house->setWindow("flat house window");
}

virtual House* getHouse() {
return m_house;
}

private:
House* m_house;

};

/**
* @brief The VillaBuile class
* 具体的建造者：构建具体的产品（别墅）
*/
class VillaBuiler : public Builder
{
public:
VillaBuiler() {
m_house = new House();
}

virtual void makeDoor() {
m_house->setDoor("villa house door");
}

virtual void makeWall() {
m_house->setWall("villa house wall");
}

virtual void makeWindow() {
m_house->setWindow("villa house window");
}

virtual House* getHouse() {
return m_house;
}

private:
House* m_house;
};

/**
* @brief The Director class
* 指挥者（导演）：负责指挥建造者
* 建造者负责具体的实施工作
*/
class Director
{
public:
Director(Builder* builder) {
m_builder = builder;
}

void Construct() {
m_builder->makeDoor();
m_builder->makeWall();
m_builder->makeWindow();
}

private:
Builder* m_builder;
};

int main()
{

House* house = NULL;
Builder* builder = NULL;
Director* director = NULL;

//别墅建造者
builder = new VillaBuiler();
//指挥者指挥别墅建造者造别墅
director = new Director(builder);
director->Construct();
house = builder->getHouse();
house->getDoor();
house->getWall();
house->getWindow();

delete house;
house = NULL;
delete builder;
builder = NULL;
delete director;
director = NULL;

cout<<"--------------------"<<endl;

//公寓建造者
builder = new FlatBuilder;
//指挥者指挥公寓建造者造公寓
director = new Director(builder);
director->Construct();
house = builder->getHouse();
house->getDoor();
house->getWall();
house->getWindow();

delete house;
house = NULL;
delete builder;
builder = NULL;
delete director;
director = NULL;

return 0;
}


运行结果：









建造者模式的优缺点：

首先，建造者模式的封装性很好。使用建造者模式可以很好地封装变化。在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。

其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

建造者模式与工厂模式的区别：

建造者模式与工厂模式是极为相似的，总体上，建造者模式只比工厂模式多了个“导演类”角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中的剩余部分就可以看做是一个简单的工厂模式了。

与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类----导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给

导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。

建造者模式与工厂模式类似，它们都属于创建型设计模式，适用的场景也很相似。一般来说，如果产品的创建很复杂用工厂模式；如果产品的创建更复杂，那么请用建造者模式。