抽象工厂模式(Abstract factory Pattern)

简介

抽象工厂模式是一种软件开发设计模式。抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。

简例

有个项目原来是依赖于access数据库，现在要用sqlserver，怎么更改呢(解耦)？

用工厂方法模式的数据访问程序

IUser接口，用于客户端访问，解除与具体数据库访问的耦合。

  1. interface IUser
  2. {
  3.     void Insert(User user);
  5.     User GetUser(int id);
  6. }

Sqlserver类，用于访问SQL Server的User。

  1. class SqlserverUser : IUser
  2. {
  3.     public void Insert(User user)
  4.     {
  5.         Console.WriteLine("在SQL Server中给User表增加一条记录");
  6.     }
  8.     public User GetUser(int id)
  9.     {
  10.         Console.WriteLine("在SQL Server中给User表获取一条记录");
  11.         return null;
  12.     }
  14. }

AccessUser类，用于访问Access的User。

  1. class AccessUser : IUser
  2. {
  3.     public void Insert(User user)
  4.     {
  5.         Console.WriteLine("在access中给User表增加一条记录");
  6.     }
  8.     public User GetUser(int id)
  9.     {
  10.         Console.WriteLine("在access中给User表获取一条记录");
  11.         return null;
  12.     }
  14. }

IFactory接口，定义一个创建访问User表对象的抽象的工厂接口。

  1. interface Ifactory
  2. {
  3.     IUser CreateUser();
  4. }

sqlServerFactory类，实现IFactory接口，实例化SqlserverUser。

  1. class sqlServerFactory:  IFactory
  2. {
  3.     public IUser CreateUser()
  4.     {
  5.         return new SqlserverUser();
  6.     }
  7. }

AccessFactory类，实现IFactory接口，实例化AccessUser.

  1. class AccessFactory:  IFactory
  2. {
  3.     public IUser CreateUser()
  4.     {
  5.         return new AccessUser();
  6.     }
  7. }

客户端代码

  1. static void main(string[] args)
  2. {
  3.     User user = new User();
  5.     IFactory factory = new SqlServerFactory();
  7.     IUser iu = factory.CreateUser();
  9.     iu.Insert(user);
  10.     iu.GetUser(1);
  11.     Console.Read();
  12. }

但是数据里面不可能只有一个User表，比如说增加部门表，此时怎么办呢。

抽象工厂类

IUser接口，用于客户端访问，解除与具体数据库访问的耦合。

  1. interface IDepartment
  2. {
  3.     void Insert(Department department);
  4.     Department GetDepartment(int id);
  5. }

SqlserverDepartment类，用于访问SQL Server的Department。

  1. class SqlserverDepartment : IDepartment
  2. {
  3.     public void Insert(Department department)
  4.     {
  5.         Console.WriteLine("在SQL Server中给Department表增加一条记录");
  6.     }
  8.     public Department GetDepartment(int id)
  9.     {
  10.         Console.WriteLine("在SQL Server中给Department表获取一条记录");
  11.         return null;
  12.     }
  14. }

AccessDepartment类，用于访问Access的Department。

  1. class AccessDepartment : IDepartment
  2. {
  3.     public void Insert(Department department)
  4.     {
  5.         Console.WriteLine("在Access中给Department表增加一条记录");
  6.     }
  8.     public Department GetDepartment(int id)
  9.     {
  10.         Console.WriteLine("在Access中给Department表获取一条记录");
  11.         return null;
  12.     }
  14. }
  1. interface IUser
  2. {
  3.     void Insert(User user);
  5.     User GetUser(int id);
  6. }

Sqlserver类，用于访问SQL Server的User。

  1. class SqlserverUser : IUser
  2. {
  3.     public void Insert(User user)
  4.     {
  5.         Console.WriteLine("在SQL Server中给User表增加一条记录");
  6.     }
  8.     public User GetUser(int id)
  9.     {
  10.         Console.WriteLine("在SQL Server中给User表获取一条记录");
  11.         return null;
  12.     }
  14. }

AccessUser类，用于访问Access的User。

  1. class AccessUser : IUser
  2. {
  3.     public void Insert(User user)
  4.     {
  5.         Console.WriteLine("在access中给User表增加一条记录");
  6.     }
  8.     public User GetUser(int id)
  9.     {
  10.         Console.WriteLine("在access中给User表获取一条记录");
  11.         return null;
  12.     }
  14. }

IFactory接口，定义一个创建访问User表对象的抽象的工厂接口。

  1. interface Ifactory
  2. {
  3.     IUser CreateUser();
  5.     IDepartment CreateDepartment();
  6. }

sqlServerFactory类，实现IFactory接口，实例化SqlserverUser。

  1. class sqlServerFactory:  IFactory
  2. {
  3.     public IUser CreateUser()
  4.     {
  5.         return new SqlserverUser();
  6.     }
  8.     public IDepartment CreateDepartment()
  9.     {
  10.         return new SqlserverDepartment();
  11.     }
  13. }

AccessFactory类，实现IFactory接口，实例化AccessUser.

  1. class AccessFactory:  IFactory
  2. {
  3.     public IUser CreateUser()
  4.     {
  5.         return new AccessUser();
  6.     }
  8.     public IDepartment CreateDepartment()
  9.     {
  10.         return new AccessDepartment();
  11.     }
  12. }

客户端代码

  1. static void main(string[] args)
  2. {
  3.     User user = new User();
  5.     IFactory factory = new SqlServerFactory();
  7.     IUser iu = factory.CreateUser();
  9.     iu.Insert(user);
  10.     iu.GetUser(1);
  11.     Console.Read();
  12. }

抽象工厂模式：提供一个创建一系列相关或者相互依赖的对象的接口，而无需指定它们具体的类。

用简单工厂来改进抽象工厂

  1. class DataAccess
  2. {
  3.     private static readonly string db = "Sqlserver";
  4.     //    private static readonly string db = "access";
  6.     public static IUser CreateUser()
  7.     {
  8.         IUser result = null;
  10.         switch (db)
  11.         {
  12.             case:"Sqlserver":
  13.                 result = new SqlserverUser();
  14.                 break;
  15.             case:"Acesss":
  16.                 result = new AcesssUser();
  17.                 break;
  18.         }
  19.         return result;
  20.     }
  22.     publci static IDepartment CreateDepartment()
  23.     {
  24.         IDepartment result = null;
  25.                 switch (db)
  26.         {
  27.             case:"Sqlserver":
  28.                 result = new SqlserverDepartment();
  29.                 break;
  30.             case:"Acesss":
  31.                 result = new AcesssDepartment();
  32.                 break;
  33.         }
  34.         return result;
  35.     }
  37. }

客户端代码

  1. static void Main(string[] args)
  2. {
  3.     User user = new User();
  4.     Department dept = new Department();
  6.     IUser iu = DataAccess.createUser();
  7.     iu.Insert(user);
  8.     iu.GetUser(1);
  10.     IDepartment id = DataAccess.createDepartment();
  11.     id.Inert(dept);
  12.     id.GetDepartment(1);
  14.     Console.Read();
  15. }

利用反射或者配置文件都可以减少在所有简单工厂的switch和if，解除分支判断带来的耦合。

“工厂”是创建产品（对象）的地方，其目的是将产品的创建与产品的使用分离。抽象工厂模式的目的，是将若干抽象产品的接口与不同主题产品的具体实现分离开。这样就能在增加新的具体工厂的时候，不用修改引用抽象工厂的客户端代码。

使用抽象工厂模式，能够在具体工厂变化的时候，不用修改使用工厂的客户端代码，甚至是在运行时。然而，使用这种模式或者相似的设计模式，可能给编写代码带来不必要的复杂性和额外的工作。正确使用设计模式能够抵消这样的“额外工作”。

从NSArray看类簇

Class Clusters（类簇）是抽象工厂模式在iOS下的一种实现，众多常用类，如NSString，NSArray，NSDictionary，NSNumber都运作在这一模式下，它是接口简单性和扩展性的权衡体现，在我们完全不知情的情况下，偷偷隐藏了很多具体的实现类，只暴露出简单的接口。

虽然官方文档中拿NSNumber说事儿，但Foundation并没有像图中描述的那样为每个number都弄一个子类，于是研究下NSArray类簇的实现方式。

__NSPlacehodlerArray

熟悉这个模式的同学很可能看过下面的测试代码，将原有的alloc+init拆开写：

  1. id obj1 = [NSArray alloc]; // __NSPlacehodlerArray *
  2. id obj2 = [NSMutableArray alloc];  // __NSPlacehodlerArray *
  3. id obj3 = [obj1 init];  // __NSArrayI *
  4. id obj4 = [obj2 init];  // __NSArrayM *

发现+ alloc后并非生成了我们期望的类实例，而是一个NSPlacehodlerArray的中间对象，后面的- init或- initWithXXXXX消息都是发送给这个中间对象，再由它做工厂，生成真的对象。这里的NSArrayI和__NSArrayM分别对应Immutable和Mutable（后面的I和M的意思）

于是顺着思路猜实现，__NSPlacehodlerArray必定用某种方式存储了它是由谁alloc出来的这个信息，才能在init的时候知道要创建的是可变数组还是不可变数组

经过研究发现，Foundation用了一个很贱的比较静态实例地址方式来实现，伪代码如下：

  1. static __NSPlacehodlerArray *GetPlaceholderForNSArray() {
  2.     static __NSPlacehodlerArray *instanceForNSArray;
  3.     if (!instanceForNSArray) {
  4.         instanceForNSArray = [[__NSPlacehodlerArray alloc] init];
  5.     }
  6.     return instanceForNSArray;
  7. }
  9. static __NSPlacehodlerArray *GetPlaceholderForNSMutableArray() {
  10.     static __NSPlacehodlerArray *instanceForNSMutableArray;
  11.     if (!instanceForNSMutableArray) {
  12.         instanceForNSMutableArray = [[__NSPlacehodlerArray alloc] init];
  13.     }
  14.     return instanceForNSMutableArray;
  15. }
  16. // NSArray实现
  17. + (id)alloc {
  18.     if (self == [NSArray class]) {
  19.         return GetPlaceholderForNSArray()
  20.     }
  21. }
  22. // NSMutableArray实现
  23. + (id)alloc {
  24.     if (self == [NSMutableArray class]) {
  25.         return GetPlaceholderForNSMutableArray()
  26.     }
  27. }
  28. // __NSPlacehodlerArray实现
  29. - (id)init {
  30.     if (self == GetPlaceholderForNSArray()) {
  31.         self = [[__NSArrayI alloc] init];
  32.     }
  33.     else if (self == GetPlaceholderForNSMutableArray()) {
  34.         self = [[__NSArrayM alloc] init];
  35.     }
  36.     return self;
  37. }

Foundation不是开源的，所以上面的代码是猜测的，思路大概就是这样，可以这样验证下：

  1. id obj1 = [NSArray alloc];
  2. id obj2 = [NSArray alloc];
  3. id obj3 = [NSMutableArray alloc];
  4. id obj4 = [NSMutableArray alloc];
  5. // 1和2地址相同，3和4地址相同，无论多少次都相同，且地址相差16位