工厂模式

[size=medium]本文章内容是看完《HeadFirst设计模式》书籍的工厂模式后为了加深印象而写。其实有的时候，某些博客并不是仅仅为了分享，更主要的是写给自己，主要是为了自己在写的过程去更加深刻去体会，光看看别人所说的，感觉挺有道理的，却没有转化成自己的东西，就更不会在实际的工作中去使用设计模式了。

言归正传，工厂模式分成3种，简单工厂模式、工厂方法模式、抽象工厂模式。这些模式都是通过接口和抽象进行解耦。

简单工厂模式：（为了偷懒，我也不会独自去想一个实际的场景，将那本书所用场景复述下来,纯手打）
订购一个披萨现状如下：[/size]

public Pizza orderPizza(String type){
		Pizza pizza;
		if(type==null || type.equals("cheese")){
			pizza=new CheesePizza();
		}else if(type.equals("greek")){
			pizza=new GreekPizza();
		}else{
			pizza=new PepperoniPizza();
		}

		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();

		return pizza;
	}

[size=medium]这个过程完成了太多的职责，披萨的生产过程、装配过程。一旦有新的披萨类型加进来就要修改这个函数。简单工厂模式就是把生产披萨的过程独立出去，使得职责划分的更加细致，更好的复用。所以建一个工厂类SimplePizzaFactory单独负责创建各种披萨，改变如下：[/size]

public class SimplePizzaFactory {

	public Pizza createPizza(String type){
		Pizza pizza;
		if(type==null || type.equals("cheese")){
			pizza=new CheesePizza();
		}else if(type.equals("greek")){
			pizza=new GreekPizza();
		}else{
			pizza=new PepperoniPizza();
		}
		return pizza;
	}
}

[size=medium]再回到订购披萨的函数中：[/size]

public static Pizza orderPizza(String type){
		SimplePizzaFactory factory=new SimplePizzaFactory();
		Pizza pizza=factory.createPizza("cheese");

		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();

		return pizza;
	}

[size=medium]我们使用了SimplePizzaFactory 来创建披萨，任何地方都可以使用SimplePizzaFactory 来创建披萨，达到复用的效果，同时要新增一个披萨类型时，只需在SimplePizzaFactory 里修改即可。这就是简单工厂模式。看完后，可能你会不屑一顾，没什么特别之处吗？我没看到多大的优点，整体来说不就是把一段代码封装起来达到复用效果吗。我也感觉是这样

工厂方法模式：
上述的简单工厂模式的缺点也很明显，简单工厂模式就是一个大杂烩，把所有的披萨的创建全依靠if else判断来进行，一旦新增一个新的披萨类型，就要去改动if else判断。工厂方法模式就是对这种缺点的改进：
PizzaStore是一个抽象的披萨商店，负责为客户订购披萨，如下：[/size]

public abstract class PizzaStore {

	public Pizza orderPizza(){
		Pizza pizza=createPizza();

		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.bake();

		return pizza;
	}

	protected abstract Pizza createPizza();
}

[size=medium]PizzaStore 根据客户传进来type类型，由它的子类来具体实现这一创建过程，PizzaStore 这一抽象类仅仅对披萨的prepare、bake、cut、bake等装配流程（相同的部分）进行封装。
protected abstract Pizza createPizza()方法就是工厂方法。新增一个披萨类型，只需继承PizzaStore实现抽象方法createPizza方法即可，不再关心披萨的装配流程。[/size]

public class CheesePizzaFactory extends PizzaStore{

	@Override
	protected Pizza createPizza() {
		return new CheesePizza();
	}

}
public class GreekPizzaFactory extends PizzaStore{

	@Override
	protected Pizza createPizza() {
		return new GreekPizza();
	}

}

[size=medium]此时实现订购的代码即为：[/size]

public static Pizza orderPizzaFactory(String type){
		PizzaStore pizzaStore=new CheesePizzaFactory();
		return pizzaStore.orderPizza();
	}

[size=medium]首先创建一个相应的披萨工厂，然后直接调用工厂的orderPizza即可获取对应的披萨。
这样的做法的确改变了简单工厂模式的大杂烩模式，新增一个披萨类，并不需要去改动以前的任何代码，只需创建一个对应的工厂，继承抽象的披萨工厂PizzaStore。然而这样也存在着一个缺点，每当新增一个新的披萨类型时，就需要新增一个对应的披萨工厂（也可以在已有的工厂中进行if else判断，但这样又会沦落为一个大杂烩），新增一个披萨类型，就要写披萨类和对应的工厂类，有人说不要工厂了，直接new一个披萨。这就说到了工厂和new的区别，其实工厂创建对象也是通过new来创建的，然而它的功能是对new出来的对象进行控制，控制对象的某些参数等等（我们的例子比较简单，工厂没有进行相应的控制）。

抽象工厂模式：
这种模式其实是另一种的使用场景即多件东西组合来合成一件东西。即工厂方法模式是用于生产一件产品，而抽象工厂模式则更适用于多件产品来组合。
如披萨的产生有多种原料来生成，所以构建这样一个抽象的原料工厂，披萨原料抽象工厂如下:[/size]

public interface PizzaSourceFactory {

	public Salt getSalt();

	public Sugar getSugar();

	public Flour getFlour();
}

[size=medium]Salt、Sugar、Flour都是接口，都有不同的实现类。
上面仅仅是一个抽象的原料工厂，下面就需要实现这个工厂,北京披萨原料工厂，BeijingPizzaSourceFactory 如下：[/size]

public class BeijingPizzaSourceFactory implements PizzaSourceFactory{

	@Override
	public Salt getSalt() {
		return new BeijingSalt();
	}

	@Override
	public Sugar getSugar() {
		return new BeijingSugar();
	}

	@Override
	public Flour getFlour() {
		return new BeijingFlour();
	}

}

[size=medium]北京披萨原料工厂都是生产的北京的盐、北京的糖、北京的面。同理上海的披萨原料工厂都生产上海的盐、上海的糖、上海的面。
有了披萨的原料工厂，来看看如何制作披萨：[/size]

public abstract class NewPizza {

	private Salt salt;

	private Sugar sugar;

	private Flour flour;

	protected abstract void prepare();

	public void bake(){
		System.out.println("bake pizza");
	}

	public void cut(){
		System.out.println("cut pizza");
	}

	public void box(){
		System.out.println("box pizza");
	}
}

[size=medium]这是一个抽象类，留出prepare()方法要求子类来实现，子类就需要通过原料工厂来实现：[/size]

public class BeijingPizza extends NewPizza{

	private PizzaSourceFactory pizzaSourceFactory;

	public BeijingPizza(PizzaSourceFactory pizzaSourceFactory) {
		super();
		this.pizzaSourceFactory = pizzaSourceFactory;
	}

	@Override
	protected void prepare() {
		salt=pizzaSourceFactory.getSalt();
		sugar=pizzaSourceFactory.getSugar();
		flour=pizzaSourceFactory.getFlour();
	}

}

[size=medium]BeijingPizza 需要接收一个原料工厂，在prepare()方法中不断的向原料工厂来获取原料，这些都是针对接口不是针对实现，披萨与原料之间实现解耦。
不同的披萨可以由不同的原料工厂来为它提供原料。
原料工厂提供原料的大致类图如下：[/size]

[img]http://dl2.iteye.com/upload/attachment/0103/1597/80104c1b-1b20-3946-bba8-ffc76f154f73.png[/img]

[size=medium]下面说说工厂方法和抽象工厂的区别：
1 抽象工厂内部的方法其实都是工厂方法，即工厂方法用于生产一个产品，而抽象工厂则用于生产一组产品。
2 工厂方法更多的用于继承基础类，抽象工厂则更多用于提供各种原料来组合创建一个产品。

若想转载请注明出处： [url]http://lgbolgger.iteye.com/blog/2155213[/url]
作者：iteye的乒乓狂魔
[/size]