（Factory method）工厂方法设计模式

• 定义：

1.) 工厂方法模式是用来封装对象的创建，通过让子类来决定创建的对象是什么，来达到将对象创建的过程封装的目的；

2.) 定义了一个创建对象的接口，但由子类决定要实例的泪是哪一个。工厂方法让类把实例化推迟到子类。

• 适用场景：

代码中经常会出现：根据条件创建实现了同一个接口的不用类实例，而这些判定条件可能随时变动，导致我们这个不得不去改动很多代码。

备注：简单工厂在Head First中，被认为不是设计模式的一种，但人们经常使用，大家习惯性的叫，久了也就言传为“工厂方法模式”。

• 简单工厂方法

• 解决了什么问题

例如：

string dbName=string.Empty;
            dbName="Access";
            MemberDaoBase memberDao=null;

            if(dbName.ToUpper()=="ACCESS"){
                memberDao=new Access.MemberDao();
            }
            else if(dbName.ToUpper()=="SQLSERVER")
            {
                memberDao=new SqlServer.MemberDao();
            }
            memberDao.Create(new Member());
            memberDao.Modify(new Member());
            memberDao.Remove();
            

如果代码中不再变动还好，但这种情况很多时候是不存在的，当来了一个新的领导，领导说Sqlite的性能好且免费，那你就不得不去重新去写一个Sqlite.MemberDao,之后再在这里的判断条件中添加上

 else if(dbName.ToUpper()=="SQLITE")
 {
       memberDao=new SqlServer.SqliteDao();
 }

当某天另外一个领导说我们不再支持SqlServer了，我们就不得不把else if(dbName.ToUpper()=="SQLSERVER") {...} 这块代码给注释了。我们就痛苦在这种“变动”中。

问题分析：

不稳定部分：

 string dbName=string.Empty;
             dbName="Access";
             MemberDaoBase memberDao=null;

             if(dbName.ToUpper()=="ACCESS"){
                 memberDao=new Access.MemberDao();
             }
             else if(dbName.ToUpper()=="SQLSERVER")
             {
                 memberDao=new SqlServer.MemberDao();
             }

稳定部分：

 memberDao.Create(new Member());

 memberDao.Modify(new Member());

 memberDao.Remove();

如果我们将不稳定的部分给交给两外一个类单独管理，就能把这种耦合变得低一点，当我们需要“变动”时，只用去修改这个管理类；而这管理来是用来new 实例的，我们习惯。

• “new管理类（简单工厂方法核心类）”：

 /// <summary>
     /// Description of MemberDaoFactory.
     /// </summary>
     public class MemberDaoFactory
     {
         public MemberDaoBase Create(string dbName)
         {
             if(dbName.ToUpper()=="ACCESS")
             {
                 Console.WriteLine("new Access.MemberDao()");
                 return new Access.MemberDao();
             }
             else if(dbName.ToUpper()=="SQLSERVER")
             {
                 Console.WriteLine("new SqlServer.MemberDao()");
                 return new SqlServer.MemberDao();
             }
             else
             {
                 throw new NotSupportedException(string.Format("Not supported {0}",dbName));
             }
         }
     }

• 按照简单工厂方法的定义调整

代码结构图：

Member.cs

 /// <summary>
     /// Description of Member.
     /// </summary>
     public class Member
     {
         private int id;
         private string name;

         public Member()
         {
         }

         public int Id
         {
             get { return id; }
             set{id=value;}
         }

         public string Name
         {
             get { return name; }
             set { name = value; }
         }
     }

Dao/MemberBO.cs

 using System;

 namespace FactoryMethod
 {
     /// <summary>
     /// Description of MemberBO.
     /// </summary>
     public class MemberBO
     {
         private MemberDaoFactory memberDaoFactory=null;
         private string dbName=string.Empty;

         public MemberBO(string dbName,MemberDaoFactory memberDaoFactory)
         {
             this.dbName=dbName;
             this.memberDaoFactory=memberDaoFactory;
         }

         public void Create(Member member)
         {
             if(member==null)
             {
                 throw new ArgumentNullException("member is null");
             }

             MemberDaoBase memberDao=this.memberDaoFactory.Create(this.dbName);

             memberDao.Create(member);
         }
     }
 }

Dao/MemberDaoBase.cs

 using System;

 namespace FactoryMethod
 {
     public abstract class MemberDaoBase
     {
         public abstract void Create(Member member);

         public abstract void Modify(Member member);        

         public abstract void Remove(int id);
     }
 }

Dao/SqlServer/MemberDao.cs

 using System;

 namespace FactoryMethod.SqlServer
 {
     /// <summary>
     /// Description of MemberDao.
     /// </summary>
     public class MemberDao:MemberDaoBase
     {
         public MemberDao()
         {
         }

         public override void Create(Member member)
         {
             //...
             Console.WriteLine("Insert member into sqlserver db");
         }

         public override void Modify(Member member)
         {
             //...
             Console.WriteLine("modify member from sqlserver db");
         }

         public override void Remove(int id)
         {
             //...
             Console.WriteLine("remove member from sqlserver db");
         }
     }
 }

Dao/Access/MemberDao.cs

 using System;

 namespace FactoryMethod.Access
 {
     /// <summary>
     /// Description of MemberDao.
     /// </summary>
     public class MemberDao:MemberDaoBase
     {
         public MemberDao()
         {
         }

         public override void Create(Member member)
         {
             //...
             Console.WriteLine("Insert member into access db");
         }

         public override void Modify(Member member)
         {
             //...
             Console.WriteLine("modify member from access db");
         }

         public override void Remove(int id)
         {
             //...
             Console.WriteLine("remove member from access db");
         }
     }
 }

客户端调用：

 class Program
     {
         public static void Main(string[] args)
         {
             Console.WriteLine("Hello World!");

             // TODO: Implement Functionality Here
             MemberBO memberBO0=new MemberBO("access",new MemberDaoFactory());
             memberBO0.Create(new Member());

             MemberBO memberBO1=new MemberBO("sqlserver",new MemberDaoFactory());
             memberBO1.Create(new Member());

             Console.Write("Press any key to continue . . . ");
             Console.ReadKey(true);
         }
     }

输出结果：

• 工厂方法

当系统要求不再是只有普通人员了，分出了管理层和基层，而且程序中要求不同等级的数据放在不同网络上，且数据库中的字段名称不同，但意义还是一样时。

我们当前系统的结构就不能很好的应对了，于是我们就需要这样处理：

提取出对应的抽象MemberBO类,和MemberBO的具体实现类ManagerBO,EmployeeBO,MemberBO包含所有的外部需要的功能外还包含一个抽象的FactoryMethod函数，ManagerBO和EmployeeBO要实现FactoryMethod函数：

对应的类：

  public class Member
     {
         public Member() { }

         public int ID { get; set; }

         public string Name { get; set; }
     }

     public abstract class MemberDaoBase
     {
         public abstract void Create(Member member);

         public abstract void Modify(Member member);
     }

     public abstract class MemberBOBase
     {
         protected virtual void Create(Member member, string dbName)
         {
             if (member == null)
             {
                 throw new ArgumentNullException("member is null!");
             }

             this.FactoryMethod(dbName).Create(member);
         }

         protected virtual void Modify(Member member, string dbName)
         {
             if (member == null)
             {
                 throw new ArgumentNullException("member is null!");
             }

             this.FactoryMethod(dbName).Modify(member);
         }

         public abstract MemberDaoBase FactoryMethod(string dbName);
     }

     public class ManagerBO : MemberBOBase
     {
         public override MemberDaoBase FactoryMethod(string dbName)
         {
             if (dbName.ToUpper() == "ACCESS")
             {
                 return new ManagerAccessDao();
             }
             else if (dbName.ToUpper() == "SQLSERVER")
             {
                 return new ManagerSqlServerDao();
             }
             else
             {
                 throw new NotImplementedException(string.Format("{0} not implemented", dbName));
             }
         }
     }

     public class EmployeeBO : MemberBOBase
     {
         public override MemberDaoBase FactoryMethod(string dbName)
         {
             if (dbName.ToUpper() == "ACCESS")
             {
                 return new EmployeeAccessDao();
             }
             else if (dbName.ToUpper() == "SQLSERVER")
             {
                 return new EmployeeSqlServerDao();
             }
             else
             {
                 throw new NotImplementedException(string.Format("{0} not implemented", dbName));
             }
         }
     }

     public class ManagerAccessDao : MemberDaoBase
     {
         public override void Create(Member member)
         {
             throw new NotImplementedException();
         }

         public override void Modify(Member member)
         {
             throw new NotImplementedException();
         }
     }

     public class ManagerSqlServerDao : MemberDaoBase
     {
         public override void Create(Member member)
         {
             throw new NotImplementedException();
         }

         public override void Modify(Member member)
         {
             throw new NotImplementedException();
         }
     }

     public class EmployeeAccessDao : MemberDaoBase
     {
         public override void Create(Member member)
         {
             throw new NotImplementedException();
         }

         public override void Modify(Member member)
         {
             throw new NotImplementedException();
         }
     }

     public class EmployeeSqlServerDao : MemberDaoBase
     {
         public override void Create(Member member)
         {
             throw new NotImplementedException();
         }

         public override void Modify(Member member)
         {
             throw new NotImplementedException();
         }
     }

• 简单工厂和工厂方法之间的差异

简单工厂是将全部的事情,在一个地方都处理完了，而工厂方法却是创建了一个框架，让子类决定要如何实现。

例如：在工厂方法中我们有一个FactoryMethod()方法提供了一般的框架，一边创建Dao，FactoryMethod()方法依赖工厂方法创建具体类，决定制造出的Dao是什么。

简单工厂的做法，可以将对象的创建封装起来，但是简单工厂不具备工厂方法的弹性，因为简单工厂不能变更正在创建的产品。

• 这样的调整好处在于什么？

当我们需要条件一个新扩展Member数据操作类时，我们有统一的接口来，具体的操作方法都可不变，改动部分只需要扩展现有的MemberDaoFactory.cs，降低了应用层的耦合度。

•  优缺点：

　　1.) 优点：

a.) 降低了应用层次调用的耦合度；

b.) 当扩展时，有统一的接口类，开发更规范；

c.) 代码逻辑更清晰，代码更易管理维护。　　　　

　　2.) 缺点：

a.) 适用性很有限，前提条件有局限性；当我们的接口类MemberDaoBase.cs变动时，我们就需要改动多处代码；

b.) 当需要扩展时，我们依然避免不了要改动代码（尽管可以进一步改进通过设置配置和反射达到避免MemberDaoFactory变动，但是当我们需要添加新的扩展时还避免不了改动代码）。

参考资料：《Head First 设计模式》

　　欢迎拍砖！请牛人们给指点。