简单工厂模式

我们还是按部就班地进行wwh：

• 什么是简单工厂模式（what）
• 为什么使用简单工厂模式（why）
• 如何使用简单工厂模式（how）

什么是简单工厂模式

简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory Method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

为什么使用简单工厂模式

模式的核心是工厂类。这个类含有必要的判断逻辑，可以决定在什么时候创建哪一个产品类的实例。符合开-闭原则“对扩展开放，对修改关闭”，对新增一个产品有了很好的扩展。

如何使用简单工厂模式

简单工厂模式的引进

比如说有一个农场，专门向市场销售水果。在这里需要描述下列的水果：

• 苹果
• 葡萄
• 草莓

首先需要建立一个各种水果都适用的接口，以便与农场里的其他植物分开，水果接口规定所有水果必须实现接口，包括任何水果类必须具备的方法：种植plant()，生长grow()以及收获harvest()。接口Fruit的类图如下图所示：

package factory.simple.inter;

public interface Fruit {

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

Apple类是水果类的一种，因此它实现了水果接口所声明的所有方法。另外，由于苹果是多年生长植物，因此多出一个treeAge描述树龄。下面是这个Apple类的源代码，如下图所示：

package factory.simple.vo;

import factory.simple.inter.Fruit;

public class Apple implements Fruit{

	/**
	 * 树龄
	 */
	private int treeAge;
	
	@Override
	public void plant() {
		log("Apple has been planted.");
	}

	@Override
	public void grow() {
		log("Apple is growing......");
	}

	@Override
	public void harvest() {
		log("Apple has been harvested.");
	}
	
	public static void log(String msg) {
		System.out.println(msg);
	}

	public int getTreeAge() {
		return treeAge;
	}

	public void setTreeAge(int treeAge) {
		this.treeAge = treeAge;
	}

}

同理，Grape类是水果类的一种，也实现了Fruit接口所声明的所有方法。但由于葡萄分有籽和无籽两种，因此，有一个seedless性质，代码如下图所示：

package factory.simple.vo;

import factory.simple.inter.Fruit;

public class Grape implements Fruit{

	/**
	 * 是否有籽
	 */
	private boolean seedless;
	
	@Override
	public void plant() {
		log("Grape has been plant.");
	}

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

	@Override
	public void harvest() {
		log("Grape has been harvest.");
	}
	
	public static void log(String msg) {
		System.out.println(msg);
	}

	public boolean isSeedless() {
		return seedless;
	}

	public void setSeedless(boolean seedless) {
		this.seedless = seedless;
	}

	
}

同理，Strawberry类实现了Fruit接口，因此，也是水果类型的子类型，其源代码如下图所示：

package factory.simple.vo;

import factory.simple.inter.Fruit;

public class Strawberry implements Fruit{

	@Override
	public void plant() {
		log("Strawberry has been planted.");
	}

	@Override
	public void grow() {
		log("Strawberry is growing......");
	}

	@Override
	public void harvest() {
		log("Strawberry has been harvested.");
	}
	
	public static void log(String msg) {
		System.out.println(msg);
	}

}

农场的园丁也是系统的一部分，自然要由一个合适的类来代表，这个类就是FruitGardener类，该类会根据客户端的要求，创建出不同的水果对象。如果接到不合法的要求，该类会抛出BadFruitException异常，如下图所示：

package factory.simple.gardener;

import factory.simple.exception.BadFruitException;
import factory.simple.inter.Fruit;
import factory.simple.vo.Apple;
import factory.simple.vo.Grape;
import factory.simple.vo.Strawberry;

public class FruitGardener {
	
	public static Fruit factory(String name) throws BadFruitException {
		if (name.equalsIgnoreCase("apple")) {
			return new Apple();
		} else if (name.equalsIgnoreCase("grape")) {
			return new Grape();
		} else if (name.equalsIgnoreCase("strawberry")) {
			return new Strawberry();
		} else {
			throw new BadFruitException("Bad Fruit request.");
		}
	}
}

如果客户端的请求是系统不支持的，工厂方法就会抛出一个BadFruitException异常。代码如下图所示：

package factory.simple.exception;

public class BadFruitException extends Exception{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

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

客户端调用FruitGardener的静态方法即可。客户端测试类ClientTest，代码如下图所示：

package factory.simple.test;

import factory.simple.exception.BadFruitException;
import factory.simple.gardener.FruitGardener;

public class ClientTest {
	public static void main(String[] args) {
		try {
			FruitGardener.factory("apple").plant();
			FruitGardener.factory("grape").grow();
			FruitGardener.factory("strawberry").harvest();
			FruitGardener.factory("abc").plant();
		} catch (BadFruitException e) {
			e.printStackTrace();
		}
	}
}

这样，农场的系统创建完毕！
看看执行效果吧

Apple has been planted.
Grape is growing......
Strawberry has been harvested.
factory.simple.exception.BadFruitException: Bad Fruit request.
	at factory.simple.gardener.FruitGardener.factory(FruitGardener.java:19)
	at factory.simple.test.ClientTest.main(ClientTest.java:12)

Apple ，Grape，Strawberry正常调用，abc由于没有这种水果，显示了异常。

简单工厂模式的结构

简单工厂模式是类的创建模式，这个模式的一般性结构，如下图所示：

上图可以看出，简单工厂模式涉及到工厂角色、抽象产品角色以及具体产品角色：

• 工厂类（Creator）角色：担任这个角色的是工厂方法模式的核心，工厂类在客户端的直接调用下创建产品对象，它往往由一个具体Java类实现。
• 抽象产品（Product）角色：担任这个角色的类是由工厂方法模式所创建的对象的父类，或它们共同拥有的接口。抽象产品角色可以用一个Java接口或者抽象类实现。
• 具体产品（Concrete Product）角色：工厂方法模式所创建的任何产品对象都是这个角色的实例，具体产品角色由一个具体Java类实现。

优点

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

缺点

待续…