結合項目執行個體 回顧傳統設計模式（四）工廠模式(簡單工廠、普通工廠、抽象工廠)

關于工廠模式和單例模式  大部分項目這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();

                return new OracleInstance();

                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;

            this.di.ExecuteNonQuery();

            this.di.ExecuteDataset();

準确來說，簡單工廠并不是一種設計模式，反而比較像是一種程式設計習慣。上述case隻是把問題從一個對象搬到另一個對象中，問題依然存在。但是SimpleFactory可以有許多客戶，把建立執行個體的代碼包裝進一個類，當以後實作改變時，隻需修改這個類就可以了。物品們也正要把具體執行個體化的過程從客戶的代碼中删除。

下面我就來介紹下兩個重量級的模式！

工廠方法模式

public abstract class facotoryCase

        {          

            di = create(type);

       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)

            return null;

    public class facotoryCaseB : facotoryCase

            if (type.Equals("Mysql"))

            }          

工廠方法模式定義了一個建立對象的接口，但由子類決定要執行個體化的類是哪一個。工廠方法讓類把執行個體化推遲到子類。

設計原則：要依賴抽象不要依賴具體類。

接下來再看下抽象工廠模式

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

            return new oracleparam();

            return new oracleconnecttion();

抽象工廠模式提供一個接口，用于建立相關或依賴對象的家族而不需要明确指定具體類。

本文轉自 熬夜的蟲子  51CTO部落格，原文連結:http://blog.51cto.com/dubing/712407