三大工厂设计模式的演变与优缺点思考

时间 2019-11-20

原文原文链接

之前都是以记录笔记的方式写很短的随笔；然而这一次比较长，因为时间，表达能力，理解能力有限，确定有不少不完整和错误的地方，请各位多多包含，后期会不断完善和修改；谢谢！算法

三大工厂模式:简单工厂模式，工厂方法模式，抽象工厂模式数据库

咱们先来举例子,好比咱们要从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);
    }
 }

但以上代码修改时会牵一发而动全身，极可能牵扯到其余不该该修改的代码，若是代码长的话进行维护时甚至本身都不认识，并且代码的复用性也不高。这时面向对象编程就起到了做用。因此咱们须要对代码进行封装。微信

面向对象方法设计就是用封装，继承，多态来实现代码的可维护，可扩展，可复用，灵活性好。ide

面向对象编程，对界面与业务的分离spa

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.简单工程模式code

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数据库,之后咱们可能操做不一样数据库的同一个产品，此时就要添加另外一种数据操做类了，如下的模式就派上用场了。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