【JAVA设计模式】工厂方法模式（Factory Method）无标题文章

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method 使一个类的实例化延迟到其子类

正如名字所示，工厂方法模式与简单工厂有几分相似。关于差异，后文将会介绍。

案例

例如有这样一个应用：实现一个导出数据的应用框架，来让客户选择导出方式，比如导出成文本格式，数据格式，xml格式等等。
依然，为了面向接口编程。我们首先定义一个接口，抽象了导出数据功能。

/**
 * 各种导出形式的操作都遵循此接口
 * Created by jerry on 16-4-21.
 */
public interface ExportFileApi {
    /**
     * 导出内容
     * @param data 导出数据
     * @return 是否成功
     */
    public boolean export(String data);
}

现在如果我想要实现把数据导出文本格式或者导出成其他格式，那么实现此接口即可。

/**
 * 将数据导出到txt文件中去
 * Created by jerry on 16-4-21.
 */
public class ExportTxtFile implements ExportFileApi{

    @Override
    public boolean export(String data) {
        System.out.println("导出数据: "+ data + " 到txt中");
        return true;
    }
}

/**
 * 导出数据到数据库中
 * Created by jerry on 16-4-21.
 */
public class ExportDB implements ExportFileApi{

    @Override
    public boolean export(String data) {
        System.out.println("导出数据： " +data+ " 到数据库中");
        return true;
    }
}

问题

试想一个问题，当我们在设计时，我们还没有想好将来究竟是用哪个具体实现，例如究竟是导出到文件呢？还是数据库呢？还是其他？换句话说，关于具体采用哪种，我想之后再做决定。这时，为了让框架层代码能够不受影响，就需要工厂方法模式。

使用模式的情况

工厂方法模式的主要功能就是让父类在不知道具体实现的情况下，完成自身的功能调用，而具体实现延迟到子类来实现。通常情况下，父类是一个抽象类，里面包含了一个抽象方法，此方法即工厂方法。

/**
 * 实现导出数据操作功能
 * Created by jerry on 16-4-21.
 */
public abstract class ExportOperate {

    /**
     * 导出数据
     * @param data
     * @return
     */
    public boolean export(String data) {
        ExportFileApi api = factoryMethod();
        return api.export(data);
    }

    /**
     * 工厂方法，创建导出的文件对象的接口对象
     * @return
     */
    protected abstract ExportFileApi factoryMethod();
}

这样以后，继承ExportOperate的类必须复写factoryMethod()方法，即由子类来完成具体实现，在父类中无须关注到底是哪个具体实例负责具体的实现，父类只须面向接口编程，大大减少了耦合度。

/**
 * 在这里真正创建具体对象
 * Created by jerry on 16-4-21.
 */
public class ExportTxtFileOperate extends ExportOperate {

    @Override
    protected ExportFileApi factoryMethod() {
        return new ExportTxtFile();
    }
}

/**
 * Created by jerry on 16-4-21.
 */
public class ExportDBOperate extends ExportOperate {

    @Override
    protected ExportFileApi factoryMethod() {
        return new ExportDB();
    }
}

客户端调用如下：

/**
 * 测试类
 * Created by jerry on 16-4-21.
 */
public class Client {

    public static void main(String[] args) {
        ExportOperate operate = new ExportDBOperate();
        operate.export("test");
    }
}

参数化工厂方法

工厂方法的设计中，可以使用参数，这样就可以通过参数决定到底使用哪一个具体的实现。
如果采用参数化工厂方法，那么通常工厂方法不再抽象，而是变为普通方法，并且提供默认的实现。此时，既然有了默认实现，工厂方法所在类也无须变为抽象，普通类即可。这样客户端可以直接使用这个类。

/**
 * 实现导出数据操作功能
 * Created by jerry on 16-4-21.
 */
public class ExportOperateByPara {

    /**
     * 导出数据
     * @param data
     * @param type 类型选择
     * @return
     */
    public boolean export(int type, String data) {
        ExportFileApi api = factoryMethod(type);
        return api.export(data);
    }

    /**
     * 工厂方法，根据参数创建导出的文件对象的接口对象
     * @param type
     * @return
     */
    protected ExportFileApi factoryMethod(int type) {
        ExportFileApi api = null;

        if (type == 1) {
            api = new ExportTxtFile();
        } else if (type == 2) {
            api = new ExportDB();
        }
        return api;
    }

}

由于有了默认实现，直接使用即可，客户端调用如下：

/**
 * 测试类2
 * Created by jerry on 16-4-21.
 */
public class Client2 {

    public static void main(String[] args) {
        ExportOperateByPara operate = new ExportOperateByPara();
        operate.export(2,"test");
    }
}

之所以使用参数化工厂方法，是因为其扩展起来会非常方便，已有的代码不会变，只要新加入一个子类来提供新的工厂方法实现，然后在客户端使用这个新的子类即可。
例如，我们要扩展一个导出xml文件的类：

/**
 * 导出到xml
 * Created by jerry on 16-4-21.
 */
public class ExportXml implements ExportFileApi {

    @Override
    public boolean export(String data) {
        System.out.println("导出数据： " + data + " 到xml文件");
        return true;
    }
}

加入新的实现类，这里可以让子类选择性覆盖，进行功能增强，或者不想覆盖还可以返回去让父类来实现。

/**
 * Created by jerry on 16-4-21.
 */
public class ExportXmlOperate extends ExportOperateByPara {

    /**
     * 覆写工厂方法
     * @param type
     * @return
     */
    @Override
    protected ExportFileApi factoryMethod(int type) {
        ExportFileApi api = null;
        // 这里是一个强大功能，可以让子类选择性覆盖，不想覆盖的方法可以返回去让父类实现
        if (type == 3) {
            api = new ExportXml();
        } else {
            api = super.factoryMethod(type);
        }
        return api;
    }
}

/**
 * 测试类2
 * Created by jerry on 16-4-21.
 */
public class Client2 {

    public static void main(String[] args) {
        ExportOperateByPara operate = new ExportXmlOperate();
        operate.export(1,"test1");
        operate.export(2,"test2");
        operate.export(3,"test3");
    }
}

程序运行如下：

导出数据: test1 到txt中
导出数据： test2 到数据库中
导出数据： test3 到xml文件

这个易扩展性的获得，是因为工厂方法给子类提供了一个钩子，使得子类可以操作父类的方法，使得扩展新的对象版本变得非常容易。

与简单工厂模式的区别

如果把ExportOperateByPara中的export方法删掉，那么发现此类就是一个简单工厂类。所以两者其实非常相似，在具体实现上都是“选择实现”。但是不同点在于：简单工厂直接在工厂类里面进行“选择实现”，而工厂方法会把这个工作延迟到子类来实现。

总结

本质：延迟到子类来选择实现。

何时使用工厂方法模式：

如果一个类需要创建某个接口的对象，但是有不知道具体的实现。此时可选用工厂方法模式，把创建对象的工作延迟到子类中实现。
如果一个类本身就希望由它的子类来创建所需的对象的时候，应该使用工厂方法模式。

我的博客：http://shenchao.me/
Github: https://github.com/jerry-sc/designPattern
Reference：《研磨设计模式》