初学Java设计模式随记 -- 抽象工厂(Abstract Factory)模式

 抽象工厂(Abstract Factory)模式的定义如下：

  

1. 用意： 提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

(Provide an interface for creating families of related or dependent objects without specifying their concrete classes.)

 

2. 参与者:（5种角色）
• 抽象工厂（AbstractFactory）： 声明一个创建抽象产品对象的操作接口。
• 具体工厂（ConcreteFactory）： 实现创建具体产品对象的操作。
• 抽象产品（AbstractProduct）： 为一类产品对象声明一个接口。
• 具体产品（ConcreteProdcut）： 定义一个将被相应的具体工厂创建的产品对象。实现抽象产品（AbstractProduct）接口。
• 客户端（Client）：仅使用由抽象工厂（AbstractFactory）和抽象产品（AbstractProduct）类声明的接口。

 

在刚看到客户端（client）这个角色的时候，有点迷惑，不知道客户端（client）在抽象工厂模式中是什么作用？

它与之前学习“简单工厂模式”和“工厂方法模式”时，写的那例子（1~7）中的客户端（Customer）是否一样?是代表的同一个意思吗？如果一样，为什么工厂方法模式里没有客户端（client）这个参与者呢？

 

在GOF的设计模式中，包含了“客户端（Client）”这个参与者；而在阎宏的《Java与模式》中没有包含“客户端（Client）”这个参与者。

 

后来，似乎明白了，客户端（client）应该会使用抽象工厂来将抽象产品给组装起来，并为使用抽象工厂模式的客户端（Customer）提供了一个调用接口。在下面的例子8中将来理解客户端（client）的作用。

其实在很多资料的例子中，都将客户端（Client）合并到了抽象工厂中，也有合并到客户端（Customer）中的。

 

3. 结构：

图1：在GoF的设计模式中（类似下面的形式）

 

图2：在阎宏的《Java与模式》中（类似下面的形式）

 

 

 

看到抽象工厂模式，总是会拿工厂方法模式与它作比较。

 

这两个模式有四个相同的角色：

抽象工厂（AbstractFactory）--->具体工厂（ConcreteFactory）

抽象产品（AbstractProduct）--->具体产品（ConcreteProdcut）

 

那么，这两个模式有什么不同呢？ 

 

看看用意有什么不同:

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

(Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.)

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

(Provide an interface for creating families of related or dependent objects without specifying their concrete classes.)

 

通过这两个模式的用意，可以看出：

1.工厂方法模式是用来创建一个产品对象的，也就是说，每个抽象工厂是用来创建一种抽象产品对象，继承抽象工厂的每个具体工厂是用来创建一种具体产品对象的。

2.抽象工厂模式是用来创建多个（一套或一系列）产品对象的，也就是说，每个抽象工厂是用来创建多种（一套或一系列）抽象产品对象，继承抽象工厂的每个具体工厂都可以用来创建多种（一套或一系列）具体产品对象的。

 

依然以“生产汽车”为例，那么，

1.工厂方法模式下，每个汽车是一个产品对象（发动机，车门等汽车零部件都被看作是汽车的属性）。

工厂生产汽车的过程，实际上只是组装汽车零部件的过程。

2.抽象工厂模式下，每个汽车由一套汽车零部件产品对象（发动机，车门等都是产品，不再是属性）组成的。

工厂生产汽车的过程，就变成了，先生产各个汽车零部件产品，然后再组装汽车零部件的过程。

 

在阎宏的《JAVA与模式》 中是这么说的：

抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级机构。

 

“产品等级结构”这个词给人感觉很抽象。

1.什么是一个产品等级结构？

奥迪A6,奥迪A8,甚至加上宝马X6,可以看作是一个产品等级的，因为他们都是汽车。

红色的奥迪A6，黑色的奥迪A8，甚至加上宝马，也可以被看作是一个产品等级的，因为它们都是汽车。

图3：

 

 

上面每种汽车的发动机，奥迪A6的发动机，奥迪A8的发动机，（这里假设发动机的型号不同），也同样可以被看作是一个产品等级的，因为它们都是发动机。

图4：

 

2.什么是多个产品等级机构？

奥迪A6的发动机，奥迪A6的车门，奥迪A6的轮胎，这些是多个产品等级结构的，因为它们是不同类的产品。

也就是说发动机，车门，轮胎以及其他的汽车部件各自代表了一类产品，不存在继承和实现的关系，没有什么交集。

 

它们之间是一种平行关系，但是它们之间组合起来，就可以组成一个汽车（一个产品族）。

一个奥迪A6汽车就是一系列的奥迪A6的发动机、奥迪A6的车门、奥迪A6的轮胎等其他汽车零部件产品的组合。

 

图5：

  

 

抽象工厂模式的例子和Java实现：

 

顾客想购买一汽大众的汽车，汽车的发动机和车身，也要求是对应的型号。

A想购买奥迪A6，顾客A想购买奥迪A8。例子8:

 

汽车发动机(抽象产品)：

 

/*
 * 汽车发动机(抽象产品)
 */
public interface Engine {

}

 

奥迪A6的发动机（具体产品）：

 

/*
 * 奥迪A6的发动机（具体产品）
 */
public class AudiA6Engine implements Engine{
	
	public String toString(){
		return "奥迪A6发动机";
	}

}

 

奥迪A8的发动机（具体产品）：

 

/*
 * 奥迪A8的发动机（具体产品）
 */
public class AudiA8Engine implements Engine{
	
	public String toString(){
		return "奥迪A8发动机";
	}

}

 

 

汽车车身（抽象产品）：

 

/*
 * 汽车车身（抽象产品）
 */
public interface CarBody {

}

 

奥迪A6的车身（具体产品）： 

  

/*
 * 奥迪A6的车身（具体产品）
 */
public class AudiA6CarBody implements CarBody {
	
	public String toString(){
		return "奥迪A6车身";
	}

}

 

奥迪A8的车身（具体产品）：

 

/*
 * 奥迪A8的车身（具体产品）
 */
public class AudiA8CarBody implements CarBody {
	
	public String toString(){
		return "奥迪A8车身";
	}

}

 

 

一汽大众工厂（抽象工厂）：

 

/*
 * 一汽大众工厂（抽象工厂）
 */
public interface CarFactory {
	/*
	 * 生产汽车发动机的工厂方法（创建一种产品对象）
	 */
	public Engine createEngine();
	
	/*
	 * 生产汽车车身的工厂方法（创建另一种产品对象）
	 */
	public CarBody createCarBody();

}

 

奥迪A6工厂（具体工厂）：

 

/*
 * 奥迪A6工厂（具体工厂）
 */
public class AudiA6CarFactory implements CarFactory {

	/*
	 * 生产奥迪A6发动机的工厂方法（创建一种具体产品对象）
	 */
	public CarBody createCarBody() {
		return new AudiA6CarBody();
	}

	/*
	 * 生产奥迪A6车身的工厂方法（创建另一种具体产品对象）
	 */
	public Engine createEngine() {
		return new AudiA6Engine();
	}

}

 

奥迪A8工厂（具体工厂）：

 

/*
 * 奥迪A8工厂（具体工厂）
 */
public class AudiA8CarFactory implements CarFactory {
	
	/*
	 * 生产奥迪A6发动机的工厂方法（创建一种具体产品对象）
	 */
	public CarBody createCarBody() {
		return new AudiA8CarBody();
	}

	/*
	 * 生产奥迪A6车身的工厂方法（创建另一种具体产品对象）
	 */
	public Engine createEngine() {
		return new AudiA8Engine();
	}

}

 

汽车（客户端）：

汽车实际上就是一个产品族，即一套（一系列）汽车零部件产品（产品族）组合。

这里定义了一个Car类，只使用了抽象工厂（CarFactory）和抽象产品（Engine 、CarBody ），不涉及任何具体工厂（AudiA6CarFactory、AudiA8CarFactory）和具体产品（AudiA6Engine 、AudiA8Engine、AudiA6CarBody 、AudiA8CarBody ）。

 

/*
 * 汽车（客户端）
 * 通过生产发动机的工厂和生产车身的工厂，生产汽车发动机和汽车车身，
 * 最终，汽车由一套产品族（一套汽车零部件）组成。
 */
public class Car {
	
	private CarBody body;
	private Engine engine;
	
	public Car(CarFactory carFactory){
		this.body = carFactory.createCarBody();
		this.engine = carFactory.createEngine();
		
	}
	
	public String toString(){
		return "[" + this.body+"/" + this.engine + "]";
	}

}

 

客户端的调用（用于测试）：

在调用抽象工厂模式时，使用了客户端（Client）角色Car，因为Car类的构造函授的传入参数类型是抽象工厂。

这样，我们根据需要，只要传入一个期望的具体工厂对象（AudiA6CarFactory），就可以得到期望的产品族（adioA6Car）对象。

当想得到另一种产品族（adioA8Car）对象，只要传入另一个具体工厂对象（AudiA8CarFactory）就可以了。 

 

/*
 * 使用抽象工厂的客户端（用于测试）
 */
public class Customers {
	 
	public static void main(String[] args){
		
//		创建一个奥迪A6生产工厂（具体工厂对象）
		CarFactory adioA6CarFactory = new AudiA6CarFactory();
//		顾客A购买了奥迪A6（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））
		Car adioA6Car = new Car(adioA6CarFactory);
		System.out.println("顾客A买了一辆汽车" + adioA6Car);

//		创建一个奥迪A8生产工厂（具体工厂对象）
		CarFactory adioA8CarFactory = new AudiA8CarFactory();
//		顾客B购买了奥迪A8（具体工厂对象作为参数，将会被用来创建汽车对象（包含了一系列相关的汽车部件产品对象））
		Car adioA8Car = new Car(adioA8CarFactory);
		System.out.println("顾客B买了一辆汽车" + adioA8Car);		
		
	}

}

 

运行结果：

顾客A买了一辆汽车[奥迪A6车身/奥迪A6发动机]
顾客B买了一辆汽车[奥迪A8车身/奥迪A8发动机]

 

 

 本例子的结构图：

  

 

 

 

 

 

小小总结一下，通过比较工厂方法模式，了解抽象工厂模式的优点：

1. 通过用意比较，

使用抽象工厂模式的目的---为了创建一系列相关或相互依赖（几个或几类）对象；

而使用工厂方法模式的目的--为了创建（一个或一类）对象。

2.通过结构比较，

因为抽象工厂模式是为了创建多个有关联的产品对象，因此增加了一个客户端（Client）角色，用于整合创建出来的产品族。

同时，抽象工厂模式的工厂不是哪一种产品的工厂，它是多种产品的工厂。我想，这可能就是抽象工厂模式的工厂被成为“抽象”工厂的原因吧。也就是说，它的“抽象”是对多种产品的“抽象”。

 

 

在很多资料以及实际应用中，大多通过结合配置文件以及反射来充分体现抽象工厂模式的优势。

在下面的链接是一位博主使用.NET来讲解的抽象工厂模式，我觉得简单易懂，而且在实际应用中很有参考价值。

.NET设计模式（3）：抽象工厂模式（Abstract Factory）

 

评论

1 楼 weishuguangeye 2011-03-25  

写的非常好,总结的也非常好！感谢！