工厂模式-简单工厂模式

工厂模式是我们最常用的实例化对象模式，是用工厂方法代替new操作的一种模式。工厂模式专门负责将大量有共同接口的类实例化。工厂模式可以动态决定将哪一个类实例化，不必事先知道每次要实例化哪一个类。

工厂模式在《Java与模式》中分三类：简单工厂模式（Simple Factory），工厂方法模式（Factory Method），抽象工厂模式（Abstract Factory）。

在此先对简单工厂模式做一下学习总结。

简单工厂模式（Simple Factory）：类的创建模式，又叫静态工厂方法（static factory method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。是不同的工厂方法模式的一个特殊实现。它有三个角色组成：

1）工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，含有与应用紧密相关的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个 具体Java类实现。

2）抽象产品（Product）角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或他们共同拥有的接口。抽象产品可以用一个Java接口或者Java抽象类实现。

3）具体产品（Concreat Product）角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品角色由一个具体Java类实现。

或者再加一个角色就是客户端。

下面设计一个情景模式：在农场生产水果，比如草莓和葡萄，水果都有通用的方法，如种植（plant），生长（grow

），收获（harvest）等。

首先创建一个抽象的产品角色Fruit

package factory.simplefactory;
/**
 * 抽象产品（Product）角色
 * @author SUNZ-SQ
 *
 */
public interface Fruit {

	/**
	 * 种植
	 */
	void plant();
	/**
	 *生长
	 */
	void grow();
	/**
	 *收获
	 */
	void harvest();
}

下面创建具体产品角色，葡萄（grape）和草莓（strawberry）。

Grape：

package factory.simplefactory;
/**
 * 具体产品（Concreat Product）角色
 * 葡萄
 * @author SUNZ-SQ
 *
 */
public class Grape implements Fruit {

	/**
	 * 生长
	 */
	@Override
	public void grow() {
		log("Grape is growing...");
	}

	/**
	 * 收获
	 */
	@Override
	public void harvest() {
		log("Grape has been harvested");
	}

	/**
	 * 种植
	 */
	@Override
	public void plant() {
		log("Grape has been planted");
	}

	/**
	 * 辅助功能
	 * @param msg
	 */
	public void log(String msg){
		
		System.out.println(msg);
	}
}

Strawberry：

package factory.simplefactory;
/**
 * 具体产品（Concreat Product）角色
 * 草莓
 * @author SUNZ-SQ
 *
 */
public class Strawberry implements Fruit {

	/**
	 * 生长
	 */
	@Override
	public void grow() {
		log("Strawberry is growing...");
	}
	/**
	 * 收获
	 */
	@Override
	public void harvest() {
		log("Strawberry has been harvested");
	}
	/**
	 * 种植
	 */
	@Override
	public void plant() {
		log("Strawberry has been planted");
	}
	/**
	 * 辅助方法
	 */
	public void log(String msg){
		System.out.println(msg);
	}

}

创建工厂类角色：

package factory.simplefactory;
/**
 * 工厂类（Creator）角色
 * 农场园丁
 * @author SUNZ-SQ
 *
 */
public class FruitGardener {

	/**
	 * 工厂方法
	 * @param which
	 * @return
	 * @throws BadFruitException
	 */
	public static Fruit factory(String which) throws BadFruitException{
		if(which.equalsIgnoreCase("grape")){
			return new Grape();
		}else if(which.equalsIgnoreCase("strawberry")){
			return new Strawberry();
		}else{
			throw new BadFruitException("Bad fruit request!");
		}
	}
}

为了严谨，在工厂类角色中加了异常类BadFruitException，代码如下：

package factory.simplefactory;
/**
 * 坏水果异常类
 * @author SUNZ-SQ
 *
 */
public class BadFruitException extends Exception {

	public BadFruitException(String msg){
		super(msg);
	}
}

最后创建一个 客户端来调用工厂生产水果，代码如下。

package factory.simplefactory;
/**
 * 客户端
 * @author SUNZ-SQ
 */
public class Client {

	public static void main(String[] args){
		
		try {
			Fruit grape = FruitGardener.factory("grape");
			grape.plant();
			Fruit strawberry = FruitGardener.factory("strawberry");
			strawberry.harvest();
			Fruit apple = FruitGardener.factory("apple");
			apple.grow();
		} catch (BadFruitException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

运行结果如下截图：

总结：

优点：简单工厂模式的核心是工厂类。这个类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例。而客户端则可以免除直接创建产品对象的责任，而仅仅负责“消费”产品。此模式完成了对责任的分割。

缺点：当产品类有复杂的多层次等级结构时，工厂类只有它自己。以不变应万变，就是模式的缺点。这个工厂集中了所有的产品创建逻辑，形成了一个无所不知的全能类，又叫上帝类（God Class），如果一旦不能工作了，正常工厂就无法进行生产，而且维护起来非常繁琐。除此之外呢，工厂的方法采用的是静态方法，能继承，能覆盖，但是无法实现子类的重写，因此工厂角色无法形成基于继承的等级结构。

开-闭原则：原则要求一个系统的设计能够允许系统在无需修改的情况下，扩展其功能。就拿上例来说，如果客户要求生成一个apple，客户端只需要找到工厂要apple，工厂呢需要拿着请求去创建apple，这个过程客户无需修改，而工厂需要修改源代码，所以说简单工厂角色只在有限的程度上支持开-闭原则。

参考书：《java与模式》