原文:@http://blog.csdn.net/eson_15/article/details/51223124
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. 工厂模式是典型的解耦框架。高层模块只需要知道产品的抽象类,其他的实现类都不用关心。
工厂模式就介绍这么多吧,如果错误之处,欢迎留言指正~