抽象工厂模式(Abstract factory Pattern)

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

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

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

    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表，比如说增加部门表，此时怎么办呢。

    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.         Console.WriteLine("在Access中给Department表增加一条记录");
    5.     }
    7.     public Department GetDepartment(int id)
    8.     {
    10.         return null;
    11.     }
    13. }
    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。

    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;
    9.         switch (db)
    10.         {
    11.             case:"Sqlserver":
    13.                 break;
    14.             case:"Acesss":
    15.                 result = new AcesssUser();
    16.                 break;
    17.         }
    18.         return result;
    19.     }
    21.     publci static IDepartment CreateDepartment()
    22.     {
    23.         IDepartment result = null;
    24.                 switch (db)
    25.         {
    26.             case:"Sqlserver":
    27.                 result = new SqlserverDepartment();
    28.                 break;
    29.             case:"Acesss":
    30.                 result = new AcesssDepartment();
    31.                 break;
    32.         }
    33.         return result;
    34.     }
    36. }
    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，解除分支判断带来的耦合。

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

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

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

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

    熟悉这个模式的同学很可能看过下面的测试代码，将原有的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. }