设计模式之工厂设计模式（二）

     接到上篇文章中的工厂设计模式思想，我们的Cookies店这时又有了新的调整：有些加盟店使用了低价的原料，所以呢总店做出了决定，决定采取一些手段，避免这样下去毁了自己的招牌，为了确保原料一致，总店决定建造一家原料工厂，为各个加盟店提供原料：

所以，为了能够给各个加盟店送出合适的原料需要了解一下，各种Cookies的加工所使用的原料，所以呢，我们需要建立一个工厂，负责创建原料中的每一种原料，工厂需要制造这些原料。首先呢，仿照上一节的思想呢，建立一个工厂原料的接口：

public interface CookiesIngredientFactory{
	public Dough createDough();
	public Sauce createSauce();
	public Cheese createCheese();
	public Pepperoni createPepperoni();
	
}

这个接口定义了每一种原料的对应的实现方法，但是呢也产生了很多的新类，每个原料都是一个类，如果每个工厂实力内部都有一种通用的机制可以实现，那么我们可以把这个接口改变成为一个抽象类；所以我们可以进行以下的操作：为每一个区域创建一个工厂继承上述的接口，然后由子类实现每一个原料的创建方法。

下面是北京店的工厂类的实现：

public class BeijingCookiesIngredientFactory implements CookiesIngredientFactory{
	public Dough createDough(){
		return new ThinCrustDough();
	}
	public Sauce createSauce(){
		return new MarinnaraSauce();
	}
	public Pepperoni createPepperoni(){
		return new SlicedPepperoni();
	}
}

按照同样的方式也可以实现南京店的Cookies的原料的制作。到现在为止，我们可以保证了使用的原料的质量，然后我们开始使用这个工厂制造出来的原料进行生产Cookies，所以呢为了将原料使用添加到制作过程中，我们开始修改Cookies超类：

public abstract class Cookies{
	String name;
	Dough dough;
	Sauce sauce;
	Pepperoni pepperoni;
	
	abstract void prepare();
	
	void bake(){
		System.out.println("Bake for 25 minutes at 350");
	}
	void cut(){
		System.out.println("Cutting the Cookies into diagonal slices");
	}
	void box(){
		System.out.println("Place Cookies in offical CookiesStore box");
	}
	void setName(String name){
		this.name=name;
	}
	String getName(){
		return name;
	}
	pulbic String toString(){
		//这里是打印Cookies的代码部分，不再详细写出来
	}
}

所以当我们制作不同的Cookies的时候就只能从工厂取得原料了：

public class CheeseCookies extends Cookies{
	CookiesIngredientFactory ingredientFactory;
	
	public CheeseCookeis(CookiesIngredientFactory ingredientFactory){
		this.ingredientFactory=ingredientFactory;
	}
	
	void prepare(){
		System.out.println("preparing"+name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}
}

之后呢，我们需要修改XxxCookiesStore类中的createCookies()方法，这个方法适用于创建不同的Cookies的，所以在原有的工厂方法的基础上做出如下修改：

以北京店为例：

public class BeijingCookiesStore extends CookiesStore{
	protected Cookies createCookies(String item){
		Cookies cookies = null;
		CookiesIngridentFactory ingredientFactory = new BeijingIngredientFactory();
		
		if("cheese".equals(item)){
			Cookies = new CheeseCookies(ingredientFactory);
			cookies.setName("Beijing Cheese Cookies");
		}
		if("greek".equals(item)){
			Cookies = new GreekCookies(ingredientFactory);
			cookies.setName("Beijing Greek Cookies");
		}
		if("pepperoni".equals(item)){
			Cookies = new PepperoniCookies(ingredientFactory);
			cookies.setName("Beijing Pepperoni Cookies");
		}
		return cookies;
	}
}

红色标注部分发生了变化，增加了一个参数，使用IngredientFactorty的一个实例化对象作为不同种类Cookies创建时的一个重要的参数；这样就能够实现使用不同的原料创建不同的Cookies；

让我们来捋顺一下：

首先，我们需要一个北京店：

BeijingCookiesStore beijingCookiesStore = new BeijingCookiesStore();

然后呢，我们开始下订单：

beijingCookiesStore.orderCookies("cheese");

进入orderCookies()方法后，首先调用createCookies(“cheese”)方法：

Cookies cookies = createCookies("cheese");

然后，当上面的方法被调用时也就开始涉及到原料的使用了：

Cookies cookies = new CheeseCookies(beijingIngredientFactory);

接下来开始执行prepare方法类：

	void prepare(){
		System.out.println("preparing"+name);
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		cheese = ingredientFactory.createCheese();
	}

随后再次执行剩下的步骤，烘烤，切片等操作。从这个过程可以看出，抽象工厂是提供了一个接口用于创建相关或者是依赖对象的家族，而不需要明确制定具体类。然而大多数情况下，抽象工厂的具体实现通常会使用工厂方法来实现创建，不过不好的事，如果需要扩展某一相关的类别，抽象工厂则需要改变接口，这意味着繁重的工作，也就是说必须深入的改变每一个自类的接口。最后展现这个例子的抽象工厂的类图，与工厂方法的类图像比较是有很大不同的：