抽象工厂模式

抽象工厂模式

编辑

抽象工厂模式是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体的情况下，创建多个产品族中的产品对象。根据LSP原则，任何接受父类型的地方，都应当能够接受子类型。因此，实际上系统所需要的，仅仅是类型与这些抽象产品角色相同的一些实例，而不是这些抽象产品的实例。换言之，也就是这些抽象产品的具体子类的实例。工厂类负责创建抽象产品的具体子类的实例。

目录

1定义

2简介

3产品族

4类型

▪ 具体工厂

▪ 抽象产品

▪ 具体产品类

5使用情况

6农场系统

7模式

8其他关系

1定义编辑

为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类

2简介编辑

当每个抽象产品都有多于一个的具体子类的时候，工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产^[1]品角色都有两个具体产品。抽象工厂模式提供两个具体工厂角色，分别对应于这两个具体产品角色，每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。

每一个模式都是针对一定问题的解决方案，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式针对的是多个产品等级结构。

3产品族编辑

是指位于不同产品等级结构中，功能相关联的产品组成的家族。一般是位于不同的等级结构中的相同位置上。显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的，形成一个二维的坐标系，水平坐标是产品等级结构，纵坐标是产品族。叫做相图。

当有多个不同的等级结构的产品时，如果使用工厂方法模式就势必要使用多个独立的工厂等级结构来对付这些产品的等级结构。如果这些产品等级结构是平行的，会导致多个平行的工厂等级结构。

抽象工厂模式使用同一个 工厂等级结构负责这些不同产品等级结构产品对象的创建。

对于每一个产品族，都有一个具体工厂。而每一个具体工厂创建属于同一个产品族，但是分属于不同等级结构的产品。

通过引进抽象工厂模式，可以处理具有相同（或者相似）等级结构的多个产品族中的产品对象的创建问题。

由于每个具体工厂角色都需要负责两个不同等级结构的产品对象的创建，因此每个工厂角色都需要提供两个工厂方法，分别用于创建两个等级结构的产品。既然每个具体工厂角色都需要实现这两个工厂方法，所以具有一般性，不妨抽象出来，移动到抽象工厂角色中加以声明。

4类型

public interface Creator{

public ProductA factoryA();

public ProductB factoryB();

}

具体工厂

类别一：

public class ConcreteCreator1 implements Creator{

public ProductA factoryA(){

return new ProductA1();

}

public ProductB factoryB(){

return new ProductB1();

}

}

类别二：

public class ConcreteCreator2 implements Creator{

public ProductA factoryA(){

return new ProductA2();

}

public ProductB factoryB(){

return new ProductB2();

}

}

一般而言，有多少个产品等级结构，就会在工厂角色中发现多少个工厂方法。每一个产品等级结构中有多少个具体的产品，就有多少个产品族，也就会在工厂等级结构中发现多少个具体工厂。

抽象产品

类别A

public interface ProductA

{

}

类别B

public interface ProductB

{

}

具体产品类

ProdcutA1:

public class ProductA1 implements ProductA

{

public ProductA1()

{

}

}

ProdcutA2：

public class ProductA2 implements ProductA

{

public ProductA2()

{

}

}:

ProdcutA1:

public class ProductB1 implements ProductB

{

public ProductB1()

{

}

}

public class ProductB2 implements ProductB

{

public ProductB2()

{

}

}

在真实的系统中，产品等级结构的数目与每个产品等级结构中产品的数目（产品族）一般是不相等的。

5使用情况编辑

1.系统不依赖于产品类实例如何被创建，组合和表达的细节。

2.系统的产品有多于一个的产品族，而系统只消费其中某一族的产品（抽象工厂模式的原始用意Unix&Windows）

Button--->UnixButton/WinButton

Text----->UnixText/WinText

Unix产品族和Windows产品族，不会同时使用。

Factory--->UnixFactory/WinFactory

3.同属于同一个产品族是在一起使用的。这一约束必须在系统的设计中体现出来。

4.系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。

6农场系统编辑

在农场系统的实现

//两种抽象产品：水果、蔬菜

public interface Fruit

{

}

public interface Veggie

{

}

//四种具体产品：北方水果，热带水果，北方蔬菜，热带蔬菜

//Northern Fruit

public class NorthernFruit implements Fruit

{

private String name;

public NorthernFruit(String name)

{

}

public String getName()

{

return name;

}

public void setName(String name)

{

this. name = name;

}

}

//TropicalFruit

public class TropicalFruit implements Fruit

{

private String name;

public TropicalFruit(String name)

{

}

public String getName()

{

return name;

}

public void setName(String name)

{

this. name = name;

}

}

//NorthernVeggie

public class NorthernVeggie implements Veggie

{

private String name;

public NorthernVeggie(String name)

{

}

public String getName()

{

return name;

}

public void setName(String name)

{

this. name = name;

}

}

//TropicalVeggie

public class TropicalVeggie implements Veggie

{

private String name;

public TropicalVeggie(String name)

{

}

public String getName()

{

return name;

}

public void setName(String name)

{

this. name = name;

}

}

//抽象工厂角色

public interface Gardener

{

public Fruit createFruit(String name);

public Veggie createVeggie(String name);

}

//具体工厂角色：北方工厂，热带角色

public class NorthernGardener implements Gardener

{

public Fruit createFruit(String name)

{

return new NorthernFruit(name);

}

public Veggie createVeggie(String name)

{

return new NorthernVeggie(name);

}

}

public class TropicalGardener implements Gardener

{

public Fruit createFruit(String name)

{

return new TropicalFruit(name);

}

public Veggie createVeggie(String name)

{

return new TropicalVeggie(name);

}

}

这样客户端只需要创建具体工厂的实例，然后调用工厂对象的工厂方法就可以得到所需要的产品对象。

第二个例子：C++实现

例子：数据库访问程序设计，不同的数据库访问方式可能不一样，

为了抽象对对不同数据库的访问，可以将数据库隐藏起来，提供统一的访问方式，用多态进行实现

#include <iostream>

using namespace std;

//用户表接口

class IUser

{

public:

virtual void Insert() = 0;

virtual void GetUser() = 0;

};

//SqlServer数据库访问User表

class SqlServerUser : public IUser

{

public:

void Insert()

{

cout<<"在SQL Server中给User表增加一条记录"<<endl;

}

void GetUser()

{

cout<<"在SQL Server中给User表获取一条记录"<<endl;

}

};

//Access数据库访问User表

class AccessUser : public IUser

{

public:

void Insert()

{

cout<<"在Access中给User表增加一条记录"<<endl;

}

void GetUser()

{

cout<<"在Access中User表获取一条记录"<<endl;

}

};

//Department表接口

class IDepartment

{

public:

virtual void Insert() = 0;

virtual void GetDepartment() = 0;

};

//SqlServer数据库访问Department表

class SqlServerDepartment : public IDepartment

{

public:

void Insert()

{

cout<<"在SQL Server中给Department表增加一条记录"<<endl;

}

void GetDepartment()

{

cout<<"在SQL Server中Department获取一条记录"<<endl;

};

};

//Access数据库访问Department表

class AccessDepartment : public IDepartment

{

public:

void Insert()

{

cout<<"在Access中给Department表增加一条记录"<<endl;

}

void GetDepartment()

{

cout<<"在Access中Department获取一条记录"<<endl;

};

};

//抽象工厂接口

class IFactory

{

public:

virtual IUser* CreateUser() = 0;

virtual IDepartment* CreateDepartment() = 0;

};

//SqlServer工厂实现

class SqlServerFactory : public IFactory

{

IUser* CreateUser()

{

return new SqlServerUser();

}

IDepartment* CreateDepartment()

{

return new SqlServerDepartment();

}

};

//Access工厂实现

class AccessFactory : public IFactory

{

IUser* CreateUser()

{

return new AccessUser();

}

IDepartment* CreateDepartment()

{

return new AccessDepartment();

}

};

int main()

{

//创建工厂

IFactory * pFactory = NULL;

IUser * pUser = NULL;

IDepartment * pDepartment = NULL;

int choise;

cout<<"选择数据库: ";

cin>>choise;

switch(choise)

{

case 1:

pFactory= new SqlServerFactory(); //创建SqlServer访问的工厂

break;

case 2:

pFactory = new AccessFactory(); //创建Access访问的工厂

break;

}

//一致的操作

pUser = pFactory->CreateUser();

pDepartment= pFactory->CreateDepartment();

pUser->Insert();

pUser->GetUser();

pDepartment->Insert();

pDepartment->GetDepartment();

return 0;

}

7模式编辑

优点：

1.它分离了具体的类

2.它使得易于交换产品系列

3.它有利于产品的一致性

缺点：

难以支持新种类的产品

微型计算机配件，这个系统所需要的产品族有两个，一个系列是PC系列，另一个系列是MAC系列。

产品等级结构也有两个，一个是RAM，一个是CPU。

//两个抽象产品

public interface Cpu

{

}

public interface Ram

{

}

//四个具体产品

public class PcCpu implements Cpu

{

}

public class MacCpu implements Cpu

{

}

public class PcRam implements Ram

{

}

public class MacRam implements Ram

{

}

//抽象工厂角色

public interface ComputerProducer

{

Cpu createCpu();

Ram createRam();

}

//两个具体工厂角色

public class PcProducer implements ComputerProducer

{

public Cpu createCpu()

{

return new PcCpu();

}

public Ram createRam()

{

return new PcRam();

}

}

public class MacProducer implements ComputerProducer

{

public Cpu createCpu()

{

return new MacCpu();

}

public Ram createRam()

{

return new MacRam();

}

}

一般情况下，有多少个抽象产品，就有多少个工厂方法。（比如再增加一个PC与MAC不同的其他计算机配件，例如显卡）。

OCP(开放-封闭原则（The Open-Close Principle，简称OCP）)

增加产品族。

增加产品等级结构。

在不改变产品等级结构的情况下，增加产品族就是意味着向每一个产品等级结构中增加一个或者多个新的具体产品角色，这时只需要向工厂等级结构中增加新的元素就可以了，具体的说，只需要增加新的具体工厂类就可以了。

在产品族数目不变的情况下，增加产品等级结构，相当于增加一个与现有产品等级结构平行的一个新的产品等级结构，这时需要向修改所有的工厂角色，增加一个新的工厂方法,这是不支持OCP的。

Producer

PcProducer MacProducer

CPU

PcCPU MacCPU

RAM

PcRAM MacCPU

在上面的结构中，增加产品族相当于增加一个新的厂商，比如Sun的CPU和RAM,这时，只需要增加一个SunProducer即可。

而增加一个新的产品等级结构相当于增加一个显卡，而显卡也有Pc和Mac之分，那么对于所有的Producer，都需要增加一个方法：createCard()

8其他关系编辑

与其他设计模式

单例模式：具体工厂类可以设计成单例类，一个单例类只有一个实例，它自己向外界提供自己唯一的实例。很显然，在农场系统中，只需要NorthernGardener和TropicalGardener的一个实例就可以了。而在计算机生产的例子中，PcProducer和RamProducer也分别只需要一个实例。

工厂的工厂：工厂角色与抽象产品角色合并（简单工厂模式java.util.DateFormat）,在抽象工厂模式中，抽象工厂类可以有静态方法，这个方法根据参数的值，返回对应的具体工厂类实例，但是其返回值类型是抽象工厂类型，这样可以在多态性的保证之下，允许静态工厂方法自行决定哪一个具体工厂符合要求。

//计算机生产抽象工厂角色

abstract public class ComputerProducer

{

public static ComputerProducer getProducer(String which)

{

if (which.equalsIgnoreCase("PC"))

{

return new PcProducer();

}

else if (which.equalsIgnoreCase("Mac"))

{

return new MacProducer();

}

else

{

return null;

}

}

}

工厂的工厂：工厂角色可以和具体产品角色合并（简单工厂模式），在抽象工厂模式中，每一个具体工厂类可以有一个静态方法，其返回值类型是该具体工厂类自己。

public class MacProducer extends ComputerProducer

{

private static MacProducer producer = new MacProducer();

private MacProducer() {

}

public Cpu createCpu()

{

return new MacCpu();

}

public Ram createRam()

{

return new PcRam();

}

public static MacProducer getInstance()

{

return producer;

}

}

女娲造万物的故事：

神绳（+举绳造物（））

阴绳 阳绳

人

女人 男人

动物

雌性 雄性

在JAVA语言的AWT库中，使用了抽象工厂模式创建分水域不同操作系统的Peer构件（与本地系统相关的GUI组件）。