设计模式之工厂三姐妹

简单工厂，工厂方法和抽象工厂是一个大家族，三个很好的姐妹。那么我们分别来介绍一下这三个姐妹。

一、简单工厂

定义

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

结构图

模式实现

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">
public class OperationFactory
{
public static Operation createOperate(string operate)
{
Operation oper = null;
switch (operate)
{
case "+":
oper = new OperationAdd();
break;
case"-":
oper = new OperationSub();
break;
case "*":
oper=new OperationMul();
break;
case"/":
oper=new OperationDiv();
break;

}
return oper;
}</SPAN>

 public class OperationFactory
    {
        public static Operation createOperate(string operate)
        {
           Operation oper = null;
            switch (operate)
            { 
                case "+":
                    oper = new OperationAdd();
                    break;
                case"-":
                    oper = new OperationSub();
                    break;
                case "*":
                    oper=new OperationMul();
                    break;
                case"/":
                    oper=new OperationDiv();
                    break;

            }
            return oper;
        }

客户端代码：

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">Operation oper;
oper = OperationFactory.createOperate("+");
oper.NumberA = 1;
oper.NumberB = 2;
double result = oper.GetResult();</SPAN>

Operation oper;
                oper = OperationFactory.createOperate("+");
                oper.NumberA = 1;
                oper.NumberB = 2;
                double result = oper.GetResult();

这样子如果要增加复杂的运算，不仅要增加子类，还要修改运算类工厂，由于开放——封闭原则是对扩展是开放的，对修改是关闭的，就违背了开放——扩展原则。于是简单工厂就被淘汰了。因为简单工厂很容易违反高内聚责任分配原则，因此只在一般很简单的情况下应用。

于是大姐抽象工厂和二姐工厂方法都全力以赴,参加比赛.

二、抽象工厂

定义

提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类.

结构图

抽象工厂的优缺点

优点

第一,易于交换产品系列,由于具体工厂类,在一个应用中只需要在初始化的时候出现一次,这就是的改变一个应用的具体工厂变得非常容易,他只需要改变具体工厂即可使用不同的产品配置.

第二,它让具体的创建实例过程与客户端分离,客户端是通过他们的抽象接口操纵实例,产品的具体类名也被具体工厂的实现分离,不会出现在客户代码中.

缺点

由于增加功能进而添加多个子类会使得抽象工厂很臃肿,而且在每个类的开始都需要声明,实例化.这样更改很浪费.

用简单工厂改造抽象工厂

结构图

实现

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">class DataAccess
{
private static
readonly string db =
"Sqlserver";
//private static readonly string db="Access"; 数据库名称可替换成Access

public static IUser CreateUser()
{
IUser result = null;
switch (db)
{
case "Sqlserver":
result = new SqlserverUser();
break;

case "Access":
result = new AccessUser();
break;
}
return result;
}

public static IDepartment CreateDepartment()
{
IDepartment result = null;
switch (db) 
//由于db事先设置，此处可以根据选择实例化出相应对象
{
case "Sqlserver":
result = new SqlserverDepartment();
break;
case"Access":
result = new AccessDepartment();
break;
}
return result;
}
}</SPAN>

class DataAccess
    {
        private static readonly string db = "Sqlserver";
        //private static readonly string db="Access";  数据库名称可替换成Access

        public static IUser CreateUser()
        {
            IUser result = null;
            switch (db)
            { 
                case "Sqlserver":
                    result = new SqlserverUser();
                    break;

                case "Access":
                    result = new AccessUser();
                    break;
            }
            return result;
        }

        public static IDepartment CreateDepartment()
        {
            IDepartment result = null;
            switch (db)    //由于db事先设置，此处可以根据选择实例化出相应对象
            { 
                case "Sqlserver":
                    result = new SqlserverDepartment();
                    break;
                case"Access":
                    result = new AccessDepartment();
                    break;
            }
            return result;
        }
    }

客户端代码

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">
static void Main(string[] args)
{
User user = new User();
Department dept = new Department();

IUser iu = DataAccess.CreateUser();

iu.Insert(user);
iu.GetUser(1);

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

Console.Read();
}</SPAN>

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

            IUser iu = DataAccess.CreateUser();

            iu.Insert(user);
            iu.GetUser(1);

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

            Console.Read();
        }

客户端没有出现任何一个SQL Server或者Access的字样，达到了解耦的目的。

DataAccess类取代三个工厂类，由于实现设置了db的值（Sqlserver或Access），所以，简单工厂的方法都不需要输入参数，这样在客户端就只需要DataAccess.CreateUser()和DataAccess.CreateDepartment()来生成具体的数据可访问类实例。

用反射+配置文件实现数据访问程序

所有用在简单工厂的地方，都可以考虑用反射技术来去除switch或if，解除分支判断带来的耦合。反射技术可以很好的解决它们难以应对的变化，难以维护和扩展的诟病。

操作

添加一个App.config文件，内容如下：

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px"><?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="DB" value="Sqlserver"/>
//配置文件，sqlserver可以替换成Access
</appSettings>
</configuration>
</SPAN>

<?xml version="1.0"  encoding="utf-8" ?>
<configuration>
     <appSettings>
         <add key="DB" value="Sqlserver"/>   //配置文件，sqlserver可以替换成Access
    </appSettings>
</configuration>

添加引用System.configruation，并在程序开头增加using System.AppSettings;然后更改DataAccess类的字段DB的赋值代码。

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">Private
static readonly
string db=ConfigurationManager.AppSettings["DB"];</SPAN>

Private  static readonly string db=ConfigurationManager.AppSettings["DB"];

总结

抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类；一个抽象工厂类，可以派生出多个具体工厂类；每个具体工厂类可以创建多个具体产品类的实例。

三、工厂方法模式

工厂方法模式可以用一个很简单的实例来理解就是雷锋依然在人间。

定义

工厂方法模式是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

结构图

具体实现

例如结构图如下的实现

可以用工厂类去实现运算类，相应的子类工厂去实现子运算类。需要哪个就用哪个工厂类去实例化相应的运算类就可以了。

（1）先构建一个接口

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">interface IFactory
{
Operation CreateOperation();
}</SPAN>

interface IFactory
    {
        Operation CreateOperation();
    }

（2）用具体工厂去实现这个接口

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">class AddFactory:IFactory
{
public Operation CreateOperation()
{
return new OperationAdd();
}
}
class SubFactory:IFactory
{
public Operation CreateOperation()
{
return new OperationSub();
}
}
class DivFactory:IFactory
{
public Operation CreateOperation()
{
return new OperationDiv();
}
class MulFactory:IFactory
{
public Operation CreateOperation()
{
return new OperationMul();
}
}</SPAN>

class AddFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationAdd();
        }
    }
 class SubFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationSub();
        }
    }
 class DivFactory:IFactory 
    {
        public Operation CreateOperation()
        { 
        return new OperationDiv();
        }
 class MulFactory:IFactory 
    {
        public Operation CreateOperation()
        {
            return new OperationMul();
        }
    }

客户端的实现

<SPAN style="FONT-FAMILY: SimSun; FONT-SIZE: 18px">IFactory operFactory =
new AddFactory();
Operation oper = operFactory.CreateOperation();
oper.NumberA = 1 ;
oper.NumberB = 2;
double result = oper.GetResult();</SPAN>

IFactory operFactory = new AddFactory();
                Operation oper = operFactory.CreateOperation();
                oper.NumberA = 1 ;
                oper.NumberB = 2;
                double result = oper.GetResult();

总结

工厂方法模式是一个抽象产品类，可以派生出多个具体产品类；一个抽象工厂类，可以派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。

四、对比

简单工厂VS.抽象方法

简单工厂模式：工厂角色可以和具体产品角色合并。

抽象工厂模式中，每一个具体工厂类可以有一个静态方法，其返回值类型是该具体工厂类自己。

简单工厂VS.工厂方法

简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，也就是说，工厂方法把简单的内部逻辑判断一道了客户端代码来进行。你想要加功能，本来是改工厂类的，而现在是修改客户端。

工厂方法模式VS.抽象工厂模式

工厂方法是基础可以根据需要灵活运用，向抽象工厂演化。

工厂方法模式只有一个抽象的产品类，而抽象工厂模式又多个；工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

五、总结

三个工厂模式都属于设计模式中的创建型模式。主要功能都是帮助我们把对象的实例化部分抽取了出来，优化了系统的架构，增强了系统的扩展性。

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。如果不修改代码的话，是无法扩展的。

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产汽车，轿车，客车，每一个工厂都由创建这些不同种类车的方法。