设计模式-生成器模式

前两个文章我介绍了工厂方法模式和抽象工厂模式，这次我来讲一些生成器模式。生成器模式我也用的比较多。5个创建型模式里面，我比较喜欢用工厂方法模式，生成器模式和单例模式。

 

意图

将一个复杂对象的构建与它的表示分开，使得同样的构建过程可以创建不同的表示。

 

结构图

 

 

一眼看去是不是和抽象工厂模式有点像？是啊，我也觉得很像，有什么分别呢？别急，让我先讲一下builder 模式是怎么实现的。

为了更好的来解释生成器模式，我这里还画了个序列图，这个序列图清楚地描述了客户端是如何来使用生成器的。

 

 

我们还是以之前讲过的跑酷游戏的地形为例。先给出所有相关类的图：

产品类，没有变化，直接给出代码：

class CComponent
{
public:
	virtual void LoadPicture() = 0;
};

class CTerrain
{
public:

	virtual void SetBackground(CComponent* bg)
	{
		if (m_BackGround)
		{
			delete m_BackGround;
		}
		m_BackGround = bg;
	}
	virtual void SetGround(CComponent* ground)
	{
		if (m_Ground)
		{
			delete m_Ground;
		}
		m_Ground = ground;
	}


	CTerrain()
	{
		m_BackGround = NULL;
		m_Ground = NULL;
	}
	virtual ~CTerrain()
	{
		if (m_BackGround)
		{
			delete m_BackGround;
			m_BackGround = NULL;
		}

		if (m_Ground)
		{
			delete m_Ground;
			m_Ground = NULL;
		}
	}
protected:
	CComponent* m_BackGround;
	CComponent* m_Ground;

};



class CSnowBackground: public CComponent
{
public:
	virtual void LoadPicture()
	{
		std::cout<< "Load snow background picture \n"; 
	}
};

class CSnowGround: public CComponent
{
public:
	virtual void LoadPicture()
	{
		std::cout<< "Load snow ground picture\n"; 
	}
};

 

然后是关键的Builder类，首先我们抽象一个CBuilder类：

class CBuilder
{
public:
	virtual void MakeBackground() = 0;
	virtual void MakeGround() = 0;
	virtual CTerrain* GetTerrain() = 0;
};

 

里面有3个接口：

1. 创建一个背景实例，构建CTerrain对象的背景；

2. 创建一个地面实例，构建CTerrain对象的地面；

3. 返回一个CTerrain实例（Terrain由背景和地面组成）

注意这3个函数里面，只有第三个函数才返回一个CTerrain实例，另外2个函数都不返回任何东西。

接下来让我们看看CBuilder的一个具体实现子类：

class CSnowTerrainBuilder: public CBuilder
{
public:
	virtual void MakeBackground()
	{
		CComponent* bk = new CSnowBackground();
		bk->LoadPicture();
		_Terrain->SetBackground(bk);
	}
	virtual void MakeGround()
	{
		CComponent* ground = new CSnowGround();
		ground->LoadPicture();
		_Terrain->SetGround(ground);
	}
	virtual CTerrain* GetTerrain()
	{
		return _Terrain;
	}

	CSnowTerrainBuilder()
	{
		_Terrain = new CTerrain();
	}
protected:
	CTerrain* _Terrain;
};

从代码里面可以看到，我们在CSnowTerrainBuilder里面增加了一个CTerrain*的数据成员。也就是说CSnowTerrainBuilder聚合了一个CTerrain对象。

MakeBackground()和MakeGround()生成了2个CTerrain的组件，并且把生成的组件放到CTerrain对象里面(也就是构建CTerrain对象)。

下面我们来看一下CCreator类（也就是Builder模式里面的Director）

class CCreator
{
public:
	virtual CTerrain* Create(CBuilder& builder)
	{
		builder.MakeBackground();
		builder.MakeGround();

		return builder.GetTerrain();
	}
};

这个函数跟抽象工厂里面的那个函数很像，但是我们可以发现，抽象工厂CCreator::Create()里面的其中4行代码在生成器模式里面并没有：

class CCreator
{
public:
	void Create(CFactory& factory, CTerrain** t, CWeather** w)
	{
		CTerrain* terrain = factory.MakeTerrain();
		CComponent* bg = factory.MakeBackground();
		CComponent* ground = factory.MakeGround();
                
                //下面这4行代码并没有出现在Builder模式的版本里面，哪里去了呢？
                bg->LoadPicture();
		ground->LoadPicture();
		terrain->SetBackground(bg);
		terrain->SetGround(ground);

		CWeather* weather = factory.MakeWeather();

		*t = terrain;
		*w = weather;
	}
};

哈哈，看一下CSnowTerrainBuilder的代码就明白了，原来这些代码跑到CSnowTerrainBuilder里面去了。也也就是生成器模式的一个特点，把对象的构建给分离出去了（这些构建代码跑到Builder类里面去了）。

然后再看一下生成器模式的CCreator::Create()，我们会发现CCreator并不知道CTerrain的内部表示（MakeBackground和MakeGround并没有返回任何东西）。从接口名字也许可以知道Builder在创建背景和地面实例，但是并不知道具体在创建什么实例。从类图的角度讲生成器模式的Director（CCreator）类并不依赖于背景类和地面类。而抽象工厂模式却是依赖的。用G4的说法就是：生成器隐藏了对象CTerrain的内部表示。这就使得改变CTerrain的内部表示要容易一些，因为所有CBuilder的客户都不需要被改变。

 

最后看看客户端是怎么调用的：

CSnowTerrainBuilder builder;
	CCreator creator;
	creator.Create(builder);

	CTerrain* snowTerrain = builder.GetTerrain();//snowTerrain 就是builder创建出来的地形实例
	//这里可以用snowTerrain来做一些其他的事情

	delete snowTerrain;

相当的easy。

假如要build一个新的地形，比如森林地形，很简单，增加一个CBuilder的子类：CForestTerrainBuilder，然后在客户端里面创建一个CForestTerrainBuilder的对象，传给CCreator就ok了。

好了，生成器模式基本介绍完毕。文章的开始我们就讲了生成器模式和抽象工厂模式很像。那么到底有什么分别呢？

我们可以总计一下：

1. 抽象工厂模式的工厂类提供了一系列创建对象的接口，这些接口里面仅仅创建对象，而没有任何构建的动作。而生成器模式的builder类里面提供的接口实现了对象的构建。

2. 抽象工厂模式的工厂类的每一个接口都返回一个对象。而生成器模式的builder类的接口里面，只有一个函数返回最后构建完毕的对象，其他所有的接口并不返回任何东西。

3. 生成器模式着重于一步一步构造一个复杂对象。而抽象工厂模式着重于多个系列的产品对象（简单或者复杂的）。

4. 生成器模式在最后一步才返回产品，而抽象工厂模式是立即返回。

 

我个人的习惯就是当一个对象比较复杂的时候，比如这个对象有很多其他对象组成，然后这些组成相对比较容易会变动时，用Builder模式比较合适。