工厂模式

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

抽象产品类

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 {
	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. 屏蔽产品类，无论产品类的实现如何变化，只要产品接口保持不变，系统的上层模块就不需要发生变化。

使用场景

1. 需要灵活、可扩展的框架时。例如需要设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3、IMAP、HTTP，我们就可以把这三种连接方法作为产品类，定义一个接口如IConnectMail，然后定义对邮件的操作方法，用不同的方法实现三个具体的产品类（也就是
   连接方式）再定义一个工厂方法，按照不同的传入条件，选择不同的连接方式。

2. 用在异构项目中，例如通过WebService与一个非Java的项目交互，从WSDL中产生的对象都认为是一个产品，然后由一个具体的工厂类进行管理，减少与外围系统的耦合。

3. 用在测试驱动开发的框架下，例如，测试一个类A，就需要把与类A有关联关系的类B也同时产生出来，我们可以使用工厂方法模式把类B虚拟出来，避免类A与类B的耦合。

扩展

缩小为简单工厂模式

一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法就可以了。

去掉抽象工厂类，将create方法设置为静态类型，简化了类的创建过程。也叫做静态工厂模式。其缺点是工厂类的扩展比较困难，不符合开闭原则，但它仍然是一个非常实用的设计模式。

升级为多个工厂类

当我们在做一个比较复杂的项目时，经常会遇到初始化一个对象很耗费精力的情况，所有的产品类都放到一个工厂方法中进行初始化会使代码结构不清晰。

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

替代单例模式

Singleton定义了一个private的无参构造函数，目的是不允许通过new的方式创建一个对象。

单例类

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

Singleton保证不能通过正常的渠道建立一个对象，那SingletonFactory如何建立一个单例对象呢？答案是通过反射方式创建。

负责生成单例的工厂类

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;
	}
}

延迟初始化

何为延迟初始化（Lazy initialization）？一个对象被消费完毕后，并不立刻释放，工厂类保持其初始状态，等待再次被使用。

ProductFactory负责产品类对象的创建工作，并且通过prMap变量产生一个缓存，对需要再次被重用的对象保留。

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;
		}
}