大话设计模式十五：抽象工厂模式（abstract factory）

一. 定义：

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

其实它和工厂方法很像，工厂方法是一个，而抽象工厂是一系列。

二. 结构和说明：

AbstractFactory:抽象工厂，定义创建一系列产品对象的操作接口。

ConcreteFactory:具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建。

AbstractProduct：定义一类产品对象的接口。

ConcreteProduct：具体的产品实现对象，通常在具体工厂里面，或选择具体的产品实现对象，来创建负荷抽象工厂定义的方法返回的产品类型的对象。

Client：客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象的接口编程，以实现需要的功能。

1. AbstractFactory:

/**
 * 抽象工厂的接口，声明创建抽象产品对象的操作
 */
public interface AbstractFactory {
	/**
	 * 示例方法，创建抽象产品A的对象
	 * @return 抽象产品A的对象
	 */
	public AbstractProductA createProductA();

	/**
	 * 示例方法，创建抽象产品B的对象
	 * @return 抽象产品B的对象
	 */
	public AbstractProductB createProductB();
}

2. ConcreteFactory1:

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreteFactory1 implements AbstractFactory {
	public AbstractProductA createProductA() {
		return new ProductA1();
	}
	public AbstractProductB createProductB() {
		return new ProductB1();
	}
}

3. ConcreteFactory2:

/**
 * 具体的工厂实现对象，实现创建具体的产品对象的操作
 */
public class ConcreteFactory2 implements AbstractFactory {
	public AbstractProductA createProductA() {
		return new ProductA2();
	}
	public AbstractProductB createProductB() {
		return new ProductB2();
	}
}

4. AbstractProductA:

/**
 * 抽象产品A的接口
 */
public interface AbstractProductA {
	//定义抽象产品A相关的操作
}

5. AbstractProductB:

/**
 * 抽象产品B的接口
 */
public interface AbstractProductB {
	//定义抽象产品B相关的操作
}

6. ProductA1:

/**
 * 产品A的具体实现
 */
public class ProductA1 implements AbstractProductA {
	//实现产品A的接口中定义的操作
}

7. ProductA2:

/**
 * 产品A的具体实现
 */
public class ProductA2 implements AbstractProductA {
	//实现产品A的接口中定义的操作
}

8. ProductB1:

/**
 * 产品B的具体实现
 */
public class ProductB1 implements AbstractProductB {
	//实现产品B的接口中定义的操作
}

9. ProductB2:

/**
 * 产品B的具体实现
 */
public class ProductB2 implements AbstractProductB {
	//实现产品B的接口中定义的操作
}

三. 实例：

假设现在我们现在需要用java实现一个给页面换皮肤的功能，即红色的按钮需要搭配红色的输入框；绿色的按钮需要搭配绿色的输入框。

我们用抽象工厂模式来设计：那么红色按钮和红色输入框就是一个产品族了。

不使用模式的解决方案：

1. 定义按钮工厂

public class ButtonFactory {
	public static Button createButton(int type) {
		if(type == 1){
			return new GreenButton();
		}else if(type == 2){
			return new RedButton();
		}
		return null;
	}
}

2. 定义输入框工厂：

public class TextFieldFactory {
	public static TextField createTextField(int type) {
		if(type == 1){
			return new GreenTextField();
		}else if(type == 2){
			return new RedTextField();
		}
		return null;
	}
}

3. 按钮接口：

//按钮接口
public interface Button {
	public void display();
}

4. 红色按钮实现：

//红色按钮类：具体产品
public class RedButton implements Button {
	public void display() {
		System.out.println("显示红色按钮");
	}
}

5. 绿色按钮实现：

//绿色按钮类：具体产品
public class GreenButton implements Button {
	public void display() {
		System.out.println("显示绿色按钮。");
	}	
}

6. 输入框接口：

//文本框接口：抽象产品
public interface TextField {
	public void display();
}

7. 红色输入框实现：

//红色文本框类：具体产品
public class RedTextField implements TextField {
	public void display() {
		System.out.println("显示红色文本框");
	}
}

8. 绿色输入框实现：

//绿色文本框类：具体产品
public class GreenTextField implements TextField {
	public void display() {
		System.out.println("显示绿色文本框。");
	}	
}

9. 测试类：

public class Client {
	public static void main(String args[]) {
		Button button = ButtonFactory.createButton(1);
		TextField textField = TextFieldFactory.createTextField(1);
		button.display();
		textField.display();
	}
}

虽然也能实现业务，但是这个代码有个问题，它需要调用者在传参的时候要小心，如果第一个参数是1，第二个参数是2，那就错了。

而且还有个问题就是不好拓展，如果我再加一种蓝色皮肤，那可就要改ButtonFactory和TextFieldFactory了，很不方便

使用模式的解决方案1：

1. 定义皮肤抽象工厂：

//皮肤工厂接口：抽象工厂
public interface SkinFactory {
	public Button createButton();
	public TextField createTextField();
}

2. 红色皮肤工厂：

//红色皮肤工厂：具体工厂
public class RedSkinFactory implements SkinFactory {
	public Button createButton() {
		return new RedButton();
	}

	public TextField createTextField() {
		return new RedTextField();
	}
}

3. 绿色皮肤工厂：

//绿色皮肤工厂：具体工厂
public class GreenSkinFactory implements SkinFactory {
	public Button createButton() {
		return new GreenButton();
	}

	public TextField createTextField() {
		return new GreenTextField();
	}
}

4. 读取并解析配置文件类：

public class XMLUtil {
	// 该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
	public static Object getBean() {
		try {
			// 创建文档对象
			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = factory.newDocumentBuilder(); 
			Document doc = builder.parse(new File("config.xml"));

			// 获取包含类名的文本节点
			NodeList list = doc.getElementsByTagName("className");
			Node classNode = list.item(0).getFirstChild(); 
			String cName = classNode.getNodeValue();

			// 通过类名生成实例对象并将其返回
			Class c = Class.forName(cName);
			Object obj = c.newInstance(); 
			return obj;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
}

5. config.xml

<?xml version="1.0"?>
<config>
	<className>com.zdp.abstractfactory.RedSkinFactory</className>
</config>

6. 客户端：

public class Client {
	public static void main(String args[]) {
		// 使用抽象层定义
		SkinFactory factory = (SkinFactory) XMLUtil.getBean();
		Button button = factory.createButton();
		TextField textField = factory.createTextField();
		button.display();
		textField.display();
	}
}

抽象工厂定义了一个产品族，如果想切换产品族(比如换成“绿色风格”，只需要改下配置文件就好了)。

而且也很好拓展，例如加一种“蓝色”风格的皮肤，只需要新增BlueSkinFactory实现SkinFactory，BlueButton实现Button，BlueTextField实现TextField。

使用模式的解决方案2：

方案1其实有个不太好的地方，如果在产品族中要添加一种新产品，比如下拉框，那么我就要修改SkinFactory这个接口了，一般情况下，接口是不能轻易修改的，因为它是一种规范，一个契约。因为接口一改，所有的实现都要改。

下面我们使用一种相对灵活，但是不太安全(需要强转)的方法来解决：在抽象工厂中只定义一个方法，给这个方法设置一个参数，通过这个参数来判断具体创建什么产品对象。

1. SkinFactory：

//皮肤工厂接口：抽象工厂
public interface SkinFactory {
	public Object createComponent(Component component);
}

2. RedSkinFactory：

public class RedSkinFactory implements SkinFactory {
	@Override
	public Object createComponent(Component component) {
		switch (component) {
			case BUTTON:
				return new RedButton();
			case TEXT_FIELD:
				return new RedTextField();
		}
		return null;
	}
}

3. GreenSkinFactory：

public class GreenSkinFactory implements SkinFactory {
	@Override
	public Object createComponent(Component component) {
		switch(component){
			case BUTTON:
				return new GreenButton();
			case TEXT_FIELD:
				return new GreenTextField();
		}
		return null;
	}
}

4. 枚举类：

public enum Component {
	BUTTON, TEXT_FIELD;
}

5. 测试类：

public class Client {
	public static void main(String args[]) {		
		SkinFactory factory = new RedSkinFactory();
		Button button = (Button)factory.createComponent(Component.BUTTON);
		TextField textField = (TextField)factory.createComponent(Component.TEXT_FIELD);
		button.display();
		textField.display();
	}
}

现在如果要加入一个下拉框的话，我们只需要修改SkinFactory的实现：RedSkinFactory和GreenSkinFactory就可以了，而无需动接口。

四. 优缺点：

1. 分离接口和实现

2. 切换产品族变得容易

3. 不太容易扩展新的产品

如果一个系统要需要动态的切换产品族的时候需要用抽象工厂模式

如果要强调一系列相关产品的接口，以便联合使用它们的时候用抽象工厂模式。