## 引入 每一个模式都是针对一定问题的解决方案。抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。 　　在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。 **产品等级结构**：产品的等级结构也就是产品的继承结构。例如一个为空调的抽象类，它有海尔空调、格力空调、美的空调等一系列的子类，那么这个抽象类空调和他的子类就构成了一个产品等级结构。 **产品族**：产品族是在抽象工厂模式中的。在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品。比如，海尔工厂生产海尔空调。海尔冰箱，那么海尔空调则位于空调产品族中。 如下图示例：  显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的。产品的等级结构与产品族将产品按照不同方向划分，形成一个二维的坐标系。横轴表示产品的等级结构，纵轴表示产品族，上图共有两个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。 　　上面所给出的三个不同的等级结构具有平行的结构。因此，如果采用工厂方法模式，就势必要使用三个独立的工厂等级结构来对付这三个产品等级结构。由于这三个产品等级结构的相似性，会导致三个平行的工厂等级结构。随着产品等级结构的数目的增加，工厂方法模式所给出的工厂等级结构的数目也会随之增加。  那么，是否可以使用同一个工厂等级结构来对付这些相同或者极为相似的产品等级结构呢？当然可以的，而且这就是抽象工厂模式的好处。同一个工厂等级结构负责三个不同产品等级结构中的产品对象的创建。  ## 基本定义 抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。 抽象工厂允许客户端使用抽象的接口来创建一组相关的产品，而不需要关系实际产出的具体产品是什么。这样一来，客户就可以从具体的产品中被解耦。 ## 模式结构 抽象工厂模式的UML结构图如下：  * AbstractFactory：抽象工厂。抽象工厂定义了一个接口，所有的具体工厂都必须实现此接口，这个接口包含了一组方法用来生产产品。 * ConcreteFactory：具体工厂。具体工厂是用于生产不同产品族。要创建一个产品，客户只需要使用其中一个工厂完全不需要实例化任何产品对象。 * AbstractProduct：抽象产品。这是一个产品家族，每一个具体工厂都能够生产一整组产品。 * Product：具体产品。 ## 代码实现 为了要保证每家加盟店都能够生产高质量的披萨，防止使用劣质的原料，我们打算建造一家生产原料的工厂，并将原料运送到各家加盟店。但是加盟店都位于不同的区域，比如纽约、芝加哥。纽约使用一组原料，芝加哥使用另一种原料。在这里我们可以这样理解，这些不同的区域组成了原料家族，每个区域实现了一个完整的原料家族。 首先创建一个原料工厂。该工厂为抽象工厂，负责创建所有的原料。 PizzaIngredientFactory.java public interface PizzaIngredientFactory { ~~~ /* * 在接口中，每个原料都有一个对应的方法创建该原料 */ public Dough createDough(); public Sauce createSauce(); public Cheese createCheese(); public Veggies[] createVeggies(); public Pepperoni createPepperoni(); public Clams createClams(); } ~~~ 纽约原料工厂：NYPizzaIngredientFactory.java。 ~~~ public class NYPizzaIngredientFactory implements PizzaIngredientFactory{ @Override public Cheese createCheese() { return new ReggianoCheese(); } @Override public Clams createClams() { return new FreshClams(); } @Override public Dough createDough() { return new ThinCrustDough(); } @Override public Pepperoni createPepperoni() { return new SlicedPepperoni(); } @Override public Sauce createSauce() { return new MarinaraSauce(); } @Override public Veggies[] createVeggies() { Veggies veggies[] = {new Garlic(),new Onion(),new Mushroom(),new RefPepper()}; return veggies; } } ~~~ 重新返回到披萨。在这个披萨类里面，我们需要使用原料，其他方法保持不变，将prepare()方法声明为抽象，在这个方法中，我们需要收集披萨所需要的原料。 Pizza.java ~~~ public abstract class Pizza { /* * 每个披萨都持有一组在准备时会用到的原料 */ String name; Dough dough; Sauce sauce; Veggies veggies[]; Cheese cheese; Pepperoni pepperoni; Clams clams; /* * prepare()方法声明为抽象方法。在这个方法中，我们需要收集披萨所需要的原料，而这些原料都是来自原料工厂 */ abstract void prepare(); void bake(){ System.out.println("Bake for 25 munites at 350"); } void cut(){ System.out.println("Cutting the pizza into diagonal slices"); } void box(){ System.out.println("Place pizza in official PizzaStore box"); } public String getName() { return name; } public void setName(String name) { this.name = name; } } ~~~ CheesePizza.java ~~~ public class CheesePizza extends Pizza{ PizzaIngredientFactory ingredientFactory; /* * 要制作披萨必须要有制作披萨的原料，而这些原料是从原料工厂运来的 */ public CheesePizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory = ingredientFactory; prepare(); } /** * 实现prepare方法 * prepare 方法一步一步地创建芝士比萨，每当需要原料时，就跟工厂要 */ void prepare() { System.out.println("Prepareing " + name); dough = ingredientFactory.createDough(); sauce = ingredientFactory.createSauce(); cheese = ingredientFactory.createCheese(); } } ~~~ Pizza的代码利用相关的工厂生产原料。所生产的原料依赖所使用的工厂，Pizza类根本不关心这些原料，它只需要知道如何制作披萨即可。这里，Pizza和区域原料之间被解耦。 ClamPizza.java ~~~ public class ClamPizza extends Pizza{ PizzaIngredientFactory ingredientFactory; public ClamPizza(PizzaIngredientFactory ingredientFactory){ this.ingredientFactory = ingredientFactory; } @Override void prepare() { System.out.println("Prepare " + name); dough = ingredientFactory.createDough(); sauce = ingredientFactory.createSauce(); cheese = ingredientFactory.createCheese(); clams = ingredientFactory.createClams(); } } ~~~ 做完披萨后，需要关注披萨店了。 在披萨店中，我们依然需要关注原料，当地的披萨店需要和本地的原料工厂关联起来。 PizzaStore.java ~~~ public abstract class PizzaStore { public Pizza orderPizza(String type){ Pizza pizza; pizza = createPizza(type); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); return pizza; } /* * 创建pizza的方法交给子类去实现 */ abstract Pizza createPizza(String type); } ~~~ 纽约的披萨店：NYPizzaStore.java ~~~ public class NYPizzaStore extends PizzaStore{ @Override Pizza createPizza(String type) { Pizza pizza = null; //使用纽约的原料工厂 PizzaIngredientFactory ingredientFactory = new NYPizzaIngredientFactory(); if("cheese".equals(type)){ pizza = new CheesePizza(ingredientFactory); pizza.setName("New York Style Cheese Pizza"); } else if("veggie".equals(type)){ pizza = new VeggiePizza(ingredientFactory); pizza.setName("New York Style Veggie Pizza"); } else if("clam".equals(type)){ pizza = new ClamPizza(ingredientFactory); pizza.setName("New York Style Clam Pizza"); } else if("pepperoni".equals(type)){ pizza = new PepperoniPizza(ingredientFactory); pizza.setName("New York Style Pepperoni Pizza"); } return pizza; } } ~~~ 其中PizzaIngredientFactory是抽象的披萨原料工厂接口，它定义了如何生产一个相关产品的家族。这个家族包含了所有制作披萨的原料。 NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory是两个具体披萨工厂类，他们负责生产相应的披萨原料。 NYPizzaStore是抽象工厂的客户端。 ## 优点 * 1、分离接口和实现，抽象工厂隔离了具体类的生成，使得客户端不需要知道什么被创建。所有的具体工厂都实现了抽象工厂中定义的公共接口，因此只需要改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。 * 2、 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。 ## 缺点 * 不太容易扩展新的产品 添加新的行为时比较麻烦。如果需要添加一个新产品族对象时，需要更改接口及其下所有子类，这必然会带来很大的麻烦。 ## 使用场景 * 1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。 * 2.系统中有多于一个的产品族，而每次只使用其中某一产品族。 * 3. 属于同一个产品族的产品将在一起使用，这一约束必须在系统的设计中体现出来。 * 4. 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。 ## 起源 抽象工厂模式的起源或者最早的应用，是用于创建分属于不同操作系统的视窗构建。比如：命令按键（Button）与文字框（Text)都是视窗构建，在UNIX操作系统的视窗环境和Windows操作系统的视窗环境中，这两个构建有不同的本地实现，它们的细节有所不同。 　　在每一个操作系统中，都有一个视窗构建组成的构建家族。在这里就是Button和Text组成的产品族。而每一个视窗构件都构成自己的等级结构，由一个抽象角色给出抽象的功能描述，而由具体子类给出不同操作系统下的具体实现。  可以发现在上面的产品类图中，有两个产品的等级结构，分别是Button等级结构和Text等级结构。同时有两个产品族，也就是UNIX产品族和Windows产品族。UNIX产品族由UNIX Button和UNIX Text产品构成；而Windows产品族由Windows Button和Windows Text产品构成。  　系统对产品对象的创建需求由一个工程的等级结构满足，其中有两个具体工程角色，即UnixFactory和WindowsFactory。UnixFactory对象负责创建Unix产品族中的产品，而WindowsFactory对象负责创建Windows产品族中的产品。这就是抽象工厂模式的应用，抽象工厂模式的解决方案如下图：  显然，一个系统只能够在某一个操作系统的视窗环境下运行，而不能同时在不同的操作系统上运行。所以，系统实际上只能消费属于同一个产品族的产品。 　　在现代的应用中，抽象工厂模式的使用范围已经大大扩大了，不再要求系统只能消费某一个产品族了。因此，可以不必理会前面所提到的原始用意。