浅谈抽象工厂模式(Abstract Factory Pattern)

抽象工厂模式

之前我们了解了简单工厂模式和工厂方法模式，那么在工厂模式族中还有一个抽象工厂模式(Abstract Factory Pattern)。

抽象工厂模式的介绍

抽象工厂模式是一种比较常用的模式，定义如下：

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

抽象工厂模式常用来解决一系列具有相关约束的产品族生成的问题，和工厂方法模式的相比，抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方法。

模式组成

抽象工厂模式的通用类图如下：

下面的类图是抽象工厂模式的通用源码类图：

角色	关系	作用
AbstractProductA(抽象产品类)	具体产品族A的父类	描述产品族A的公共接口
AbstractProductB(抽象产品类)	具体产品族B的父类	描述产品族B的公共接口
ProductA1(具体产品)	抽象产品A的子类	描述具体生产的产品
ProductA2(具体产品)	抽象产品A的子类	描述具体生产的产品
ProductB1(具体产品)	抽象产品B的子类	描述具体生产的产品
ProductB2(具体产品)	抽象产品B的子类	描述具体生产的产品
AbstractCreator(抽象工厂类)	具体工厂的父类	描述具体工厂的公共接口
Creator(具体工厂类)	具体工厂	描述具体工厂

表述代码

首先我们需要声明抽象产品类族（A和B）

public abstract class AbstractProductA {

	//每个产品共有的方法
	public void shareMethod() {
		
	}
	//每个产品相同的方法，不同实现
	public abstract void doSomething();
}

public abstract class AbstractProductB {
	//每个产品共有的方法
	public void shareMethod() {
		
	}
	//每个产品相同的方法，不同实现
	public abstract void doSomething();
}

在每一个抽象产品类族中，都有不同的产品等级分类，对于产品等级，我们实现相关的具体产品类

public class ProductA1 extends AbstractProductA {

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("产品A1的实习方法");
		
	}
}

public class ProductA2 extends AbstractProductA {

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("产品A2的实现方法");
		
	}

}

public class ProductB1 extends AbstractProductB {

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("产品B1的实现方法");
		
	}
}

public class ProductB2 extends AbstractProductB {

	@Override
	public void doSomething() {
		// TODO Auto-generated method stub
		System.out.println("产品B2的生产方法");
		
	}
}

声明抽象工厂类：

/**
 * 抽象工厂类
 * @author lishanlei
 *
 */
public abstract class AbstractCreator {

	//创建A产品家族
	public abstract AbstractProductA createProductA();
	
	//创建B产品家族
	public abstract AbstractProductB createProductB();
}

对于每个产品等级，实现一个具体的工厂类：
产品等级1的实现类

/**
 * 产品等级1的实现类
 * @author lishanlei
 *
 */
public class Creator1 extends AbstractCreator {

	//只生产产品等级为1的A产品
	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA1();
	}
	//只生产产品等级为1的B产品
	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB1();
	}

}

产品等级2的实现类:

/**
 * 产品等级为2的实现类
 * @author lishanlei
 *
 */
public class Creator2 extends AbstractCreator {

	//只生产产品等级为2的A产品
	@Override
	public AbstractProductA createProductA() {
		// TODO Auto-generated method stub
		return new ProductA2();
	}

	//只生产产品等级为2的B产品
	@Override
	public AbstractProductB createProductB() {
		// TODO Auto-generated method stub
		return new ProductB2();
	}

}

最后是我们的业务类：

public class Client {

	public static void main(String[] args) {
		
		//定义两个工厂
		AbstractCreator creator1 = new Creator1();
		AbstractCreator creator2 = new Creator2();
		
		//产生A1对象
		AbstractProductA a1 = creator1.createProductA();
		
		//产生A2对象
		AbstractProductA a2 = creator2.createProductA();
		
		//产生B1对象
		AbstractProductB b1 = creator1.createProductB();
		
		//产生B2对象
		AbstractProductB b2 = creator2.createProductB();
		
	}
}

注意事项

• 有N个产品族，在抽象工厂类中就应该有N个创建方法
• 有M个产品等级就应该有M个实现工厂类，在每个实现工厂类中，实现不同产品族的生产任务

抽象工厂模式的优点

• 封装性，每个产品的实现类不是高层模块要关心的
• 产品族内的约束为非公开状态，具体的产品族内的约束是在工厂内实现的

抽象工厂模式的缺点

• 产品族的扩展非常困难（注意：不是产品等级扩展困难）

使用场景

• 一个对象族都有相同的约束，则可以使用抽象工厂模式