设计模式（3）---抽象工厂模式及工厂模式总结

一、引言　　

　　在前面分别讲述了简单工厂模式和工厂模式，工厂方法模式是为了克服简单工厂模式的缺点而设计出来的，但是在现实生活中，一个工厂只创建单个产品这样的例子很少，因为现在工厂都多元化了，是一个工厂创建一系列产品，此时工厂模式显示不适用，抽象工厂模式可以很好的解决此问题。本节学习抽象工厂模式，最后会对这三种模式做简单总结，加深对这几种模式的理解。

　　

二、定义

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

 　　角色：

　　抽象工厂：声明生成一系列抽象产品的方法。具体工厂：执行生成一系列抽象产品的方法，生成一系列具体的产品。

　　抽象产品：声明一系列某一种产品的接口。具体产品：定义具体工厂生成的具体产品的对象，实现产品接口。

三、UML图：

　　

四、举例说明：

　　在实际项目中，需要用到数据库，必然有一些数据库连接语句。在本例中，项目需要同时兼任sqlserver和access两种数据库，为了更加便利地解决此问题，用抽象工厂解决。　

　　抽象产品和具体产品角色：　

class User
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }

        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

    interface IUser
    {
        void Insert(User user);
    }

    class SqlserverUser:IUser 
    {
        public void Insert(User user)
        {
            Console.WriteLine("在sqlserver中给User表增加一条记录");
        }
    }

    class AccessUser:IUser 
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }
    }

　　抽象工厂和具体工厂角色：　

interface IFactory
    {
        IUser CreateUser();
    }

    class SqlserverFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }
    }

    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }
    }

　　客户端调用：　

User user = new User();

            IFactory factory = new SqlserverFactory();
            IUser iu = factory.CreateUser();
            iu.Insert(user);

　　看了上面这个实例，给人的感觉就是工厂模式，而不是抽象工厂，对不对？我的理解也是如此。给出UML图看看：

　　下面贴出一段代码：

class Program
    {
        static void Main(string[] args)
        {
            User user = new User();
            Department dept = new Department();

            IFactory factory = new AccessFactory();

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

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

            Console.Read();
        }
    }

    class User
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }

        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

    interface IUser
    {
        void Insert(User user);
        User GetUser(int id);
    }

    class SqlserverUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在sqlserver中给User表增加一条记录");
        }

        public User GetUser(int id)
        {
            Console.WriteLine("在sqlserver中根据ID得到User表一条记录");
            return null;
        }
    }

    class AccessUser : IUser
    {
        public void Insert(User user)
        {
            Console.WriteLine("在Access中给User表增加一条记录");
        }

        public User GetUser(int id)
        {
            Console.WriteLine("在Access中根据ID得到User表一条记录");
            return null;
        }
    }

    class Department
    {
        private int id;
        public int ID
        {
            get { return id; }
            set { id = value; }
        }

        private string name;
        public string Name
        {
            get { return name; }
            set { name = value; }
        }
    }

    interface IDepartment
    {
        void Insert(Department department);
        Department GetDepartment(int id);
    }

    class SqlserverDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在sqlserver中给Department表增加一条记录");
        }

        public Department GetDepartment(int id)
        {
            Console.WriteLine("在sqlserver中根据ID得到Department表一条记录");
            return null;
        }
    }

    class AccessDepartment : IDepartment
    {
        public void Insert(Department department)
        {
            Console.WriteLine("在Access中给Department表增加一条记录");
        }

        public Department GetDepartment(int id)
        {
            Console.WriteLine("在Access中根据ID得到Department表一条记录");
            return null;
        }
    }

    interface IFactory
    {
        IUser CreateUser();
        IDepartment CreateDepartment();
    }

    class SqlserverFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new SqlserverUser();
        }

        public IDepartment CreateDepartment()
        {
            return new SqlserverDepartment();
        }
    }

    class AccessFactory : IFactory
    {
        public IUser CreateUser()
        {
            return new AccessUser();
        }

        public IDepartment CreateDepartment()
        {
            return new AccessDepartment();
        }
    }

　　它的UML类图如下：

　　

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

　　工厂模式定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

　　简单工厂：一个类专门负责创建其他类的实例，具体创建什么实例由传入的参数而决定，并且这些类都共同继承于一个父类或者有共同的接口。

　　从抽象工厂的UML类图和工厂模式的UMl类图中似乎可以看出其区别，抽象工厂模式是提供一系列对象的接口，而工厂模式则不是。（不知道理解的对不对）。抽象工厂模式有多个方法，是创建多个产品的，工厂模式只有一个方法，创建一种产品。（这里可以在IUser中加入多个方法，此处暂时没有添加。）既然抽象工厂、工厂模式的UML类图都有了，今天把简单工厂的也放在一起，对比出效果。

　　简单工厂UML：

　　总而言之：

　　简单工厂：是系统根据外界传入的具体信息创建所需的实例，等于是客户端不必关心产品如何生产，只负责指定生产什么产品。

　　工厂模式：让子类决定创建什么产品，即：使一个类的实例化延迟到子类。

　　抽象工厂模式：便于交换产品系列，同时让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端。