【设计模式之禅】工厂方法模式

什么是工厂方法模式？

工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。

工厂模式使用频率非常高，日常开发总能用到它。

工厂模式的通用类图

工厂模式通用代码

抽象产品类Product:

public abstract class Product {
	// 产品类的公共方法
	public void method1(){
		// 业务逻辑
	}
	// 抽象方法
	public abstract void method2();
}

具体产品类ConcreteProduct:

public class ConcreteProduct1 extends Product {
	@Override
	public void method2() {
		// ConcreteProduct1的业务逻辑
	}
}

public class ConcreteProduct2 extends Product {
	@Override
	public void method2() {
		// ConcreteProduct2的业务逻辑
	}
}

抽象工厂类Creator：

public abstract class Creator {
	/**
	 * 创建一个产品对象，其输入参数类型可以自行设置
	 * 通常是String、Enum、Class等
	 */
	public abstract <T extends Product> T createProduct(Class<T> c);
}

具体如何产生一个产品，由具体工厂类完成：

public class ConcreteCreator extends Creator {
	@Override
	public <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return (T) product;
	}
}

工厂方法模式的应用

优点

• 良好的封装性，代码结构清晰。只需知道类名就可以创建产品，降低模块间耦合。
• 工厂方法模式拓展性优秀，增加产品类的情况下，只需适当修改具体工厂类或拓展一个工厂类。
• 屏蔽了产品类，这点很重要，产品如何实现如何变化，调用者不需要关心。
• 工厂模式是典型的解耦框架。

工厂方法模式使用场景

• 首先，替代new关键字，但是需要慎重考虑是否用，因为增加了类的复杂度。
• 其次，需要灵活可拓展的框架时，可以考虑采用工厂方法模式。例如设计一个连接邮件服务器的框架，三种网络协议：POP3、IMAP、HTTP我们就可以把这三种作为产品类，如果某些服务器提供了新的WebService接口，只需增加一个产品类就可以了。
• 再次，工厂方法模式可以用在异构项目中，例如通过WebService与一个非java的项目交互，虽然WebService号称可以做到异构项目的同构化，但是实际还是会碰到很多问题，比如类型问题，WSDL文件的支持问题等。我们可以设计从WSDL产生的对象都是产品，然后由一个工厂类进行管理，减少与外围系统的耦合。

工厂方法模式的拓展

简单工厂模式

一般情况一个模块只需要一个工厂类，没有必要把它生产出来，使用静态方法就可以，这样我们不需要抽象工厂类，把具体工厂创建类的方法改为静态，如下：

public class ConcreteCreator {
	
	public static <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return (T) product;
	}
}

上层模块直接用ConcreteCreator.createProduct(..)进行生产产品类就可以了。

多个工厂类模式

当我们做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。例如一个产品类有5个具体产品实现，每个实现类的初始化方法（不仅是new，还是给实例设置值）都不同，如果写在一个工厂方法中，这个工厂必然巨大无比，这个时候我们就为每一个产品定义一个创造者，然后由调用者自己选择与那个工厂方法关联。

这里代码就不做演示了，相信读者可以自己写出。

替代单例模式

单例工厂通过反射获取单例，如下：

public class SingletonFactory {
	private static Singleton singleton = null;
	static {
		try {
			Class<?> cls = Class.forName(Singleton.class.getName());
			// 获得无参构造
			Constructor cons = cls.getDeclaredConstructor();
			// 设置无参构造函数是可以访问的
			cons.setAccessible(true);
			singleton = (Singleton) cons.newInstance();
		} catch (Exception e) {
			// 异常处理
		} 
	}
	public static Singleton getSingleton(){
		return singleton;
	}
}

延迟初始化

一个对象被消费完毕后，并不立即释放，工厂类保持其初始状态，等待重用。代码如下：

public class ProductFactory {
	// 缓存容器
	private static final Map<String, Product> prMap = new HashMap<String, Product>();
	public static synchronized Product createProduct(String type) throws Exception {
		Product product = null;
		if (prMap.containsKey(type)){
			product = prMap.get(type);
		} else {
			if (type.equals("Product1")) {
				product = new ConcreteProduct1();
			} else {
				product = new ConcreteProduct2();
			}
			// 同时把对象放到缓存容器中
			prMap.put(type, product);
		}
		return product;
	}
}

通过定义一个Map容器，容纳所有产生的对象，如果在Map容器中有对象，则直接取出，没有则根据需要的类型产生一个对象放入Map容器中。方便下次使用。

延迟加载是可以拓展的，例如限制某一个产品类的最大实例化数量，可以通过判断Map中已有的对象数量来实现。

延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，涉及多方面交互，可以通过延迟加载降低对象的产生和销毁带来的复杂性。