定义：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类
示例一：工厂方法模式（通用版）
1.类图8-2
2. 类图说明：
Product 抽象产品类，负责定义产品的共性，实现对事物最抽象的定义
Creator 抽象创建类，即抽象工厂
ConcreteCreator 具体实现工厂，创建产品类
3. 代码清单8-8:
********** 通用工厂，代码清单8-8: ***************//
#include <QCoreApplication>
#include <QDebug>
enum E_Product
{
EConcreteProduct1 ,
EConcreteProduct2
};
class Product //产品类的公共方法
{
public:
virtual void method1() = 0;
virtual void method2() = 0;
};
class ConcreteProduct1:public Product //具体产品类
{
public:
virtual void method1(){}
virtual void method2(){qDebug() << "ConcreteProduct1 method";}
};
class ConcreteProduct2:public Product //具体产品类
{
public:
virtual void method1(){}
virtual void method2(){qDebug() << "ConcreteProduct2 method";}
};
class Creator //抽象工厂类
{
public:
virtual Product* createProduct(E_Product eenum) = 0;
};
class ConcreteCreator:public Creator //具体工厂类
{
public:
virtual Product* createProduct(E_Product eenum)
{
Product* product;
switch(eenum)
{
case EConcreteProduct1:
product = new ConcreteProduct1();
break;
case EConcreteProduct2:
product = new ConcreteProduct2();
break;
}
return product;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Creator *creator = new ConcreteCreator();
Product *product = creator->createProduct(EConcreteProduct1);
product->method2();
return a.exec();
}
示例二：女娲造人
1.类图8-1
2. 类图说明：
AbstractHumanFactory ：是一个抽象类，定义了一个八卦炉具有的整体功能
HumanFactory ：为实现类，完成具体的任务——创建人类
Human ：接口是人类的总称，其三个实现类分别为三类人种
NvWa ：类是一个场景类，负责模拟这个场景，执行相关的任务
其中，定义每个人种都有两个方法：getColor(获得人的皮肤颜色) 和 talk(交谈)
3. 代码清单8-1:
********** 女娲造人，代码清单8-1: ***************//
#include <QCoreApplication>
#include <QDebug>
enum E_Human
{
EBlackHuman ,
EYellowHuman ,
EWhiteHuman
};
class Human
{
public:
virtual void getColor() = 0; //每个人种的皮肤都有相应的颜色
virtual void talk() = 0; //人类会说话
};
class BlackHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Black";}
virtual void talk(){qDebug() << "Black talk";}
};
class YellowHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Yellow";}
virtual void talk(){qDebug() << "Yellow talk";}
};
class WhiteHuman:public Human
{
public:
virtual void getColor(){qDebug() << "White";}
virtual void talk(){qDebug() << "White talk";}
};
class AbstractHumanFactory
{
public:
virtual Human* createHuman(E_Human nnum) = 0;
};
class HumanFactory:public AbstractHumanFactory
{
public:
virtual Human* createHuman(E_Human nnum)
{
Human* human;
switch(nnum)
{
case EBlackHuman:
human = new BlackHuman();
break;
case EYellowHuman:
human = new YellowHuman();
break;
case EWhiteHuman:
human = new WhiteHuman();
break;
}
return human;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
AbstractHumanFactory *factory = new HumanFactory();
Human *white = factory->createHuman(EWhiteHuman);
white->getColor();
white->talk();
Human *yellow = factory->createHuman(EYellowHuman);
yellow->getColor();
yellow->talk();
Human *black = factory->createHuman(EBlackHuman);
black->getColor();
black->talk();
return a.exec();
}
三、工厂方法模式的应用
优点：
- 良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以，不用知道创建对象的过程，降低模块间的耦合
- 扩展性好。在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以“拥抱变化”。例如，在例子中的，需要增加一个棕色人种，只需要增加一个BrownHuman类，工厂类不用任何修改就可以完成系统扩展
- 屏蔽产品类。产品类的实现如何变化，调用者不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不用发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。例如：数据库开发中，如果使用JDBC链接数据库，数据库从MySQL切换到Oracle，需要改动的地方就是切换一下驱动名称（前提条件是SQL语句是标准语句），其他都不需要修改，这是工厂方法灵活性的一个直接案例
- 典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不关心，符合迪米特法则，不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；还符合里氏替换原则，使用产品子类替换产品父类
四、工厂方法的使用场景
- 工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，但需要慎重地考虑是否要增加一个工厂类进行管理，增加代码的复杂度
- 需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。万物皆对象，那万物也就皆产品类。例如，需要设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3, IMAP, HTTP，我们就可以把这三种连接方法作为产品类，定义一个接口如 IConnectMail，然后定义对邮件的操作方法，用不同的方法实现是哪个具体的产品类（也就是连接方式）再定义一个工厂方法，按照不同的传入条件，选择不同的链接方式。如此设计，可以做到完美的扩展，如叩谢邮件服务器提供了 WebService 接口，那我们只要增加一个产品类就可以了
- 可以使用在异构项目中，通过WebService与一个非C++的项目交互
- 可以使用在测试驱动开发的框架下。例如，测试一个类A，就需要把与类A有关联关系的类B也同时产生出来，我们可以使用工厂方法把类B虚拟出来，避免类A与类B的耦合
五、工厂方法的扩展
工厂模式有很多扩展，下面介绍4种
5-1. 缩小为简单工厂模式
场景：一个模块仅需要一个工厂类，没有必要把他产生出来，使用静态的方法就可以了，根据这一要求，把上例中的 AbstarctHumanFactory 修改一下
示例三：简单工厂模式
1. 类图8-3
分析：在类图中去掉了 AbstarctHumanFactory 抽象类，同时把 createHuman 方法设置为静态类型，简化了创建过程
2. 代码清单8-13:
********** 1.扩展：简单工厂模式，代码清单8-13: ***************//
enum E_Human
{
EBlackHuman ,
EYellowHuman ,
EWhiteHuman
};
class Human
{
public:
virtual void getColor() = 0; //每个人种的皮肤都有相应的颜色
virtual void talk() = 0; //人类会说话
};
class BlackHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Black";}
virtual void talk(){qDebug() << "Black talk";}
};
class YellowHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Yellow";}
virtual void talk(){qDebug() << "Yellow talk";}
};
class WhiteHuman:public Human
{
public:
virtual void getColor(){qDebug() << "White";}
virtual void talk(){qDebug() << "White talk";}
};
class HumanFactory
{
public:
static Human* createHuman(E_Human nnum)
{
Human* human;
switch(nnum)
{
case EBlackHuman:
human = new BlackHuman();
break;
case EYellowHuman:
human = new YellowHuman();
break;
case EWhiteHuman:
human = new WhiteHuman();
break;
}
return human;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Human *white = HumanFactory::createHuman(EWhiteHuman);
white->getColor();
white->talk();
Human *yellow = HumanFactory::createHuman(EYellowHuman);
yellow->getColor();
yellow->talk();
Human *black = HumanFactory::createHuman(EBlackHuman);
black->getColor();
black->talk();
return a.exec();
}
5-2. 升级为多个工厂类
场景：当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。例如，一个产品类具有5个具体实现，每个实现类的初始化（不仅仅是new,初始化包括new一个对象，并对对象设置一定的初始值）方法都不相同，如果卸载一个工厂方法中，势必会导致该方法巨大
解决：考虑到需要结构清晰，我们就为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。我们还以女娲造人为例，每个人种（具体的产品类）都对应了一个创建者，每个创建者都独立负责创建对应的产品对象，符合单一职责原则。
示例四：多个工厂类
1. 类图8-4
2. 代码清单8-14:
********** 2.扩展：多个工厂模式，代码清单8-14:***************//
class Human
{
public:
virtual void getColor() = 0; //每个人种的皮肤都有相应的颜色
virtual void talk() = 0; //人类会说话
};
class BlackHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Black";}
virtual void talk(){qDebug() << "Black talk";}
};
class YellowHuman:public Human
{
public:
virtual void getColor(){qDebug() << "Yellow";}
virtual void talk(){qDebug() << "Yellow talk";}
};
class WhiteHuman:public Human
{
public:
virtual void getColor(){qDebug() << "White";}
virtual void talk(){qDebug() << "White talk";}
};
class AbstractHumanFactory
{
public:
virtual Human* createHuman() = 0;
};
class BlackHumanFactory:public AbstractHumanFactory
{
public:
virtual Human* createHuman()
{
Human* human;
human = new BlackHuman();
return human;
}
};
class YellowHumanFactory:public AbstractHumanFactory
{
public:
virtual Human* createHuman()
{
Human* human;
human = new YellowHuman();
return human;
}
};
class WhiteHumanFactory:public AbstractHumanFactory
{
public:
virtual Human* createHuman()
{
Human* human;
human = new WhiteHuman();
return human;
}
};
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
AbstractHumanFactory *wFactory = new WhiteHumanFactory();
Human *white = wFactory->createHuman();
white->getColor();
white->talk();
AbstractHumanFactory *yFactory = new YellowHumanFactory();
Human *yellow = yFactory->createHuman();
yellow->getColor();
yellow->talk();
AbstractHumanFactory *bFactory = new BlackHumanFactory();
Human *black = bFactory->createHuman();
black->getColor();
black->talk();
return a.exec();
}
分析：每一个产品类都对应了一个创建类，好处是创建类的职责清晰，而且结构简单，但是给可扩展性和可维护性带来了影响。比如，如果要扩展一个产品类，就需要建立一个响应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同，维护时需要考虑两个对象之间的关系。
注：在复杂的应用中一般采用多工厂的方法，然后再增加一个协调类，避免调用者与各个子工厂交流，协调类的作用是封装工厂类，对高层模块提供统一的访问接口
5-3. 替代单例模式
场景：单例博士的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象
示例五：替代单例模式
1. 类图8-5
2. 类图说明：
Singleton 定义了一个private 的无参构造函数，目的是不允许通过new的方式创建一个对象。Singleton保证不能通过正常的渠道建立一个对象，那么使用SingletonFactory通过反射方式创建。通过获得类构造器，然后设置访问权限，生成一个对象，然后提供外部访问，保证内存中的对象唯一。
分析：以下通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。
3. 代码清单8-15:
#include <QCoreApplication>
#include <QDebug>
using namespace std;
// ********** 3.扩展：替代单例模式，代码清单8-15::***************//
class Singleton
{
public:
void doSomething(){qDebug() << "Singleton doSomething";}
friend class SingletonFactory;
private:
Singleton(){}
};
class SingletonFactory
{
public:
static Singleton* getSingleton()
{
return m_singleton;
}
private:
static Singleton* m_singleton;
};
Singleton* SingletonFactory::m_singleton = new Singleton();
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
Singleton* singleton = SingletonFactory::getSingleton();
singleton->doSomething();
return a.exec();
}
5-4. 延迟初始化
场景：为何延迟初始化？一个对象被消费完毕后，不立刻释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂方法模式的一个扩展应用。
分析：ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重用的对象保留。
示例六：延迟初始化
1. 类图8-6
2. 代码清单8-16:
#include <QCoreApplication>
#include <QDebug>
using namespace std;
// ********** 4.扩展：延迟初始化，代码清单8-16:***************//
class Product //产品类的公共方法
{
public:
virtual void method1() = 0;
virtual void method2() = 0;
};
class ConcreteProduct1:public Product //具体产品类
{
public:
virtual void method1(){}
virtual void method2(){qDebug() << "ConcreteProduct1 method";}
};
class ConcreteProduct2:public Product //具体产品类
{
public:
virtual void method1(){}
virtual void method2(){qDebug() << "ConcreteProduct2 method";}
};
class ProductFactory
{
public:
static Product* createProduct(QString type)
{
Product* product = nullptr;
QHash<QString, Product>::const_iterator iter = m_prMap.constBegin();
while (iter != m_prMap.constEnd())
{
if (iter.key() == type)
{
product = iter.value();
}
else
{
if (type == "Product1")
{
product = new ConcreteProduct1();
}
else
{
product = new ConcreteProduct2();
}
m_prMap.insert(type, product);
}
++iter;
}
}
private:
static QHash<QString,*Product> m_prMap;
};
QHash<QString,Product> ProductFactory::m_prMap;
代码说明：
通过定义一个QHash容器，容纳所有生产对象，如果在QHash容器中已经有的对象，则直接取出返回；如果没有，则根据需要的类型产生一个对象并放入到QHash中，方便下次调用。
延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断QHash中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC链接数据库，都会要求设置一个MaxConnections最大连接数量，该数量就是内存汇总最大实例化的数量。
延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，设计多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。
参考文献《秦小波. 设计模式之禅》（第2版） (华章原创精品) 机械工业出版社
扫一扫
1636
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
