设计模式读书笔记3-工厂方法模式

上一篇的简单工厂模式虽然简单，但是存在一个很严重的问题：当系统中需要引入新产品时，由于静态工厂方法通过所传入参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背开闭原则。如何实现新增新产品而不影响已有代码？工厂方法模式为此应运而生。

    工厂方法模式（Factory Method） 	学习难度：★★☆☆☆ 	使用频率：★★★★★

1. 工厂方法模式的引入

我们紧接上章，简单工厂模式，其核心代码为

Human *CreateHuman(char *pString)
{
	Human *pHuman = NULL;
	if(0 == strcmp(pString, "Whiteman"))
	{
		pHuman = (Human *)CreateWhiteHuman();
	}
	else if(0 == strcmp(pString, "Blackman"))
	{
		pHuman = (Human *)CreateBlackHuman();
	}
	else if(0 ==  strcmp(pString, "Yellowman"))
	{
		pHuman = (Human *)CreateYellowHuman();
	}
	else
	{
		printf("not support\n");
	}

	
	return pHuman;
}

void DeleteHumanFactory(AbstractFactory *pHumanFactory)
{
	if(NULL != pHumanFactory)
	{
		free(pHumanFactory);
		pHumanFactory = NULL;
	}

	return;
}

AbstractFactory *CreateHumanFactory(void)
{
	AbstractFactory *pAbstractFactory = (AbstractFactory *)malloc(sizeof(AbstractFactory));
	if(!pAbstractFactory)
	{
		return NULL;
	}

	pAbstractFactory->CreateHuman        = CreateHuman;
	pAbstractFactory->DeleteHumanFactory = DeleteHumanFactory;
	
	return pAbstractFactory;
}

　　上述代码省了具体的Human的初始化代码，在AbstractFactory中提供了静态的方法，CreateHuman(),用于根据传入的参数不同创建各种不同肤色的人的实体。通过使用简单工厂模式，将Human对象的创建和使用分离，客户端只需要使用由工厂类创建的Factory对象即可，无须关心对象的创建过程。
But，虽然简单工厂模式实现了对象的创建和使用分离，仍然存在以下两个问题：

1. 工厂类过于庞大！包含了大量的if-else代码，维护和测试的难度增大不少
2. 系统扩展不灵活，如果新增类型，必须修改静态工厂方法的业务逻辑，违反了开闭原则.
3. 所有产品类放到一个工厂方法中进行初始化，使得代码结构不清晰。例如，一个产品类有5个对象实现，每个实现类的初始化方法都不一样，如果写在一个工厂方法中，势必会导致方法巨大无比

如何解决这两个问题，M公司程序猿苦思冥想，想要改进简单工厂模式，于是开始学习工厂方法模。考虑到需要结构清晰，我们就需要为每一个产品定义一个创造者，然后调用者自己选择与哪个工厂方法关联，还是以女蜗造人为例，每个人都有一个固定的八卦图，分别造出黑色人种，白色人种，黄色人种，其类图为

2 工厂方法模式介绍

2.1 工厂方法模式概述

　　在简单工厂模式中只提供一个工厂类，该工厂类需要知道每一个产品对象的创建细节，并决定合适实例化哪一个产品类。其最大的缺点就是当有新产品加入时，必须修改工厂类，需要在其中加入必要的业务逻辑，这违背了开闭原则。此外，在简单工厂模式中，所有的产品都由同一个工厂创建，工厂类职责较重，业务逻辑较为复杂，具体产品与工厂类之间的耦合度较高，严重影响了系统的灵活性和扩展性。

　　在工厂方法模式中，不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。

工厂方法（Factory Method）模式：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。

工厂方法模式让一个类的实例化延迟到其子类。工厂方法模式又简称为工厂模式，也可称为多态工厂模式，它是一种创建型模式。　　

2.2 工厂方法模式结构图

工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法，而由其子类来具体实现工厂方法并创建具体的产品对象。

从图中可以看出，在工厂方法模式结构图中包含以下4个角色：

1. Product（抽象产品）：定义产品的接口，是工厂方法模式所创建的对象的超类，也就是产品对象的公共父类。
2. ConcreteProduct（具体产品）：它实现了抽象产品接口，某种类型的具体产品由专门的具体工厂创建，具体工厂和具体产品之间一一对应。
3. Factory（抽象工厂）：抽象工厂类，声明了工厂方法，用于返回一个产品。
4. ConcreteFactory（具体工厂）：抽象工厂的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

2.3 抽象产品

typedef struct _Human Human;
struct _Human
{
	void (*getColor)(void);
	void (*talk)(void);
};

2.4 具体工厂

typedef struct _BlackHuman BlackHuman;
struct _BlackHuman
{
	Human human;
	void (*BlackGetColor)(void);
	void (*BlackTalk)(void);
	void (*BlackHumanDelete)(BlackHuman *pBlackHuman);
};

2.5 具体产品

void BlackGetColor(void)
{
	printf("black get color\n");
}

void BlackTalk(void)
{
	printf("black talk\n");
}

void BlackHumanDelete(BlackHuman *pBlackHuman)
{
	if(!pBlackHuman)
	{
		free(pBlackHuman);
		pBlackHuman = NULL;
	}
	
	return;
}

BlackHuman *CreateBlackHuman(void)
{
	BlackHuman *pBlackHuman       = (BlackHuman *)malloc(sizeof(BlackHuman));
	pBlackHuman->BlackGetColor    = BlackGetColor;
	pBlackHuman->BlackTalk        = BlackTalk;
	pBlackHuman->BlackHumanDelete = BlackHumanDelete;
	pBlackHuman->human.getColor   = pBlackHuman->BlackGetColor;
	pBlackHuman->human.talk       = pBlackHuman->BlackTalk;
	
	return pBlackHuman;
}

2.6 抽象工厂

1. 白人的抽象

Human *CreateWhiteHumanFactory(void)
{
	Human *pHuman = (Human *)CreateWhiteHuman();;

	return pHuman;
}

2. 黑人的抽象

Human *CreateBlackHumanFactory(void)
{
	Human *pHuman = (Human *)CreateBlackHuman();;

	return pHuman;
}

客户端代码

int main(void)
{
		Human *pwhiteHuman  = NULL;
		Human *pblackHuman = NULL;

		pwhiteHuman = CreateWhiteHumanFactory();
		pwhiteHuman->getColor();
		pwhiteHuman->talk();

		
		pblackHuman = CreateBlackHumanFactory();
		pblackHuman->getColor();
		pblackHuman->talk();
}

我们回顾一下，每一个产品结构都对应了一个创建抽象的结构，好处就是创建抽象结构的职责清晰，而且结构简单，但是给可扩展和可维护性都带来了一定的影响。为什么这么说，那么如果我们需要扩展一个产品，就需要建立一个工厂结构和产品结构，维护时候也要维护两个结构对象。

3 工厂方法总结

3.1 主要优点

1. 工厂方法用于创建客户所需要的产品，还向客户隐藏了哪种具体产品类将被实例化这一细节。因此，用户只需要关心所需产品对应的工厂，无须关心创建细节。
2. 在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，也无须修改客户端，还无须修改其他的具体工厂和具体产品，而只要加入一个具体工厂和具体产品就可以了。因此，系统的可扩展性得到了保证，符合开闭原则。

3.2 主要缺点

1. 在添加新产品时，需要编写新的具体产品类，还要提供与之对应的具体工厂类，系统中类的个数将成对增加，一定程度上增加了系统的复杂度。
2. 由于考虑到系统的可扩展性，需要引入抽象层，且在实现时可能需要用到反射等技术，增加了系统的实现难度

3.3 适用场景

1. 客户端不知道其所需要的对象的类。在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的的工厂即可，具体的产品对象由具体工厂创建，可将具体工厂的类名存储到配置文件或数据库中。
2. 抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中，抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏替换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统易于扩展。

4 参考资料

秦晓波， 《设计模式之禅》

刘伟，《设计模式的艺术—软件开发人员内功修炼之道》