GOF之抽象工厂模式

动机(Motivation)

在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作;同时，由于需求的变化，往往存在更多系列的对象的创建工作。

如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

意图(Intene)

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具体的类。

结构(Stucture)

具体代码实现：

1 对应图中的AbstractFactory
2 abstract class FacilitiesFactory
3     {
4         public abstract Road CreateRoad();
5         public abstract Building CreateBuilding();
6     }

 1 对应图中的AbstractProductA
 2 abstract class Road
 3     {
 4         private string _name;
 5         public string Name
 6         {
 7             get { return _name; }
 8             set { _name = value; }
 9         }
10         public abstract void RoadMethod();
11     }

 1 对应图中的AbstractProductB
 2 abstract class Building
 3     {
 4         private string _name;
 5         public string Name
 6         {
 7             get { return _name; }
 8             set { _name = value; }
 9         }
10         public abstract void BuildingMethod();
11     }

 1 对应图中的ConcreteFactory1
 2  class ModenFacilities:FacilitiesFactory
 3     {
 4         public override Road CreateRoad()
 5         {
 6             return new ModenRoad("现代风格的");
 7         }
 8
 9         public override Building CreateBuilding()
10         {
11             return new ModenBuilding("现代风格的");
12         }
13     }

 1 对应图中的ConcreteFactory2
 2 class ClassicFacilities:FacilitiesFactory
 3     {
 4         public override Road CreateRoad()
 5         {
 6             return new ClassicRoad("古典风格的");
 7         }
 8
 9         public override Building CreateBuilding()
10         {
11             return new ClassicBuilding("古典风格的");
12         }
13     }

 1 对应图中的Client
 2 class GameManage
 3     {
 4         private FacilitiesFactory facilitiesFactory;
 5         private Road road;
 6         private Building building;
 7         public GameManage(FacilitiesFactory facilitiesFactory)
 8         {
 9             this.facilitiesFactory = facilitiesFactory;
10         }
11         public void BuildFacilities()
12         {
13             road = facilitiesFactory.CreateRoad();
14             building = facilitiesFactory.CreateBuilding();
15         }
16         public void Run()
17         {
18             road.RoadMethod();
19             building.BuildingMethod();
20         }
21     }

 1 对应图中的ProductA1
 2 class ModenRoad:Road
 3     {
 4         public override void RoadMethod()
 5         {
 6             Console.WriteLine("{0}的道路",this.Name);
 7         }
 8         public ModenRoad(string name)
 9         {
10             this.Name = name;
11         }
12     }

 1 对应图中ProductB1
 2 class ModenBuilding:Building
 3     {
 4
 5         public override void BuildingMethod()
 6         {
 7             Console.WriteLine("{0}的建筑物",this.Name);
 8         }
 9         public ModenBuilding(string name)
10         {
11             this.Name = name;
12         }
13     }

 1 对应图中ProductA2
 2 class ClassicRoad:Road
 3     {
 4         public override void RoadMethod()
 5         {
 6             Console.WriteLine("{0}的道路", this.Name);
 7         }
 8         public ClassicRoad(string name)
 9         {
10             this.Name = name;
11         }
12     }

 1 对应图中ProductB2
 2  class ClassicBuilding:Building
 3     {
 4         public override void BuildingMethod()
 5         {
 6             Console.WriteLine("{0}的建筑物", this.Name);
 7         }
 8         public ClassicBuilding(string name)
 9         {
10             this.Name = name;
11         }
12     }

1 这是主函数的调用
2  static void Main(string[] args)
3  {
4       GameManage g = new GameManage(new ClassicFacilities());
5       g.BuildFacilities();
6       g.Run();
7       Console.ReadKey();
8  }

Abstract Factory模式的几个要点

如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂。

“系列对象”指的是这些对象之间有相互依赖、或作用的关系，例如游戏开发场景中的“道路”与“房屋”的依赖。

Abstract Factory模式主要在于应对“新系列”的需求变动，其缺点在于难以应对“新对象”的需求变动。

Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。