标签：

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抽象类负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象工厂类，具体如何创建产品类由具体的实现工厂ConcreteCreator来完成。我们来看一下通用的模板代码：

public abstract class Product {
	
	public void method() { //产品类的公共方法，已经实现
		//实现了公共的逻辑
	}
	
	public abstract void method2(); //非公共方法，需要子类具体实现
}

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

	@Override
	public void method2() {
		//product2的业务逻辑
	}
}

public abstract class Creator {
	//创建一个产品对象，其输入参数类型可以自行设置
	public abstract <T extends Product> T createProduct(Class<T> clazz);
}

public class ConcreteCreator extends Creator {

	@Override
	public <T extends Product> T createProduct(Class<T> clazz) {
		Product product = null;
		try {
			product = (Product) Class.forName(clazz.getName()).newInstance();
		} catch (Exception e) { //异常处理
			e.printStackTrace();
		}
		return (T) product;
	}
}

public class FactoryTest {

	public static void main(String[] args) {
		Creator factory = new ConcreteCreator();
		Product product1 = factory.createProduct(ConcreteProduct1.class); //通过不同的类创建不同的产品
 		Product product2 = factory.createProduct(ConcreteProduct2.class);
		 /*
		  * 下面继续其他业务处理
		  */
	 }
}

2.用女蜗造人阐述工厂模式

        现在女娲要造人，她要造三种人：白种人、黄种人和黑种人。怎么造呢？她得有个能产生人类的工厂吧（类似于八卦炉的东西），这个工厂得让她生产出不同的人种。每个人都有两个属性：皮肤颜色和说话。那现在我们开始设计女蜗造人的程序，首先我们看一下造人的类图：

        抽象接口Human是人类，里面有两个方法，getColor获得皮肤颜色，talk交谈。下面三个具体Human的实现类，分别实现三个人种。根据工厂模式，应该有个抽象工厂，AbstractHumanFactory就担当了这个责任，里面有个抽象方法createHuman，那HumanFactory就是实现类了，实现抽象工厂里的方法。下面我们看看具体实现：

public interface Human {	
	public void getColor();//人有不同的颜色	
	public void talk(); //人会说话
}

public class BlackHuman implements Human {// 黑种人

	@Override
	public void getColor() {
		System.out.println("Black");
	}
	@Override
	public void talk() {
		System.out.println("Black man");
	}
}
public class Human implements Human {	//黄种人

	@Override
	public void getColor() {
		System.out.println("Yellow");
	}
	@Override
	public void talk() {
		System.out.println("Yellow man");
	}
}
public class WhiteHuman implements Human {//白种人

	@Override
	public void getColor() {
		System.out.println("White");
	}
	@Override
	public void talk() {
		System.out.println("White man");
	}
}

        好了，人的模子搞好了，现在女娲要开始搭建八卦炉了，于是女娲开始画八卦炉模型了：

public abstract class AbstractHumanFactory{
	public abstract <T extends Human> T createHuman(Class<T> clazz); //注意这里T必须是Human的实现类才行，因为要造Human嘛
}

public class HumanFactory extends AbstractHumanFactory {

	@Override
	public <T extends Human> T createHuman(Class<T> clazz) {
		Human human = null;
		try {
			human = (Product) Class.forName(clazz.getName()).newInstance();
		} catch (Exception e) { //异常处理
			System.out.println("人种产生错误");
		}
		return (T) human;
	}
}

        好，现在人种也有了，八卦炉也有了，剩下的就是采集黄土，然后命令八卦炉开始生产了：

public class FactoryTest {
	public static void main(String[] args) {
		AbstractHumanFactory bagualu = new HunmanFactory();
		Human blackMan = bagualu.createHuman(BlackHuman.class); //黑人诞生了
 		Human yellowMan = bagualu.createHuman(YelloHuman.class); //黄人诞生了
		Human whiteMan = bagualu.createHuman(WhiteHuman.class); //白人诞生了
	  }
}

3.工厂模式的扩展

3.1 静态工厂模式

        我们还用上面女娲造人的例子说明，现在女娲在思考一个问题：我现在只需要一个工厂就可以把人生产出来，我干嘛要具体的工厂对象呢？我只要使用静态方法就好了。这样一想，于是女娲就开始把AbstractHumanFactory抽象类去掉了，只保留了HumanFactory类，同时把createHuman方法设置成了static类型，搞定！

public class HumanFactory {

	@Override
	public static <T extends Human> T createHuman(Class<T> clazz) {
		Human human = null;
		try {
			human = (Product) Class.forName(clazz.getName()).newInstance();
		} catch (Exception e) { //异常处理
			System.out.println("人种产生错误");
		}
		return (T) human;
	}
}

Human blackMan = HumanFactory.createHuman(BlackHuman.class);

        这就是静态工厂模式，在实际项目中，根据需求可以设置成静态工厂类，但是缺点是扩展比较困难，如果就一个工厂，不需要扩展，可以这么设计，仍然是很常用的。

3.2 多个工厂模式

        我们还以女娲造人为例，后来女娲想了想，，这人不可能就说话吧，还得有不同的属性杀的，如果在一个八卦炉里造，除了new一个人外，还得对不同的人设置不同的属性，这样的话，八卦炉有点吃不消阿……又有点乱啊……但是她想到了一个法子，每个人种弄个八卦炉，不同的八卦炉专门生产不同的人种，这样就结构清晰了，她在造人的时候自己选择与哪个八卦炉相关联就行了。示意图如下：

        这样的话AbstractHumanFactory抽象类我们就要改写了：

public abstract class AbstractHumanFactory {
	public abstract Human createHuman();
}

public class BlackHumanFactory extends AbstractHumanFactory {
	public Human createHuman() {
		return new BlackHuman();
	}
}
public class YellowHumanFactory extends AbstractHumanFactory {
	public Human createHuman() {
		return new YellowHuman();
	}
}
public class WhiteHumanFactory extends AbstractHumanFactory {
	public Human createHuman() {
		return new WhiteHuman();
	}
}

public class FactoryTest {
	public static void main(String[] args) {
		Human blackMan = new BlackHumanFactory().createHuman(); //黑人诞生了
 		Human yellowMan = new YellowHumanFactory().createHuman(); //黄人诞生了
		Human whiteMan = new WhiteHumanFactory().createHuman(); //白人诞生了
	  }
}

3.3 替代单例模式

        上一章介绍了单例模式，并且指出了单例和多例的一些缺点，但是我们是不是可以采用工厂模式来实现一个单例模式的功能呢？答案是肯定的，单例模式的核心要求就是在内存中只有一个对象，通过工厂方法模式也可以只在内存中生产一个对象。见下面：

Singleton类定义了一个private的无参构造方法，目的是不允许通过new的方式创建对象，另外，Singleton类也不自己定义一个Singleton对象了，因为它要通过工厂来获得。

public class Singleton {
	private Singleton() {
		
	}
	public void doSomething() {
		//业务处理
	}
}

public class SingletonFactory {
	private static Singleton instance;
	static {
		try {		
			Class clazz = Class.forName(Singleton.class.getName());
			//获取无参构造方法
			Constructor constructor = clazz.getDeclaredConstructor();
			//设置无参构造方法可访问
			constructor.setAccessible(true);
			//产生一个实例对象
			instance = (Singleton) constructor.newInstance();
		} catch (Exception e) {
			//异常处理
		}
	}
	public static Singleton getInstance() {
		return instance;
	}
}

3.4 延迟初始化

        何为延迟初始化（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;
	}
}

        代码比较简单，通过定义一个Map容器，容纳所有产生的对象，每次在new一个对象的时候先判断Map中有没有，有就不用再new了，直接取。另外，每次new过一个对象后，也将其放入Map中方便下次调用。

        延迟加载时很有用的，比如JDBC连接数据库，会要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。

4. 工厂模式的应用

    优点：

        1. 工厂模式具有良好的封装性，代码结构清晰，也有利于扩展。在增加产品类的情况下，只需要适当地修改具体的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。

        2. 工厂模式可以屏蔽产品类。这一点非常重要，产品类的实现如何变化，调用者都不用关系，只需要关心产品的接口，只要接口保持不变，系统的上层模块就不需要发生变化。

        3. 工厂模式是典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不用关心。

       工厂模式就介绍这么多吧，如果错误之处，欢迎留言指正~

_____________________________________________________________________________________________________________________________________________________

-----乐于分享，共同进步！

【java设计模式】之 工厂（Factory）模式

标签：

原文地址：http://blog.csdn.net/eson_15/article/details/51223124