设计模式（二）（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(0);
            

如果代码中不再变动还好，但这种情况很多时候是不存在的，当来了一个新的领导，领导说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(0);

如果我们将不稳定的部分给交给两外一个类单独管理，就能把这种耦合变得低一点，当我们需要“变动”时，只用去修改这个管理类；而这管理来是用来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 设计模式》

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