实战设计模式系列-AbstractFactory(抽象工厂)

【需求分析】

 

    假设我们需要写一个迷宫游戏，游戏支持用户自由选择游戏的场景，比如可以选择普通的迷宫，或者是有魔法的迷宫等。但所有的迷宫都有一些共同的元素，包括墙壁、门、房间。

 

    只考虑创造一个普通的迷宫，代码比较简单，如下所示：

 

Maze* aMaze = new Maze(); Room * r1 = new Room(1); Room * r2 = new Room(2); Door * theDoor = new Door(r1, r2); aMaze->AddRoom(r1); aMaze->AddRoom(r2); r1->SetSide(North, factory.MakeWall()); r1->SetSide(East, theDoor); r1->SetSide(South, factory.MakeWall()); r1->SetSide(West, factory.MakeWall()); r2->SetSide(North, factory.MakeWall()); r2->SetSide(West, theDoor); r2->SetSide(South, factory.MakeWall()); r2->SetSide(East, factory.MakeWall()); return aMaze;

 

 

    为了让迷宫支持更多的差异化，我们把迷宫的属性进行细分，可以发现不同的迷宫间有共同的元素，不同的只是元素的属性，或者说元素的实现方式。因此，我们希望这些共同的元素能够被工厂动态的生产出来，然后加入到迷宫当中，如下所示：

 

aMaze = factory.MakeMaze(); r1 = factory.MakeRoom(1); r2 = factory.MakeRoom(2); theDoor = factory.MakeDoor(r1, r2); aMaze->AddRoom(r1); aMaze->AddRoom(r2); r1->SetSide(North, factory.MakeWall()); r1->SetSide(East, theDoor); r1->SetSide(South, factory.MakeWall()); r1->SetSide(West, factory.MakeWall()); r2->SetSide(North, factory.MakeWall()); r2->SetSide(West, theDoor); r2->SetSide(South, factory.MakeWall()); r2->SetSide(East, factory.MakeWall());

   

    factory是一个工厂，这个工厂可以是一个生产普通迷宫的工厂，或者是生产魔法迷宫的工厂，他们都能生产出同样的迷宫，而只是样式不同。这样就实现了迷宫的动态创建

 

【实现过程】

1. 实现迷宫的组件抽象类

    抽象这些元素的共同点，都有enter接口，因此可以给这些组件定义一个抽象类MapSite，如下所示:

/*MapSite.h*/ #ifndef _MAPSITE_H #define _MAPSITE_H enum TYPE {MAPSITE, ROOM, WALL, DOOR}; class MapSite { public: virtual void Enter() = 0; ~MapSite(); virtual int type() = 0; }; MapSite::~MapSite() { printf("Delete MapSite/n"); } #endif

 

2.实现迷宫的组件

 

    现在假设要支持两种迷宫，魔法迷宫和可墙壁可爆炸的迷宫。我们先定义房间。

/*Room.h*/ #ifndef _ROOM_H #define _ROOM_H enum Direction {North, South, East, West}; class Room : public MapSite { public: Room(); Room(int roomNo); ~Room(); type(); MapSite* GetSide(Direction) const; void SetSide(Direction dir, MapSite* pMapSite); int GetRoomNo(); virtual void Enter(); protected: int _roomNumber; private: MapSite* _sides[4]; }; Room::Room() { } Room::Room(int roomNo) { _roomNumber = roomNo; printf("Create Room NO.%d/n", roomNo); } Room::~Room() { printf("Delete Room/n"); for (int i = 0; i < 4; i++) { if (_sides[i]->type() != DOOR) // TUDO { delete _sides[i]; _sides[i] = NULL; } } } Room::type() { return ROOM; } void Room::SetSide(Direction dir, MapSite* pMapSite) { _sides[dir] = pMapSite; switch(dir) { case East: printf("Set Room NO.%d East Side/n", GetRoomNo()); break; case West: printf("Set Room NO.%d West Side/n", GetRoomNo()); break; case North: printf("Set Room NO.%d North Side/n", GetRoomNo()); break; case South: printf("Set Room NO.%d East South/n", GetRoomNo()); break; default: break; } } int Room::GetRoomNo() { return _roomNumber; } void Room::Enter() { printf("Enter Room/n"); } class EnchantedRoom : public Room { public: EnchantedRoom(int roomNo) { _roomNumber = roomNo; printf("Create EnchantedRoom NO.%d/n", roomNo); } }; class BoomedRoom : public Room { public: BoomedRoom(int roomNo) { _roomNumber = roomNo; printf("Create BoomedRoom NO.%d/n", roomNo); } }; #endif

 

    类似的实现墙壁和门。

 /*Wall.h*/ #ifndef _WALL_H #define _WALL_H class Wall : public MapSite { public: Wall(); ~Wall(); type(); virtual void Enter(); }; Wall::Wall() { printf("Create Wall/n"); } Wall::~Wall() { printf("Delete Wall/n"); } Wall::type() { return WALL; } void Wall::Enter() { printf("Enter Wall/n"); } class EnchantedWall : public Wall { public: EnchantedWall() { printf("Create EnchantedWall/n"); } }; class BoomedWall : public Wall { public: BoomedWall() { printf("Create BoomedWall/n"); } }; #endif

 

/*Door.h*/ #ifndef _DOOR_H #define _DOOR_H #include "Room.h" class Door : public MapSite { public: Door(Room* r1 = 0, Room * r2 = 0); ~Door(); type(); virtual void Enter(); Room* OtherSideFrom(Room *); private: Room* _room1; Room* _room2; bool _isOpen; }; Door::Door(Room* r1, Room * r2):_room1(r1), _room2(r2) { printf("Create Door between Room %d and %d/n", r1->GetRoomNo(), r2->GetRoomNo()); } Door::~Door() { printf("Delete Door/n"); } Door::type() { return DOOR; } void Door::Enter() { printf("Enter Door/n"); } #endif

 

3.实现工厂

 

    工厂必须能生产门，墙和房间，因此这些应该是基类的抽象接口。

 

/*MazeFacory.h*/ #ifndef _MAZEFACTORY_H #define _MAZEFACTORY_H #include "Maze.h" #include "Room.h" #include "Wall.h" #include "Door.h" class MazeFactory // Abstract class { public: MazeFactory() { printf("Create MazeFactory/n"); } virtual Maze* MakeMaze() const { return new Maze; } virtual Wall* MakeWall() const = 0; virtual Room* MakeRoom(int n) const = 0; virtual Door* MakeDoor(Room* r1, Room* r2) const { return new Door(r1, r2); } }; class EnchantedMazeFactory : public MazeFactory { public: EnchantedMazeFactory() { printf("Create MazeFactory"); } virtual Room* MakeRoom(int n) const { return new EnchantedRoom(n); } virtual Wall* MakeWall() const { return new EnchantedWall(); } }; class BoomedMazeFactory : public MazeFactory { public: BoomedMazeFactory() { printf("Create MazeFactory"); } virtual Room* MakeRoom(int n) const { return new BoomedRoom(n); } virtual Wall* MakeWall() const { return new BoomedWall(); } }; #endif

 

4.实现迷宫类

 

 /*MazeGame.h*/ #ifndef _MAZEGAME_H #define _MAZEGAME_H #include "Maze.h" #include "Room.h" #include "Wall.h" #include "Door.h" #include "MazeFactory.h" class MazeGame { public: MazeGame(); ~MazeGame(); Maze* CreateMaze(MazeFactory& factory); private: Maze* aMaze; Room* r1; Room* r2; Door* theDoor; }; MazeGame::MazeGame() { printf("Create MazeGame/n"); } MazeGame::~MazeGame() { delete aMaze; delete theDoor; printf("Delete MazeGame/n"); } Maze* MazeGame::CreateMaze(MazeFactory& factory) { aMaze = factory.MakeMaze(); r1 = factory.MakeRoom(1); r2 = factory.MakeRoom(2); theDoor = factory.MakeDoor(r1, r2); aMaze->AddRoom(r1); aMaze->AddRoom(r2); r1->SetSide(North, factory.MakeWall()); r1->SetSide(East, theDoor); r1->SetSide(South, factory.MakeWall()); r1->SetSide(West, factory.MakeWall()); r2->SetSide(North, factory.MakeWall()); r2->SetSide(West, theDoor); r2->SetSide(South, factory.MakeWall()); r2->SetSide(East, factory.MakeWall()); return aMaze; } #endif

 

5.如何使用

 

#include <stdio.h> #include <stdlib.h> #include "MapSite.h" #include "Room.h" #include "Wall.h" #include "Door.h" #include "Maze.h" #include "MazeGame.h" int main(void) { MazeGame *pMazeGame = new MazeGame; int tag; printf("EnchantedMaze:1/nBoomedMaze:2/n"); printf("Enter your choice:/n"); scanf("%d", &tag); EnchantedMazeFactory pEnchangtedFactory; BoomedMazeFactory pBoomedMazeFactory; switch(tag) { case 1: pMazeGame->CreateMaze(pEnchangtedFactory); case 2: pMazeGame->CreateMaze(pBoomedMazeFactory); } delete pMazeGame; return 0; }

 

【总结】

 

    抽象工厂在抽象工厂类中定义接口，子类中实现父类的方法，不同的配置方式就有多个子类去实现，而客户只使用父类中提供的接口，通过传参数的方式在客户类中决定用那个具体的工厂去实例化对象。

    下图是本文中举例的图示，图中MazeFactory作为父类限定了接口，可以是抽象类，也可是具体类，如是具体类，则可以定义一个最基本的功能接口，并可以在Client类MazeGame中初实例化。

    客户类MazeGame接收一个MazeFactory引用参数来实例化一个产品，通过传入具体类的参数在运行时刻决定应该实例化那一个类。

    Room和Wall作为组件使用来构建具体的工厂类。

    这个模式的缺点在于难以支持新种类的产品，每增加一个新的功能就要修改抽象工厂类的接口。

    抽象工厂模式提供了一个创建一系列相关或相互依赖对象的接口。