设计模式-工厂模式

一、概述

回顾：MySQL存储引擎，如何建立个人博客

个人博客：后台建站，适合java程序员

什么是工厂模式？

工厂模式（Factory Pattern）是最常见的一种设计模式之一。它主要是提供一种创建对象的最佳方法！

为什么要学习工厂模式？

与通过new来创建对象不同，使用工厂模式创建对象不会对客户端暴露创建逻辑，并且是通过统一个共同的接口指向新创建的对象。同事工厂模式能将创建对象的代码集中在一个对象或者方法中，可以避免代码中的重复，并且更方便维护。面向接口编程，这样的代码更具有弹性，可以应对未来的扩展。

二、认识工厂模式

案例：假设你有一个Pizza店，每天要做出不同口味的Pizza。

假设我们有两种口味Pizza

/*
 * 抽象的Pizza类，Pizza制作一般包括准备，烘烤，切块，包装。
 */
public abstract class Pizza{
	 // Pizza名称
	 protected String name;
	 // 面团类型
	 protected String dough;
	 // 酱料
	 protected String sauce;
	 // 芝士
	 protected String cheese;
	 // 蛤蜊
	 protected String clam;
	 // 佐料
	 protected List toppings = new ArrayList();
	
	// 准备
	public  void prepare() {
		System.out.print("准备食材，添加调料:");
		for (int i = 0; i < toppings.size(); i++) {
			System.out.print(toppings.get(i)+" ");
		}
	};
	// 烘烤
	public  void bake() {
		System.out.println("烘烤20分钟...");
	};
	// 切块
	public void cut() {
		System.out.println("切成x块...");
	};
	// 包装
	public void box() {
		System.out.println("包装...");
	}
 	// setter 和 getter方法省略
}

芝加哥风味的芝士Pizza

public class ChicagoStyleCheesePizza extends Pizza{

	public ChicagoStyleCheesePizza() {

		name = "Chicago Style Deep Dish Cheese Pizza";

		dough = "Extra Thick Crust Dough";

		sauce = "Plum Tomato Sauce";

		toppings.add("Shredded Mozzarella Cheese");

	}	
	public void cut() {
		System.out.println("Cut the pizza into square slices");
	}
}

纽约风味的蔬菜Pizza

public class NyStyleVeggiePizza extends Pizza{
	public NyStyleVeggiePizza() {
		name = "NY style Sauce and Veggie Pizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		toppings.add("Grated Reggiano Veggie");
	}
}

纽约风味的芝士Pizza

public class NyStyleCheesePizza extends Pizza{
	public NyStyleCheesePizza() {
		name = "NY style Sauce and Cheese Pizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		toppings.add("Grated Reggiano Cheese");
	}
}

通过new创建对象

// 创建一个纽约风味的芝士Pizza
NyStyleCheesePizza nyPizza = new NyStyleCheesePizza（）;

当使用new得到一个对象时，确实得到了一个具体类，是针对具体类实现，而不是接口。代码绑定具体类会导致代码脆弱，更缺乏弹性。

简单工厂

public class SimplePizzaFactory {
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		if (type.equals("NyStyleCheesePizza")) {
			return new NyStyleChieesePizza();
		} else if(type.endsWith("ChicagoStyleCheesePizza")) {
			return new ChicagoStyleCheesePizza();
		}else {
			return null;
		}
	}
}

// 创建简单工厂对象
SimplePizzaFactory pizzaFactory = new SimplePizzaFactory();
// 创建Pizza对象
NyStyleChieesePizza myPizza = pizzaFactory.createPizza("NYStyleChieesePizza");

简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。

这种简单工厂的写法是通过if else来判断对象创建过程的。简单工厂只是把new对象的问题转移到另一个类中在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。

工厂方法模式

定义：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

// 抽象的Pizza工厂
public abstract class PizzaFactory {
	public Pizza getPizza(String type) {
		Pizza pizza;
		pizza = createPizza(type);
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		
		return pizza;
	}
	protected abstract Pizza createPizza(String pizza);
}

// 纽约Pizza工厂（芝加哥pizza工厂跟这个类似）
public class NYPizzaFactory extends PizzaFactory {

	protected Pizza createPizza(String type) {
		if (type.equals("NyStyleChieesePizza")) {
			return new NyStyleCheesePizza();
		} else if (type.equals("NyStyleVeggiePizza")) {
			return new NyStyleVeggiePizza();
		}else {
			return null;
		}
	}
}

通过工厂方法创建对象

PizzaFactory pizzaFactory = new NYPizzaFactory();
// 创建一个蔬菜披萨
Pizza pizza = pizzaFactory.createPizza("NyStyleVeggiePizza");

当使用工厂方法创建对象时，是在编写具体工厂类时决定创建的对象时哪一个，选择使用哪个工厂类，自然就决定了十几创建的是哪个对象。尽管只有一个具体工厂，工厂方法还是非常有用的！因为它将对象从“实现”从“使用”中解耦，如果增加对象或者改变对象，工厂是不会受到影响的！

抽象工厂模式

定义：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

抽象原料工厂

// 为了简化， 这里的原料用字符串表示，其实每个原料应该用一个类表示
public interface PizzaIngredientFactory {
	public String createDough();
	public String createSauce();
	public String createChieese();
	public String[] createVeggies();
	public String createPepperoni();
}

芝士pizza原料工厂

public class CheesePizzaIngredientFactory implements PizzaIngredientFactory {

	public String createDough() {
		return "薄地壳比萨生面团";
	}

	public String createSauce() {
		return "纽约专用蘸料";
	}

	public String createChieese() {
		return "Reggiano干酪";
	}

	public String[] createVeggies() {
		 
		return new String[]{"洋葱","生菜","香菇"};
	}
	public String createPepperoni() {
		return "意大利辣香肠";
	}
}

创建pizza工厂

public class ChinaPizzaFactory extends PizzaFactory {
	
	public Pizza createPizza(String type) {
		Pizza pizza = null;
		PizzaIngredientFactory ingredientFactory = new ChinaPizzaIngredientFactory();
		if(type.equals("cheese")) {
			pizza = new CheesePizza(ingredientFactory);
			pizza.setName("中国芝士pizza");
		}else if (type.equals("clam")) {
			pizza = new ClamPizza(ingredientFactory);
			pizza.setName("中国蛤蜊pizza");
		}
		return pizza;
	}
}

 // 具体的Pizza类
public class ClamPizza extends Pizza {
	PizzaIngredientFactory ingredientFactory;
	
	public ClamPizza(PizzaIngredientFactory pizzaIngredientFactory) {
		this.ingredientFactory = pizzaIngredientFactory;
	}

	public void prepare() {
		System.out.println("Preparinging" + name);
        // 根据pizza本身的特点，从工厂中获取自己需要的原料
		dough = ingredientFactory.createDough();
		sauce = ingredientFactory.createSauce();
		clam = ingredientFactory.creatClam();
	}
}

创建一个中国蛤蜊pizza

// 创建一个Pizza工厂
PizzaFactory pizzaFactory = new ChinaPizzaFactory();
Pizza clamPizza = pizzaFactory.createPizza("clam");

抽象工厂模式将'对象' 与 ‘’组成对象或者对象依赖的类‘’解耦。

三、对比与分析

通过new来创建对象是面向具体类编程，扩展性差！

简单工厂把全部的事情都在一个地方处理完了，但是当有新增或者修改的对象类时，很难进行扩展，违反了开闭原则。简单工厂并不能算是工厂模式，而是一种编程习惯，或者是一种方法的封装，并不具备弹性。

工厂方法是创建一个框架，让子类决定如何实现。虽然可能导致类会变多，代码稍微复杂，但是这样做最大的好处是更具有弹性。

工厂模式的好处：将创建对象的代码集中在一个对象或者方法中，可以避免代码中重复的代码，并且方便以后的维护。依赖接口，而不是具体的类。

如何选择？

当需要将对象家族和具体的对象集合结合起来时，可以使用抽象工厂。

当需要将客户代码从需要实例化的具体类中解耦，或者目前还不中知道将来实例化哪些具体类时，可以使用工厂方法。