1 前言
工厂模式分类：
抽象工厂（Abstract Factory）：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道或关心实际产出的具体产品是什么。这样一来，客户就能从具体的产品中被解耦。
工厂方法（Factory Method）：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
简单工厂（Simple Factory）：简单工厂其实不是一个设计模式，比较像一种编程习惯，就是提供一个静态函数，根据不同的参数动态创建同一个类的不同子类对象。
工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。
2 抽象工厂
2.1 定义
提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。抽象工厂允许客户使用抽象的接口来创建一组相关的产品，而不需要知道或关心实际产出的具体产品是什么。这样一来，客户就能从具体的产品中被解耦。
2.2 适用场景
在以下情况可以使用Abstract Factory模式
- 一个系统要独立于它的产品的创建、组合和表示时
- 一个系统要由多个产品系列中的一个来配置时
- 当你要强调一系列相关的产品对象的设计以便进行联合使用时
- 当你提供一个产品类库，而只想显示它们的接口而不是实现时
2.3 UML图
抽象工厂模式UML图a)
- AbstractFactory
——声明一个创建抽象产品对象的操作接口。
- ConcreteFactory
——实现创建具体产品对象的操作。
- AbstractProduct
——为一类产品对象声明一个接口。
- ConcreteProduct
——定义一个将被相应的具体工厂创建的产品对象。
——实现AbstractProduct接口。
在这里指的是ProductA1,ProductA2,ProductB1,ProductB2。
- Client
——仅适用由AbstractFactory和AbstractProduct类声明的接口。
一般而言，有多少个产品等级结构，就会在工厂角色中发现多少个工厂方法。每一个产品等级结构中有多少个具体的产品，就有多少个产品族，也就会在工厂等级结构中发现多少个具体工厂。
2.4 代码示例
《设计模式：可复用面向对象软件的基础》中一书中，给出了一个应用工厂方法设计迷宫的例子，这里修改为应用抽象工厂模式来实现。
首先，给出了枚举类型Direction表明东南西北四个方向，定义抽象产品AbstractProduct接口，包含一个纯虚函数Enter，用于在迷宫间移动位置。
enum Direction {North, South, East, West};
//AbstractProduct
class MapSite{
public:
virtual void Enter() = 0;
};
接下来，基于抽象产品接口MapSite实现ConcreteProduct具体产品类:
定义迷宫房间Room类（ProductA）；
//ProductA
class Room : public MapSite{
public:
Room(int roomNo);//初始化房间号 MapSite *GetSide(Direction) const;//获取当前房间四周具体产品ConcreteProduct类MapSite
void SetSide(Direction, MapSite*);//设置当前房间四周具体产品ConcreteProduct类MapSite
virtual void Enter();
private:
MapSite* _side[4];
int _roomNumber;
};
定义迷宫的墙Wall类（ProductB）；
//ProductB
class Wall : public MapSite{
public:
Wall(); virtual void Enter();
};
定义迷宫的门Door类（ProductC）；
//ProductC
class Door : public MapSite{
public:
Door(Room * = 0, Room * = 0);//初始化门两边的房间 virtual void Enter();
Room* OtherSideFrom(Room *);
private:
Room * _room1;
Room * _room2;
bool _isOpen;
};
定义迷宫Maze类（ProductD）；
//ProductD
class Maze{
public:
Maze(); void AddRoom(Room *);
Room* RoomNo(int) const;
private:
//...
};
在完成抽象产品接口和具体产品类定义后，接下来定义抽象工厂接口AbstractFactory类MazeFactory，对外提供接口，用于生成上述定义的具体产品类ProductA——Room，ProductB——Wall，ProductC——Door，ProductD——Maze。
//AbstractFactory
class MazeFactory{
public:
MazeFactory(); virtual Maze* MakeMaze() const
{return new Maze;}
virtual Wall* MakeWall() const
{return new Wall;}
virtual Room* MakeRoom(int n) const
{return new Room(n);}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new Door(r1,r2);}
};
在定义好抽象工厂接口、抽象产品接口、具体产品后，就可以由Client来动态创建和处理各个对象的关系，这里创建一个包含两个房间的简单迷宫。
//Client
Maze * MazeGame::CreateMaze(MazeFactory &factory){
Maze * aMaze = factory.MakeMaze();
Room *r1 = factory.MakeRoom(1);
Room *r2 = factory.MakeRoom(2);
Door *aDoor = factory.MakeDoor(r1,r2); aMaze->AddRoom(r1);
aMaze->AddRoom(r2); r1->SetSide(North, factory.MakeWall());
r1->SetSide(East, aDoor);
r1->SetSide(South,factory.MakeWall());
r1->SetSide(West, factory.MakeWall());
r2->SetSide(North, factory.MakeWall());
r2->SetSide(East, factory.MakeWall());
r2->SetSide(South, factory.MakeWall());
r2->SetSide(West, aDoor); return aMaze;
}
如果需要创建带各种特效或者属性的Room、Door、Wall ，只需要继承具体产品类ProductA、ProductB、ProductC、ProductD，以及抽象工厂AbstractFactory接口MazeFactory。
如果要生成魔法迷宫，只需要继承MazeFactory生成ConcreteFactory类EnchantedMazeFacotry，
//ConcreteFactory
class EnchantedMazeFactory:public MazeFactory{
public:
EnchantedMazeFacotry(); virtual Room* MakeRoom(int n) const
{return new EnchantedRoom(n, castSpell());}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new DoorNeedingSpell(r1,r2);}
protected:
Spell* CastSpell() const;
};
调用CreateMaze就可以生成带魔法房间和符咒门的迷宫了。。。
先创建一个工厂生产器FactoryProducer：
MazeFactory *FactoryProducer(string type){
if(type == "Maze"){
return new MazeFactory;
}
else if(type == "EnchantedMaze"){
return new EnchantedMazeFactory;
}
}
客户端只需要针对抽象接口编程即可：
MazeFacoty *factory = FactoryProducer("Maze");
Maze *maze = CreateMaze(factory);
factory = FactoryProducer("EnchantedMaze");
maze = CreateMaze(factory);
同理还可以，由爆炸工厂生成带爆炸门和爆炸房间的迷宫。。。
Wall * BombedMazeFactory::MakeWall() const {
return new BombedWall;
}
Room* BombedMazeFactory::MakeRoom(int n) const{
return new RoomWithABomb(n);
}
如果嫌上面例子麻烦， 下面这个例子（截图自wikipedia官网），简单明了的阐释了抽象工厂模式：
2.5 优缺点
优点：
1、抽象工厂模式隔离了具体类的生产，使得客户并不需要知道什么被创建。
2、当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
3、增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
缺点：
增加新的产品等级结构很复杂，需要修改抽象工厂和所有的具体工厂类，对“开闭原则”的支持呈现倾斜性。
3 工厂方法
3.1 定义
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
3.2 适用场景
在下列情况下可以使用Factory Method模式：
- 当一个类不知道它所必须创建的对象的类的时候。
- 当一个类希望由它的子类来指定它所创建的对象的时候。
- 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
3.3 UML图
UML结构
- Product
——定义工厂方法所创建的对象的接口。
- ConcreteProduct
——实现Product接口。
- Creator
——声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的却省实现，它返回一个缺省的ConcreteProduct对象。
——可以调用该工厂方法以创建一个Product对象。
- ConcreteCreator
——重定义工厂方法以返回一个ConcreteProduct实例。
3.4 代码示例
与抽象工厂不同的时，在抽象工厂中，只需要将抽象工厂接口Factory传到client中，然后就能生成不同的Product，然而在工厂方法中，是通过Creator来实现的。Creator中FactoryMethod是一些产品虚函数，用于生成具体的产品的，而AnOperation成员函数，相当于抽象工厂中的Client，调用ConcreteCreator的虚函数FactoryMethod来生成真正的产品。
修改抽象产品中迷宫例子，将CreateMaze函数和MazeFactory合并到一块，并将CreateMaze参数去掉，改名为MazeGame,这样就是工厂方法的实现了，这里MazeGame就是Creator，如果需要扩展生成更多的产品，只需要继承MazeGame，实现ConcreteCreator，然后重载虚函数FactoryMethod，就能创建更多的产品。
class MazeGame{
public:
Maze * CreateMaze();
//factory method
virtual Maze* MakeMaze() const
{return new Maze;}
virtual Wall* MakeWall() const
{return new Wall;}
virtual Room* MakeRoom(int n) const
{return new Room(n);}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new Door(r1,r2);}
};
CreateMaze是AnOperation的具体实现。
Maze * MazeGame::CreateMaze(){
Maze * aMaze = MakeMaze();
Room *r1 = MakeRoom(1);
Room *r2 = MakeRoom(2);
Door *aDoor = MakeDoor(r1,r2);
aMaze->AddRoom(r1);
aMaze->AddRoom(r2);
r1->SetSide(North, MakeWall());
r1->SetSide(East, aDoor);
r1->SetSide(South,MakeWall());
r1->SetSide(West, MakeWall());
r2->SetSide(North, MakeWall());
r2->SetSide(East, MakeWall());
r2->SetSide(South, MakeWall());
r2->SetSide(West, aDoor);
return aMaze;
}
EnchantedMazeGame是ConcreteCreator的具体实现。
class EnchantedMazeGame:public MazeGame{
public:
EnchantedMazeFacotry();
virtual Room* MakeRoom(int n) const
{return new EnchantedRoom(n, castSpell());}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new DoorNeedingSpell(r1,r2);}
protected:
Spell* CastSpell() const;
};
Client生成具体的产品调用方式为：
//Factory Producer
MazeGame *CreateMaze(string type){
if(type == "Maze"){
return new MazeGame;
}
else if(type == "EnchantedMaze"){
return new EnchantedMazeGame ;
}
}
//Creator
MazeGame *creator= CreateMaze("Maze");
Maze *maze = creator->CreateMaze();
//ConcreteCreator
creator= CreateMaze("EnchantedMaze");
maze = creator->CreateMaze();
3.5 优缺点
优缺点除了抽象工厂的外，不能很好的支持多种产品。
4 简单工厂
4.1 定义
简单工厂其实不是一个设计模式，比较像一种编程习惯，就是提供一个静态函数，根据不同的参数动态创建同一个类的不同子类对象。
4.2 适用场景
4.3 UML图
- Product
——产品类，具有一些有用的实现，这些实现是虚函数，可以被子类覆盖。
- ProductFactory
——产品工厂，是一个静态函数，根据不同的参数信息，生成不同的产品对象。
4.4 代码示例
MazeGame和EnchantedMazeGame为UML图中的Product和ConcreteProduct。
class MazeGame{
public:
virtual Maze* MakeMaze() const
{return new Maze;}
virtual Wall* MakeWall() const
{return new Wall;}
virtual Room* MakeRoom(int n) const
{return new Room(n);}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new Door(r1,r2);}
};
class EnchantedMazeGame:public MazeGame{
public:
EnchantedMazeFacotry();
virtual Room* MakeRoom(int n) const
{return new EnchantedRoom(n, castSpell());}
virtual Door* MakeDoor(Room* r1, Room* r2) const
{return new DoorNeedingSpell(r1,r2);}
protected:
Spell* CastSpell() const;
};
用简单工厂的方法重写CreateMaze如下，根据不同的type类型创建不同的迷宫：
Maze * CreateMaze(string type){
Maze * aMaze = NULL;
if(type == "Maze"){
aMaze = new MazeGame;
}
else if(type == "EnchantedMaze"){
aMaze = new EnchantedMazeGame;
}
Room *r1 = aMaze->MakeRoom(1);
Room *r2 = aMaze->MakeRoom(2);
Door *aDoor = aMaze->MakeDoor(r1,r2);
aMaze->AddRoom(r1);
aMaze->AddRoom(r2);
r1->SetSide(North, MakeWall());
r1->SetSide(East, aDoor);
r1->SetSide(South,MakeWall());
r1->SetSide(West, MakeWall());
r2->SetSide(North, MakeWall());
r2->SetSide(East, MakeWall());
r2->SetSide(South, MakeWall());
r2->SetSide(West, aDoor);
return aMaze;
}
4.5 优缺点
缺点是为违背了编码“高内聚低耦合”的原则，将很多细节暴露了给客户，如CreateMaze中函数，房间、墙、门是如何组成迷宫的细节都暴露了。
5 如何选择三种设计模式
参考资料：
a) https://en.wikipedia.org/wiki/Abstract_factory_pattern
b) 《设计模式：可复用面向对象软件的基础》
c) http://www.runoob.com/design-pattern/abstract-factory-pattern.html
d) https://zh.wikipedia.org/wiki/%E6%8A%BD%E8%B1%A1%E5%B7%A5%E5%8E%82