工厂方法模式

工厂方法模式的定义:

    Define an interface for creating an object,but let subclasses decide which class toinstantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。）
工厂方法模式的通用类图:

在工厂方法模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义；Creator为抽象创建类，也就是抽象工厂，具体如何创建产品类是由具体的实现工厂ConcreteCreator完成的。工厂方法模式的变种较多，我们来看一个比较实用的通用源码。

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

/**
*具体的产品类可以有多个，都继承于抽象产品类
*/
public class ConcreteProduct1 extends Product {
	public void method2() {
		//业务逻辑处理
	}
}
public class ConcreteProduct2 extends Product {
	public void method2() {
		//业务逻辑处理
	}
}

/**
*抽象工厂类负责定义产品对象的产生
*/
public abstract class Creator {
	/*
	* 创建一个产品对象，其输入参数类型可以自行设置
	* 通常为String、Enum、Class等，当然也可以为空
	*/
	public abstract <T extends Product> T createProduct(Class<T> c);
}

/**
*具体如何产生一个产品的对象，是由具体的工厂类实现的
*/
public class ConcreteCreator extends Creator {
	public <T extends Product> T createProduct(Class<T> c){
		Product product=null;
		try {
			product = (Product)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			//异常处理
		}
		return (T)product;
	}
}

/**
*场景类的调用方法
*/
public class Client {
	public static void main(String[] args) {
		Creator creator = new ConcreteCreator();
		Product product = creator.createProduct(ConcreteProduct1.class);
		/*
		* 继续业务处理
		*/
	}
}

说明:该通用代码是一个比较实用、易扩展的框架，可以根据实际项目需要进行扩展。

工厂方法模式的优点:

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

工厂方法模式的使用场景

1. 首先，工厂方法模式是new一个对象的替代品，所以在所有需要生成对象的地方都可以使用，但是需要慎重地考虑是否要增加一个工厂类进行管理，增加代码的复杂度。
2. 其次，需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。
3. 再次，工厂方法模式可以用在异构项目中。例如通过WebService与一个非Java的项目交互，虽然WebService号称是可以做到异构系统的同构化，但是在实际的开发中，还是会碰到很多问题，如类型问题、WSDL文件的支持问题，等等。从WSDL中产生的对象都认为是一个产品，然后由一个具体的工厂类进行管理，减少与外围系统的耦合。
4. 最后，可以使用在测试驱动开发的框架下。例如，测试一个类A，就需要把与类A有关联关系的类B也同时产生出来，我们可以使用工厂方法模式把类B虚拟出来，避免类A与类B的耦合。(目前由于JMock和EasyMock的诞生，该使用场景已经弱化了，可以在遇到此种情况时直接考虑使用JMock或EasyMock)

扩展:

1. 缩小为简单工厂模式
   实现:一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法就可以了(去掉抽象类,同时把工厂生产方法设置为静态类型)

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 (Exception e) {
				//异常处理
			}
			return (T)product;
		}
	}

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

2. 升级为多个工厂类

   1. 问题:当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。
   2. 解决:考虑到需要结构清晰，我们就为每个产品定义一个创造者，然后由调用者自己去选择与哪个工厂方法关联(抽象方法中已经不再需要传递相关参数了，因为每一个具体的工厂都已经非常明
      确自己的职责：创建自己负责的产品类对象)。
   3. 好处:创建类的职责清晰，而且结构简单
   4. 坏处:给可扩展性和可维护性带来了一定的影响(如果要扩展一个产品类，就需要建立一个相应的工厂类，这样就增加了扩展的难度。因为工厂类和产品类的数量相同，维护时需要考虑两个对象之间的关系)
   5. 解决方案:复杂的应用中一般采用多工厂的方法，然后再增加一个协调类，避免调用者与各个子工厂交流，协调类的作用是封装子工厂类，对高层模块提供统一的访问接口。

3. 替代单例模式
   通过获得类构造器，然后设置访问权限，生成一个对象，然后提供外部访问，保证内存中的对象唯一。
   工厂方法模式替代单例模式类图

//单例类	
	public class Singleton {
		//不允许通过new产生一个对象
		private Singleton(){
		}
		public void doSomething(){
			//业务处理
		}
	 }

	//负责生成单例的工厂类
	public class SingletonFactory {
		private static Singleton singleton;
		static{
			try {
				Class cl= Class.forName(Singleton.class.getName());
				//获得无参构造
				Constructor constructor=cl.getDeclaredConstructor();
				//设置无参构造是可访问的
				constructor.setAccessible(true);
				//产生一个实例对象
				singleton = (Singleton)constructor.newInstance();
			} catch (Exception e) {
				//异常处理
			}
		}

		public static Singleton getSingleton(){
			return singleton;
		}
	}

以上通过工厂方法模式创建了一个单例对象，该框架可以继续扩展，在一个项目中可以产生一个单例构造器，所有需要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架，只要输入一个类型就可以获得唯一的一个实例。

4. 延迟初始化
   延迟初始化（Lazy initialization）:一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。
   延迟初始化是工厂方法模式的一个扩展应用，其通用类图如图
   

/**
	* 延迟加载的工厂类
	*/
	public class ProductFactory {
		private static final Map<String,Product> prMap = new HashMap();
		public static synchronized Product createProduct(String type) throws Exception{
			Product product =null;
			//如果Map中已经有这个对象
			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;
		}
	}

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

后记:

工厂方法模式在项目中使用得非常频繁，以至于很多代码中都包含工厂方法模式。该模式几乎尽人皆知，但不是每个人都能用得好。熟能生巧，熟练掌握该模式，多思考工厂方法如何应用，而且工厂方法模式还可以与其他模式混合使用（例如模板方法模式、单例模式、原型模式等），变化出无穷的优秀设计，这也正是软件设计和开发的乐趣所在。