Builder模式又称建造者模式或者生成器模式，是GoF提出的23种设计模式之一。Builder模式是一种对象创建型模式之一，用来隐藏复合对象的创建过程，它把复合对象的创建过程加以抽象，通过子类继承和重载的方式，动态地创建具有复合属性的对象。
对象的创建：Builder模式是为对象的创建而设计的一种模式，创建的是一个复合对象，被创建的对象为一个具有复合属性的复合对象。关注对象创建的各部分的创建过程，不同的工厂（这里指Builder生成器）对产品属性有不同的创建方法。
- 角色和职责
Builder Pattern结构图
Builder模式的关键是其中的Director对象并不直接返回对象，而是通过一步步（BuildPartA，BuildPartB，BuildPartC）来一步步进行对象的创建。当然这里Director可以提供一个默认的返回对象的接口（即返回通用的复杂对象的创建，即不指定或者特定唯一指定BuildPart中的参数）。
1) Builder : 为创建产品各个部分，同一抽象接口。
2) ConcreteBuilder : 具体创建产品的各个部分，部分A，部分B，部分C。
3) Director : 构造一个使用Builder接口的对象。
4) Product : 表示被构造的复杂对象。
ConcreteBuilder 创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。
适用场景：当我们要创建的对象很复杂的时候（通常是由很多其他的对象组合而成），我们要要复杂对象的创建过程和这个对象的表示（展示）分离开来，这样做的好处就是通过一步步的进行复杂对象的构建，由于在每一步的构造过程中可以引入参数，使得经过相同的步骤创建最后得到的对象的展示不一样。
简单实现代码如下：
#include <iostream>
using namespace std;
//复杂对象的抽象类
class House
{
public:
void setDoor(string door) { m_door = door; }
void setWall(string wall) { m_wall = wall; }
void setWindow(string window) { m_window = window; }
string getDoor() { return m_door; }
string getWall() { return m_wall; }
string getWindow() { return m_window; }
private:
string m_door;
string m_wall;
string m_window;
};
//工程队的抽象类
class Builder
{
public:
virtual void buildDoor() = 0;
virtual void buildWall() = 0;
virtual void buildWindow() = 0;
virtual House* getHouse() = 0;
};
//负责建造公寓的工程队的抽象
class FlatBuilder : public Builder
{
public:
FlatBuilder() { m_pHouse = new House; }
virtual void buildWindow()
{
m_pHouse->setWindow("FlatWindow");
}
virtual void buildWall()
{
m_pHouse->setWall("FlatWadll");
}
virtual void buildDoor()
{
m_pHouse->setDoor("FlatDoor");
}
virtual House* getHouse()
{
return m_pHouse;
}
private:
House *m_pHouse;
};
//负责建造别墅的工程队的抽象
class VillaBuilder : public Builder
{
public:
VillaBuilder() { m_pHouse = new House; }
virtual void buildWindow()
{
m_pHouse->setWindow("VillaWindow");
}
virtual void buildWall()
{
m_pHouse->setWall("VillaWadll");
}
virtual void buildDoor()
{
m_pHouse->setDoor("VillaDoor");
}
virtual House* getHouse()
{
return m_pHouse;
}
private:
House *m_pHouse;
};
//设计师（指挥者） 负责建造逻辑
//指挥建筑队干具体的活
class Director
{
public:
Director(Builder *build)
{
m_pBuild = build;
}
void construct()
{
m_pBuild->buildWall();
m_pBuild->buildWindow();
m_pBuild->buildDoor();
}
private:
Builder *m_pBuild;
};
int main()
{
Builder *builder = NULL;
Director *dre = NULL;
House *house = NULL;
builder = new VillaBuilder();
dre = new Director(builder);
dre->construct();
house = builder->getHouse();
cout << (house->getWindow()).c_str() << endl;
delete house;
delete builder;
delete dre;
builder = new FlatBuilder();
dre = new Director(builder);
dre->construct();
house = builder->getHouse();
cout << (house->getWindow()).c_str() << endl;
delete house;
delete builder;
delete dre;
house = NULL;
builder = NULL;
dre = NULL;
return 0;
}
- 总结
GoF在《设计模式》一书中给出的关于Builder模式的意图是非常容易理解、间接的：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示（在示例代码中可以通过传入不同的参数实现这一点）。
Builder模式和AbstractFactory模式在功能上很相似，因为都是用来创建大的复杂的对象，它们的区别是：Builder模式强调的是一步步创建对象，并通过相同的创建过程可以获得不同的结果对象，一般来说Builder模式中对象不是直接返回的。而在AbstractFactory模式中对象是直接返回的，AbstractFactory模式强调的是为创建多个相互依赖的对象提供一个同一的接口。