三大工廠設計模式的演變與優缺點思考

之前都是以記錄筆記的方式寫很短的隨筆；然而這一次比較長，因爲時間，表達能力，理解能力有限，確定有不少不完整和錯誤的地方，請各位多多包含，後期會不斷完善和修改；謝謝！

三大工廠模式:簡單工廠模式，工廠方法模式，抽象工廠模式

咱們先來舉例子,好比咱們要從SQLServer數據庫獲取與新增Department。

面向過程編程： 

static void Main(string[] args)
{
    try
    {
        Console.Write("請輸入數字Get or Insert：");
        string strOperation=Console.ReadLine();
        switch(strOperation)
        {
            case "Get": 
　　　　　　　　　　Console.WriteLine("在SQL Server中給Department表增長一條記錄");
　　　　　　　　　　 break;
            case "Insert": 
　　　　　　　　　　Console.WriteLine("在SQL Server中根據ID獲得給Department表一條記錄"); 
　　　　　　　　　　break;
        }
    }
    catch(Exception e)
    {
        Console.WriteLine("程序出現異常："+e.Message);
    }
 }

 

但以上代碼修改時會牽一髮而動全身，極可能牽扯到其餘不該該修改的代碼，若是代碼長的話進行維護時甚至本身都不認識，並且代碼的複用性也不高。這時面向對象編程就起到了做用。因此咱們須要對代碼進行封裝。

面向對象方法設計就是用封裝，繼承，多態來實現代碼的可維護，可擴展，可複用，靈活性好。

面向對象編程，對界面與業務的分離

public class Department
{        
        public static string GetResult(string strOperation)
        {
            string result=string.Empty;
            switch(strOperation)
            {
                 case "Insert": result = "在SQL Server中給Department表增長一條記錄"; 
　　　　　　　　　　　　　　　　　　　break;
                 case "Get": result = "在SQL Server中根據ID獲得給Department表一條記錄"; 
　　　　　　　　　　　　　　　　　　　　break;
            }
            return result;
        }
        
    }
 public class Program 
 {
 　　    static void Main(string[] args)
 　　    {
                try
                {
                    Console.Write("請輸入數字Insert or Get：");
                    string strOperation=Console.ReadLine();
                    string strResult = Department.GetResult(strOperation);
                    Console.WriteLine(strResult);
                }
                catch(Exception e)
                {
                    Console.WriteLine("程序出現異常："+e.Message);
                }
          }
}   

 可是，這時，若是咱們須要對業務中新增其餘功能，如刪除，那就會對修改開放了，違背了「開放-封閉」原則：只能對擴展開放，而不能對修改開放。因此咱們須要對操做進行分離和封裝,而且使用接口,它的好處就是讓功能的定義與實現分離,這樣對於用戶來講,他們以相同的方式調用接口,而卻有不一樣的實現方式。因此我繼續對業務層進行分離.

public class Department
    {
        public string strResult = string.Empty;
        public virtual string GetResult()
        {               
               return strResult;
        }
    }
    class InsertSqlserverDepartment : Department
    {
         public override string GetResult()
         {
             strResult = "在SQL Server中給Department表增長一條記錄";
             return strResult;
         }
    }
    class GetSqlserverDepartment : Department
    {
         public override string GetResult()
         {
             strResult = "在SQL Server中根據ID獲得給Department表一條記錄";
             return strResult;
         }
    }

    public class Program 
    {
 　　    static void Main(string[] args)
 　　    {
           //Console.WriteLine("請輸入你所要的操做，Insert or Get");
           //string strOperation = Console.ReadLine();
           Department oper;
           oper = new GetSqlserverDepartment();
           string strResult = oper.GetResult();
           Console.WriteLine(strResult);
           Console.ReadLine();
          }
     }      

可是我想根據客戶端的選擇條件動態實例化相關的類

1.簡單工程模式

public class Department
    {
        public string strResult = string.Empty;
        public virtual string GetResult()
        {               
               return strResult;
        }
    }
    class InsertSqlserverDepartment : Department
    {
         public override string GetResult()
         {
             strResult = "在SQL Server中給Department表增長一條記錄";
             return strResult;
         }
    }
    class GetSqlserverDepartment : Department
    {
         public override string GetResult()
         {
             strResult = "在SQL Server中根據ID獲得給Department表一條記錄";
             return strResult;
         }
    }
    public class DepartmentFactory
    {
        public static Department createDepartmentOperation(string type)
        {
            Department dept = null;
            switch (type)
            {
                case "Insert": dept = new InsertSqlserverDepartment(); break;
                case "Get": dept = new GetSqlserverDepartment(); break;
            }
            return dept;
        }
    }
 
    public class Program 
    {
 　　    static void Main(string[] args)
 　　    {
           Console.WriteLine("請輸入你所要的操做，Insert or Get");
           string strOperation = Console.ReadLine();
           Department oper;
           oper =DepartmentFactory.createDepartmentOperation(strOperation);
           string strResult = oper.GetResult();
           Console.WriteLine(strResult);
           Console.ReadLine();
          }
     }        

 這裏咱們的代碼已經達到了"高內聚,低耦合".但在後期擴展維護方面可能還會有問題,這裏咱們只是操做SQL Server數據庫,之後咱們可能操做不一樣數據庫的同一個產品，此時就要添加另外一種數據操做類了，如下的模式就派上用場了。

2.工廠方法模式

 

class Department
    {
        public int ID{get;set;}
        public int DeptName{get;set;}
    }

    interface IDepartment
    {
        void Insert(Department dept);
        Department GetDepartment(int id);
    }
    class SqlserverDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在SQL Server中給Department表增長一條記錄");
        }
        public void GetDepartment(int id)
        {
            Console.WriteLine("在SQL Server中根據ID獲得給Department表一條記錄");
        }
    }
    class OracleDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在Oracle中給Department表增長一條記錄");
        }
        public void GetDepartment(int id)
        {
            Console.WriteLine("在Oracle中根據ID獲得給Department表一條記錄");
        }
    }
    interface IFactory
    {
        IDepartment CreateDepartment();
    }
    class SqlServerFactory : IFactory
    {
       
        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }
    class OracleFactory : IFactory
    {
       
        public IDepartment CreateDepartment()
        {
            return new OracleDepartment();
        }
    }
    public class Program 
    {
 　　    static void Main(string[] args)
 　　    {         
           Department dept = new Department();
           //IFactory factory = new SqlServerFactory();
           IFactory factory = new OracleFactory();

           IDepartment idept = factory.CreateDepartment();
           idept.Insert(dept);
           idept.GetDepartment(1);

           Console.ReadLine();
          }
 }      

以上的代碼我就實現了對不一樣數據庫的操做,當咱們想要改變數據庫時,咱們只須要在客戶端初始化時告訴他們就能夠了,其餘地方的代碼都不須要改變了.是否是很強大,哈哈.

但這裏還會有變更的地方,由於咱們數據庫通常不僅是操做一張表，極可能還會多張表,好比用戶表，那咱們繼續添加，這裏就有了如下的設計模式

3.抽象工廠模式

　　class Department
    {
        public int ID{get;set;}
        public int DeptName{get;set;}
    }
    class User
    {
        public int ID { get; set; }
        public int UserName { get; set; }
    }
    interface IDepartment
    {
        void Insert(Department department);
        Department GetDepartment(int id);
    }
    interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }
    class SqlserverDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在SQL Server中給Department表增長一條記錄");
        }
        public void GetDepartment(int id)
        {
            Console.WriteLine("在SQL Server中根據ID獲得給Department表一條記錄");
        }
    }
    class OracleDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在Oracle中給Department表增長一條記錄");
        }
        public void GetDepartment(int id)
        {
            Console.WriteLine("在Oracle中根據ID獲得給Department表一條記錄");
        }
    }
    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在SQL Server中給User表增長一條記錄");
        }
        public void GetDUser(int id)
        {
            Console.WriteLine("在SQL Server中根據ID獲得給User表一條記錄");
        }
    }
    class OracleUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Oracle中給User表增長一條記錄");
        }
        public void GetUser(int id)
        {
            Console.WriteLine("在Oracle中根據ID獲得給User表一條記錄");
        }
    }
    interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }
    class SqlServerFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }
    class OracleFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new OracleUser();
        }
        public IDepartment CreateDepartment()
        {
            return new OracleDepartment();
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            User user = new User();
            Department dept = new Department();
            //IFactory factory = new SqlServerFactory();
            IFactory factory = new OracleFactory();

            IUser iu = factory.CreateUser();
            iu.Insert(user);
            iu.GetUser(1);

            IDepartment idept = factory.CreateDepartment();
            idept.Insert(dept);
            idept.GetDepartment(1);

            Console.ReadLine();
        }
    }

 

總結：

簡單工廠模式：他的最大優勢就是在於工廠類包含了必要的邏輯判斷，根據客戶端的選擇條件動態實例化相關的類，對於客戶端來講，去除了與具體產品的依賴，當算法比較穩定，通常不會對它進行新增，或刪除等就適合用詞模式；不然就會違背了「開放-封閉」原則

工廠方法模式：它定義了用於建立對象的接口，讓子類決定實例化哪個類，工廠方法使一個類的實例化延遲到其子類。

抽象方法模式：當產品有不一樣的系列，而不一樣的系列又有不一樣的建立方式，此時就適合用此模式

 

本人文筆表達有限，若有不到位的地方，還請包涵，若有解決你的問題，請轉發或點贊，謝謝。

本人聯繫方式：

                更多精彩分享，可關注個人微信公衆號：

                                    

                 微信號：WeixinJungle

　　　　　　　　　　　　  

                 郵箱:oneou6688@163.com