【设计模式 - 创建型模式】1. 工厂模式
工厂模式(Factory Pattern)是最常用的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
其介绍如下:
- 意图:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。
- 主要解决:主要解决接口选择的问题。
- 何时使用:我们明确地计划不同条件下创建不同实例时。
- 如何解决:让其子类实现工厂接口,返回的也是一个抽象的产品。
- 关键代码:创建过程在其子类执行。
- 应用实例: 您需要一辆汽车,可以直接从工厂里面提货,而不用去管这辆汽车是怎么做出来的,以及这个汽车里面的具体实现。
- 优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。
- 缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。这并不是什么好事。
- 使用场景: 1、日志记录器:记录可能记录到本地硬盘、系统事件、远程服务器等,用户可以选择记录日志到什么地方。 2、数据库访问,当用户不知道最后系统采用哪一类数据库,以及数据库可能有变化时。 3、设计一个连接服务器的框架,需要三个协议,"POP3"、"IMAP"、"HTTP",可以把这三个作为产品类,共同实现一个接口。
- 注意事项:作为一种创建类模式,在任何需要生成复杂对象的地方,都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式,而简单对象,特别是只需要通过 new 就可以完成创建的对象,无需使用工厂模式。如果使用工厂模式,就需要引入一个工厂类,会增加系统的复杂度。
一、简单工厂模式
举个例子,直接 new 对象的方式相当于当我们需要一个苹果时,我们需要知道苹果的构造方法,要一个梨子时,需要知道梨子的构造方法。更好的实现方式是有一个水果工厂,我们告诉工厂需要什么种类的水果,水果工厂将我们需要的水果制造出来给我们就可以了。这样我们就无需知道苹果、梨子是怎么种出来的,只用和水果工厂打交道即可。
步骤 1
创建基类 - 水果产品类:
class Fruit
{
public:
Fruit();
float getPrice(); // 创建一个接口:获取水果价格
};
步骤 2
创建派生类 - 苹果产品类:
class Apple : public Fruit
{
public:
Apple();
// Override
float getPrice() {
return 8.0;
}
};
创建派生类 - 梨子产品类:
class Pear : public Fruit
{
public:
Pear();
// Override
float getPrice() {
return 5.0;
}
};
步骤 3
创建一个工厂,生成基于给定类型信息的实体水果产品类的对象。
class FruitFactory
{
public:
FruitFactory();
Fruit *crate(string typeName) {
if(typeName == "Apple")
return new Apple();
else if (typeName == "Pear")
return new Pear();
else
printf("暂时没有这种水果");
return nullptr;
}
};
步骤 4
调用者:使用该工厂,通过传递类型信息来获取实体类的对象。
int main(int argc, char *argv[])
{
// 创建水果工厂对象
FruitFactory *fruitFactory = new FruitFactory();
// 使用水果工厂,创建苹果产品对象
Apple *pApple = (Apple *)fruitFactory->crate("Apple");
printf("Apple: %f\n", pApple->getPrice());
// 使用水果工厂,创建梨子产品对象
Pear *pPear = (Pear *)fruitFactory->crate("Pear");
printf("Pear: %f\n", pPear->getPrice());
}
输出如下:
Apple: 8.000000
Pear: 5.000000
另外一个优点
事实上,将构建过程封装的好处不仅可以降低耦合,如果某个产品构造方法相当复杂,使用工厂模式可以大大减少代码重复。比如,如果生产一个苹果需要苹果种子、阳光、水分,将工厂修改如下:
class FruitFactory
{
public:
FruitFactory();
Fruit *crate(string typeName) {
if(typeName == "Apple") {
Appleseed appleseed = new Appleseed();
Sunlight sunlight = new Sunlight();
Water water = new Water();
return new Apple(appleseed, sunlight, water);
}
else if (typeName == "Pear")
return new Pear();
else
printf("暂时没有这种水果");
return nullptr;
}
};
这样 Apple 类的代码完全不需要变化,而且调用者不需要在每次需要苹果时,自己先去构建苹果种子、阳光、水分以获得苹果。假如某天科家发明了让苹果更香甜的肥料,要加入苹果的生产过程中的话,也只需要在工厂中修改,不需要修改 Apple 类。
不知不觉中,我们就写出了简单工厂模式的代码。工厂模式共有三种:
- 简单工厂模式
- 工厂方法模式
- 抽象工厂模式
注:在 GoF 所著的《议计模式》一书中,简单工厂模式被划分为工厂方法模式的一种特例,没有单独被列出来。
总而言之,简单工厂模式就是让一个工厂类承担构建所有对象的职责。调用者需要什么产品,让工厂生产出来即可。它的弊端也显而易见:
- 一是如果需要生产的产品过多,此模式会导致工厂类过于庞大,承担过多的职责,变成超级类。当苹果生产过程需要修改时,要来修改此工厂。梨子生产过程需要修改时,也要来修改此工厂。也就是说这个类不止一个引起修改的原因。违背了单一职责原则。
- 二是当要生产新的产品时,必须在工厂类中添加新的分支。而开闭原则告诉我们:类应该对修改封闭。我们希望在添加新功能时,只需增加新的类,而不是修改既有的类,所以这就违背了开闭原则。
二、工厂方法模式
为了解决简单工厂模式的这两个弊端,工厂方法模式应运而生,它规定每个产品都有一个专属工厂。比如苹果有专属的苹果工厂,梨子有专属的梨子工厂,C++ 代码如下:
苹果工厂:
class AppleFactory
{
public:
AppleFactory();
// Override
Fruit *crate() {
return new Apple();
}
};
梨子工厂:
class PearFactory
{
public:
PearFactory();
// Override
Fruit *crate() {
return new Pear();
}
};
调用者:
int main(int argc, char *argv[])
{
// 创建苹果工厂对象
AppleFactory *appleFactory = new AppleFactory();
// 创建苹果对象
Apple *pApple = (Apple *)appleFactory->crate();
printf("Apple: %f\n", pApple->getPrice());
// 创建梨子工厂对象
PearFactory *pearFactory = new PearFactory();
// 创建梨子对象
Pear *pPear = (Pear *)pearFactory->crate();
printf("Pear: %f\n", pPear->getPrice());
}
有读者可能会开喷了,这样和直接 new 出苹果和梨子有什么区别?上文说工厂是为了减少类与类之间的耦合,让调用者尽可能少的和其他类打交道。用简单工厂模式,我们只需要知道 FruitFactory,无需知道 Apple、Pear类,很容易看出耦合度降低了。但用工厂方法模式,调用者虽然不需要和 Apple、Pear类打交道了,但却需要和 AppleFactory、 PearFactory 类打交道。有几种水果就需要知道几个工厂类,耦合度完全没有下降啊,甚至还增加了代码量!
这位读者请先放下手中的大刀,仔细想想,工厂模式的第二个优点在工厂方法模式中还是存在的。当构建过程相当复杂时,工厂将构建过程封装起来,调用者可以很方便的直接使用,同样以苹果生产为例:
class AppleFactory
{
public:
AppleFactory();
Fruit *crate() {
Appleseed appleseed = new Appleseed();
Sunlight sunlight = new Sunlight();
Water water = new Water();
return new Apple(appleseed, sunlight, water);
}
};
调用者无需知道苹果的生产细节,当生产过程需要修改时也无需更改调用端。同时,工厂方法模式解决了简单工厂模式的两个弊端。
- 当生产的产品种类越来越多时,工厂类不会变成超级类。工厂类会越来越多,保持灵活。不会越来越大、变得臃肿。如果苹果的生产过程需要修改时,只需修改苹果工厂。梨子的生产过程需要修改时,只需修改梨子工厂。符合单一职责原则。
- 当需要生产新的产品时,无需更改既有的工厂,只需要添加新的工厂即可。保持了面向对象的可扩展性,符合开闭原则。
三、抽象工厂模式
工厂方法模式可以进一步优化,提取出工厂接口。
class IFactory
{
public:
IFactory();
virtual Fruit *create() = 0;
};
然后苹果工厂和梨子工厂都实现此接口:
class AppleFactory : public IFactory
{
public:
AppleFactory();
// Override
Fruit *create() {
return new Apple();
}
};
class PearFactory : public IFactory
{
public:
PearFactory();
// Override
Fruit *create() {
return new Pear();
}
};
此时,调用者可以将 AppleFactory 和 PearFactory 统一作为 Factory 对象使用,调用者 C++ 代码如下:
// 抽象工厂模式
int main(int argc, char *argv[])
{
// 苹果工厂
IFactory *pAppleFactory = new AppleFactory();
Fruit *pApple = pAppleFactory->create();
printf("Apple: %f\n", pApple->getPrice());
// 梨子对象
IFactory *pPearFactory = new PearFactory();
Fruit *pPear = pPearFactory->create();
printf("Pear: %f\n", pPear->getPrice());
}
输出如下:
Apple: 8.000000
Pear: 5.000000
可以看到,我们在创建时指定了具体的工厂类后,在使用时就无需再关心是哪个工厂类,只需要将此工厂当作抽象的 IFactory 接口使用即可。这种经过抽象的工厂方法模式被称作抽象工厂模式。
由于客户端只和 IFactory 打交道了,调用的是接口中的方法,使用时根本不需要知道是在哪个具体工厂中实现的这些方法,这就使得替换工厂变得非常容易。
例如:
int main(int argc, char *argv[])
{
IFactory *pFactory = new AppleFactory();
Fruit *pFruit = pFactory->create();
printf("Fruit: %f\n", pFruit->getPrice());
}
如果需要替换为获取梨子价格,只需要更改一行代码即可:
int main(int argc, char *argv[])
{
IFactory *pFactory = new PearFactory();
Fruit *pFruit = pFactory->create();
printf("Fruit: %f\n", pFruit->getPrice());
}
总结
IFactory 中只有一个抽象方法时,或许还看不出抽象工厂模式的威力。实际上抽象工厂模式主要用于替换一系列方法。例如将程序中的 SQL Server 数据库整个替换为 Access 数据库,使用抽象方法模式的话,只需在 IFactory 接口中定义好增删改查四个方法,让 SQLFactory 和 AccessFactory 实现此接口,调用时直接使用 IFactory 中的抽象方法即可,调用者无需知道使用的什么数据库,我们就可以非常方便的整个替换程序的数据库,并且让客户端亳不知情。
抽象工厂模式很好的发挥了开闭原则、依赖倒置原则,但缺点是抽象工厂模式太重了,如果 IFactory 接口需要新增功能,则会影响到所有的具体工厂类。使用抽象工厂模式,替换具体工厂时只需更改一行代码,但要新増抽象方法则需要修改所有的具体工厂类。所以抽象工厂模式适用于增加同类工厂这样的横向扩展需求,不适合新增功能这样的纵向扩展。
介绍抽象工厂模式好的还有另一篇文章:设计模式之抽象工厂模式(C++)
参考