结合项目实例 回顾传统设计模式（四）工厂模式(简单工厂、普通工厂、抽象工厂)

关于工厂模式和单例模式  大部分项目这2种模式都很常见

例如在orm框架中 工厂模式常用来封装数据库的创建 我们分3种case来看 简单工厂模式 普通工厂模式 抽象工厂模式

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

一般惯性思维 我们遇到分支判断时会这样

  public  class NormalCase
    {
         private DBInstance dbInstance;
         public NormalCase( string type)
        {
               if (type.Equals( " SQL "))
            {
                dbInstance=   new SqlInstance();
            }
             else  if (type.Equals( " Oracle "))
            {
                dbInstance =  new OracleInstance();
            }
             else  if (type.Equals( " Mysql "))
            {
                dbInstance =  new MysqlInstance();
            }
        }
         public  void ExecuteNonQuery()
        {
             this.dbInstance.ExecuteNonQuery();
        }
         public  void ExecuteDataset()
        {
             this.dbInstance.ExecuteDataset();
        }
    }

那么 new有什么不好，在技术上new没什么错，但是好的设计针对扩展开放而对修改关闭。

针对接口编程，可以隔离掉以后系统可能发生的一大堆改变。如果代码是针对接口编写，那么通过多态，它可以与任何新类实现该接口。

下面让我们看看工厂模式如何解决该问题

先来看看简单工厂

 

public  class SimpleFactory
    {
         public DBInstance createinstance( string type)
        {
            DBInstance di =  null;
             if (type.Equals( " SQL "))
            {
                 return  new SqlInstance();
            }
             else  if (type.Equals( " Oracle "))
            {
                 return  new OracleInstance();
            }
             else  if (type.Equals( " Mysql "))
            {
                 return  new MysqlInstance();
            }
             return di;
            
        }
    }

     public  class SimpleCase
    {
        SimpleFactory facotory;
        DBInstance di;
         public SimpleCase(SimpleFactory facotory)
        {
             this.facotory = facotory;
        }
         public DBInstance CreateInstance( string type)
        {            
             di = facotory.createinstance(type);
              return di;

        }
         public  void ExecuteNonQuery()
        {
             this.di.ExecuteNonQuery();
        }
         public  void ExecuteDataset()
        {
             this.di.ExecuteDataset();
        }

    }

 

准确来说，简单工厂并不是一种设计模式，反而比较像是一种编程习惯。上述case只是把问题从一个对象搬到另一个对象中，问题依然存在。但是SimpleFactory可以有许多客户，把创建实例的代码包装进一个类，当以后实现改变时，只需修改这个类就可以了。物品们也正要把具体实例化的过程从客户的代码中删除。

下面我就来介绍下两个重量级的模式！

工厂方法模式

public  abstract  class facotoryCase
    {
        DBInstance di;
         public DBInstance CreateInstance( string type)
        {          
            di = create(type);
             return di;
        }
        public  abstract DBInstance create( string type);

        public  void ExecuteNonQuery()
       {
            this.di.ExecuteNonQuery();
       }
        public  void ExecuteDataset()
       {
            this.di.ExecuteDataset();
       }
    }

     public  class facotoryCaseA : facotoryCase
    {
         public  override DBInstance create( string type)
        {
             if (type.Equals( " SQL "))
            {
                 return  new SqlInstance();
            }
             else  if (type.Equals( " Oracle "))
            {
                 return  new OracleInstance();
            }
             return  null;
        }
    }

     public  class facotoryCaseB : facotoryCase
    {
         public  override DBInstance create( string type)
        {
             if (type.Equals( " Mysql "))
            {
                 return  new MysqlInstance();
            }          
             return  null;
        }
    }

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

设计原则：要依赖抽象不要依赖具体类。

接下来再看下抽象工厂模式

public  class Param { }
     public  class sqlparm : Param { }
     public  class oracleparam : Param { }
     public  class connection { }
     public  class sqlconnecttion : connection { }
     public  class oracleconnecttion : connection { }


     public  interface abstractCase
    {
        Param GetParameter();
        connection GetConnection();
    }

     public  abstract  class DBInstanceforabstract
    {
         public Param p;
         public connection c;
         public  abstract  void ExecuteNonQuery();
         public  abstract  void ExecuteDataset();
    }

     public  class DBInstanceforabstractA : DBInstanceforabstract
    {
        abstractCase ac;
         public DBInstanceforabstractA(abstractCase ac)
        {
             this.ac = ac;
        }
         public  override  void ExecuteNonQuery()
        {
            p = ac.GetParameter();         
        }
         public  override  void ExecuteDataset()
        {
            c = ac.GetConnection();
          
        }
         
    }

     public  class abstractCaseA : abstractCase
    {
        DBInstanceforabstract di;
         public Param GetParameter()
        {
             return  new sqlparm();
        }
         public connection GetConnection()
        {
             return  new sqlconnecttion();
        }
    }

     public  class abstractCaseB : abstractCase
    {
        DBInstanceforabstract di;
         public Param GetParameter()
        {
             return  new oracleparam();
        }
         public connection GetConnection()
        {
             return  new oracleconnecttion();
        }
    }

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族而不需要明确指定具体类。