学习——工厂方法模式（FACTORY METHOD）

工厂方法模式（FACTORY METHOD）

1.工厂方法模式的定义

工厂方法模式使用的频率非常高，在我们日常的开发中总能见到它的身影。其定义为：Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类）。
在工厂方法模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义；AbstractProductFactory为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工厂ProductFactory完成的。
工厂模式示例

package com.qqxhb.pattern;

/**
 * 抽象产品类
 * 
 * @author Administrator
 *
 */
public abstract class Product {

	/**
	 * 设置产品信息抽象方法
	 * 
	 */
	public abstract void printInfo();
}

package com.qqxhb.pattern;

/**
 * 抽象产品工厂类
 * 
 * @author Administrator
 *
 */
public abstract class AbstractProductFactory {

	/**
	 * 创建产品抽象方法
	 * 
	 * @param c 产品子类
	 * @return
	 */
	public abstract <T extends Product> T createProduct(Class<T> c);
}

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.AbstractProductFactory;
import com.qqxhb.pattern.Product;

/**
 * 产品工厂实现类
 * 
 * @author Administrator
 *
 */
public class ProductFactory extends AbstractProductFactory {

	@SuppressWarnings("unchecked")
	@Override
	public <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (T) product;
	}

}

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.Product;

/**
 * 产品实现类——桌子
 * 
 * @author Administrator
 *
 */
public class Table extends Product {

	@Override
	public void printInfo() {
		System.out.println("Product Table");
	}

}

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.Product;

/**
 * 产品实现类——椅子
 * 
 * @author Administrator
 *
 */
public class Chair extends Product {

	@Override
	public void printInfo() {
		System.out.println("Prodct Chair");
	}

}

package com.qqxhb.pattern;

import com.qqxhb.pattern.impl.Chair;
import com.qqxhb.pattern.impl.ProductFactory;
import com.qqxhb.pattern.impl.Table;

public class Client {
	public static void main(String[] args) {
		AbstractProductFactory factory = new ProductFactory();
		Product product = factory.createProduct(Table.class);
		product.printInfo();
		product = factory.createProduct(Chair.class);
		product.printInfo();
	}
}

2.工厂方法模式的应用

2.1 优点

首先，良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创建对象的艰辛过程，降低模块间的耦合。
其次，工厂方法模式的扩展性非常优秀。在增加产品类的情况下，只要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。
再次，屏蔽产品类。这一特点非常重要，产品类的实现如何变化，调用者都不需要关心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类决定的。在数据库开发中，大家应该能够深刻体会到工厂方法模式的好处：如果使用JDBC连接数据库，数据库从MySQL切换到Oracle，需要改动的地方就是切换一下驱动名称（前提条件是SQL语句是标准语句），其他的都不需要修改，这是工厂方法模式灵活性的一个直接案例。
最后，工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类，没问题！

2.2 使用场景

首先，工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，但是需要慎重地考虑是否要增加一个工厂类进行管理，增加代码的复杂度。
其次，需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。

3.工厂方法模式的其他实现方式

3.1简单工厂方法模式

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.Product;

/**
 * 简单工厂类 修改工厂方法模式中的代码 不再需要抽象工厂类
 * 
 * @author Administrator
 *
 */
public class ProductFactory {

	@SuppressWarnings("unchecked")
	public static <T extends Product> T createProduct(Class<T> c) {
		Product product = null;
		try {
			product = (Product) Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (T) product;
	}

}

package com.qqxhb.pattern;

import com.qqxhb.pattern.impl.Chair;
import com.qqxhb.pattern.impl.ProductFactory;
import com.qqxhb.pattern.impl.Table;

public class Client {
	public static void main(String[] args) {
		Product product = ProductFactory.createProduct(Table.class);
		product.printInfo();
		product = ProductFactory.createProduct(Chair.class);
		product.printInfo();
	}
}

该模式是工厂方法模式的弱化，因为简单，所以称为简单工厂模式（Simple Factory Pattern），也叫做静态工厂模式。在实际项目中，采用该方法的案例还是比较多的，其缺点是工厂类的扩展比较困难，不符合开闭原则，但它仍然是一个非常实用的设计模式。

3.2 多个工厂类模式

考虑到需要结构清晰，我们就为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联。

package com.qqxhb.pattern;

/**
 * 抽象产品工厂类
 * 
 * @author Administrator
 *
 */
public abstract class AbstractProductFactory {

	/**
	 * 抽象方法中已经不再需要传递相关参数了，因为每一个具体的工厂都已经非常明 确自己的职责：创建自己负责的产品类对象。
	 * 
	 * @return
	 */
	public abstract Product createProduct();
}

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.AbstractProductFactory;
import com.qqxhb.pattern.Product;

/**
 * 桌子产品工厂
 * 
 * @author Administrator
 *
 */
public class TableFactory extends AbstractProductFactory {

	@Override
	public Product createProduct() {
		return new Table();
	}

}

package com.qqxhb.pattern.impl;

import com.qqxhb.pattern.AbstractProductFactory;
import com.qqxhb.pattern.Product;

/**
 * 椅子产品工厂
 * 
 * @author Administrator
 *
 */
public class ChairFactory extends AbstractProductFactory {

	@Override
	public Product createProduct() {
		return new Chair();
	}

}

package com.qqxhb.pattern;

import com.qqxhb.pattern.impl.ChairFactory;
import com.qqxhb.pattern.impl.TableFactory;

public class Client {
	public static void main(String[] args) {
		Product product = new TableFactory().createProduct();
		product.printInfo();
		product = new ChairFactory().createProduct();
		product.printInfo();
	}
}

每个具体的产品类都对应了一个创建者，每个创建者都独立负责创建对应的产
品对象，非常符合单一职责原则。但是，如果一个系统比较复杂时工厂类也会相应地变复杂，给可扩展性和可维护性带来了一定的影响。如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同，维护时需要考虑两个对象之间的关系。当然，在复杂的应用中一般采用多工厂的方法，然后再增加一个协调类，避免调用者与各个子工厂交流，协调类的作用是封装子工厂类，对高层模块提供统一的访问接口。

3.3 延迟初始化

一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂方法模式的一个扩展应用，具体实现如下。

package com.qqxhb.pattern.impl;

import java.util.HashMap;

import com.qqxhb.pattern.Product;

/**
 * ProductFactory负责产品类对象的创建工作，并且通过productMap变量产生一个缓存，对需要 再次被重用的对象保留
 * 
 * @author Administrator
 *
 */
public class ProductFactory {

	private static final HashMap<String, Product> productMap = new HashMap<String, Product>();

	public static synchronized Product createProduct(String type) throws Exception {
		Product product = null;
		if (productMap.containsKey(type)) {
			product = productMap.get(type);
		} else {
			if ("table".equals(type)) {
				product = new Table();
			} else {
				product = new Chair();
			}
			productMap.put(type, product);
		}
		return product;
	}

}

延迟加载框架是可以扩展的，例如限制某一个产品类的最大实例化数量，可以通过判断Map中已有的对象数量来实现，这样的处理是非常有意义的，例如JDBC连接数据库，都会要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。
延迟加载还可以用在对象初始化比较复杂的情况下，例如硬件访问，涉及多方面的交互，则可以通过延迟加载降低对象的产生和销毁带来的复杂性。