原博文：https://blog.****.net/KongZhongNiao/article/details/79663853

定义

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

结构和说明

• Product：定义工厂方法所创建的对象的接口，也就是实际需要使用的对象的接口
• ConcreteProduct：具体的Product接口的实现对象。
• Creator：创建器，声明工厂方法
• ConcreteCreator：具体的创建器对象，覆盖实现Creator定义的工厂方法，返回具体的Product实例

示例代码

工厂方法所创建的对象的接口

package cn.javass.dp.factorymethod.example2;
/**
 * 工厂方法所创建的对象的接口
 */
public interface Product {
    //可以定义Product的方法
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

具体的Product对象

package cn.javass.dp.factorymethod.example2;
/**
 * 具体的Product对象
 */
public class ConcreteProduct implements Product {
    //实现Product要求的方法
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8

创建器，声明工厂方法

package cn.javass.dp.factorymethod.example2;
/**
 * 创建器，声明工厂方法
 */
public abstract class Creator {
    /**
     * 创建Product的工厂方法
     * @return Product对象
     */
    protected abstract Product factoryMethod();
    /**
     * 示意方法，实现某些功能的方法 
     */
    public void someOperation() {
        //通常在这些方法实现中，需要调用工厂方法来获取Product对象
        Product product = factoryMethod();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

具体的创建器实现对象

package cn.javass.dp.factorymethod.example2;
/**
 * 具体的创建器实现对象
 */
public class ConcreteCreator extends Creator {
    public Product factoryMethod() {
        //重定义工厂方法，返回一个具体的Product对象
        return new ConcreteProduct();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

体会工厂方法模式

导出数据的应用框架

考虑这样一个实际应用：实现一个导出数据的应用框架，来让客户选择数
据的导出方式，并真正执行数据导出。
通常这种系统，在导出数据上，会有一些约定的方式，比如导出成：文本
格式、数据库备份形式、Excel格式、Xml格式等等。

不用模式的解决方案

直接参看代码示例

导出的文件对象的接口

package cn.javass.dp.factorymethod.example1;
/**
 * 导出的文件对象的接口
 */
public interface ExportFileApi {
    /**
     * 导出内容成为文件
     * @param data 示意：需要保存的数据
     * @return 是否导出成功
     */
    public boolean export(String data);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

导出成文本文件格式的对象

package cn.javass.dp.factorymethod.example1;
/**
 * 导出成文本文件格式的对象
 */
public class ExportTxtFile implements ExportFileApi{
    public boolean export(String data) {
        //简单示意一下，这里需要操作文件
        System.out.println("导出数据"+data+"到文本文件");
        return true;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

导出成xml格式的对象

package cn.javass.dp.factorymethod.example1;
/**
 * 导出成xml格式的对象
 */
public class ExportXmlFile implements ExportFileApi{
    public boolean export(String data) {
        //简单示意一下，这里需要操作文件
        System.out.println("导出数据"+data+"到xml文件");
        return true;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

导出成数据库备份文件形式的对象

package cn.javass.dp.factorymethod.example1;
/**
 * 导出成数据库备份文件形式的对象
 */
public class ExportDB implements ExportFileApi{
    public boolean export(String data) {
        //简单示意一下，这里需要操作数据库和文件
        System.out.println("导出数据"+data+"到数据库备份文件");
        return true;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

实现导出数据的业务功能对象

package cn.javass.dp.factorymethod.example1;
/**
 * 实现导出数据的业务功能对象
 */
public class ExportOperate {
    /**
     * 导出文件
     * @param type 用户选择的导出类型
     * @param data 需要保存的数据
     * @return 是否成功导出文件
     */
    public boolean export(int type,String data){
        //先完成各种导出数据前的准备工作
        //比如进行数据校验
        System.out.println("now 进行数据校验");
        //比如进行数据转换
        System.out.println("now 进行数据转换");
        //比如进行数据格式的封装
        System.out.println("now 进行数据格式的封装");

        //然后才真正的去导出
        ExportFileApi api = ;
        //根据类型来选择究竟要创建哪一种导出文件对象
        if(type == 1){
            api = new ExportTxtFile();
        }else if(type == 2){
            api = new ExportDB();
        }else if(type==3){
            api = new ExportXmlFile();
        }
        return api.export(data);
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35

客户端

package cn.javass.dp.factorymethod.example1;

public class Client {
    public static void main(String[] args) {
        ExportOperate operate = new ExportOperate();
        operate.export(1, "要导出的测试数据");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

存在的问题

对于实现导出数据的业务功能对象，它需要创建ExportFileApi的具体实例
对象，但是它只知道ExportFileApi接口，而不知道其具体的实现。那该怎么办
呢？

使用模式的解决方案

直接参看代码示例

其他的不变，添加一些实现

实现导出数据的业务功能对象

package cn.javass.dp.factorymethod.example3;
/**
 * 实现导出数据的业务功能对象
 */
public abstract class ExportOperate {
    public ABC createABC(String name){
        return new ABC(name,factoryMethod());
    }

    /**
     * 导出文件
     * @param data 需要保存的数据
     * @return 是否成功导出文件
     */
    public boolean export(String data){
        //先完成各种导出数据前的准备工作
        //比如进行数据校验
        System.out.println("now 进行数据校验");
        //比如进行数据转换
        System.out.println("now 进行数据转换");
        //比如进行数据格式的封装
        System.out.println("now 进行数据格式的封装");

        //然后才真正的去导出

        //使用工厂方法
        ExportFileApi api = factoryMethod();

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

    //既要约束子类的行为，又要为子类提供公共的功能
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40

具体的创建器实现对象，实现创建导出成文本文件格式的对象

package cn.javass.dp.factorymethod.example3;
/**
 * 具体的创建器实现对象，实现创建导出成文本文件格式的对象
 */
public class ExportTxtFileOperate extends ExportOperate{

    protected ExportFileApi factoryMethod() {
        //创建导出成文本文件格式的对象
        return new ExportTxtFile();
    }

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

实现创建导出成xml格式的对象

package cn.javass.dp.factorymethod.example3;
/**
 * 导出成文本文件格式的对象
 */
public class ExportXmlFileOperate extends ExportOperate{

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

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

具体的创建器实现对象，实现创建导出成数据库备份文件形式的对象

package cn.javass.dp.factorymethod.example3;
/**
 * 具体的创建器实现对象，实现创建导出成数据库备份文件形式的对象
 */
public class ExportDBOperate extends ExportOperate{
    protected ExportFileApi factoryMethod() {
        //创建导出成数据库备份文件形式的对象
        return new ExportDB();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

客户端

package cn.javass.dp.factorymethod.example3;

public class Client {
    public static void main(String[] args) {
//      //创建需要使用的Creator对象
        ExportOperate operate = new ExportXmlFileOperate();
        //调用输出数据的功能方法
        operate.export("测试数据");

//      ABC abc = new ExportOperate().createABC("cc");

//      abc.test();
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15

理解工厂方法模式

认识工厂方法模式

1：工厂方法模式的功能

工厂方法的主要功能是让父类在不知道具体实现的情况下，完成自身的功
能调用，而具体的实现延迟到子类来实现。

2：实现成抽象类

工厂方法的实现中，通常父类会是一个抽象类，里面包含创建所需对象的抽象方
法，这些抽象方法就是工厂方法

3：实现成具体的类

也可以把父类实现成为一个具体的类，这种情况下，通常是在父类中提供获取所
需对象的默认实现方法，这样就算没有具体的子类，也能够运行。

4：工厂方法的参数和返回值

工厂方法的实现中，可能需要参数，以便决定到底选用哪一种具体的实现。
一般工厂方法返回的是被创建对象的接口对象，当然也可以是抽象类或者一个具
体的类的实例。

5：谁来使用工厂方法创建的对象

• （1）在工厂方法模式里面，应该是Creator中的其它方法在使用工厂方法创建的
  对象
• （2）客户端应该是使用Creator对象，或者是使用由Creator创建出来的对象，
  这个时候工厂方法创建的对象，是Creator中的某些方法使用。

• （3）在某些情况下，客户端可能会使用由Creator创建出来的对象，这个时候工
  厂方法创建的对象，是构成客户端需要的对象的一部分。

• 小结一下：在工厂方法模式里面，客户端要么使用Creator对象，要么使用
  Creator创建的对象，一般客户端不直接使用工厂方法。当然也可以直接把工厂
  方法暴露给客户端操作，但是一般不这么做。

工厂方法模式的调用顺序示意图

先看看客户端使用由Creator创建出来的对象情况的调用顺序示意图

接下来看看客户端使用Creator对象时候的调用顺序示意图

工厂方法模式与IoC/DI

1：概念

• 依赖注入：应用程序依赖容器创建并注入它所需要的外部资源
• 控制反转：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的
  外部资源。

2：理解

• (1)参与者都有谁？
• (2)依赖：谁依赖于谁？为什么需要依赖？
• (3)注入：谁注入于谁？到底注入什么？
• (4)控制反转：谁控制谁？控制什么？为何叫反转（有反转就应该有正转了）？
• (5)依赖注入和控制反转是同一概念吗？

3：过程

没有IoC/DI的时候，常规的A类使用C类的示意图

有了IoC/DI的容器后，A类不再主动去创建C了

而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向的注入到A类中

4：思想

其实IoC/DI对编程带来的最大改变不是从代码上，而是从思想上，发生了
“==主从换位==”的变化。应用程序原本是老大，要获取什么资源都是主动出击，但
是在IoC/DI思想中，应用程序就变成被动的了，被动的等待IoC/DI容器来创建并
注入它所需要的资源了。

这么小小的一个改变其实是编程思想的一个大进步，这样就有效的分离了
对象和它所需要的外部资源，使得它们松散耦合，有利于功能复用，更重要的是
使得程序的整个体系结构变得非常灵活。

工厂方法模式和IoC/DI的关系

他们的思想很类似，都是“主动变被动”，进行“主从换位”，从而获得更灵活
的程序结构

平行的类层次结构

（1）什么是平行的类层次结构呢？

简单点说，假如有两个类层次结构，其中一个类层次中的每个类在另一个
类层次中都有一个对应的类的结构，就被称为平行的类层次结构。

2）这种平行的类层次结构用来干什么呢？

主要用来把一个类层次中的某些行为分离出来，让类层次中的类把原本属
于自己的职责，委托给分离出来的类去实现，从而使得类层次本身变得更简单，
更容易扩展和复用。

（3）工厂方法模式跟平行的类层次结构有何关系呢？

可以使用工厂方法模式来连接平行的类层次。

看上面的示例图，在每个硬盘对象里面，都有一个工厂方法
createHDOperate，通过这个工厂方法，客户端就可以获取一个跟硬盘对象相对
应的行为对象。

参数化工厂方法

所谓参数化工厂方法指的就是：通过给工厂方法传递参数，让工厂方法根
据参数的不同来创建不同的产品对象

（1）先看代码示例

参数工厂

package cn.javass.dp.factorymethod.example7;

public class MyFactory {
    private MyFactory(){

    }
    public static ExportFileApi factoryMethod(int type){
        ExportFileApi api = ;
        //根据类型来选择究竟要创建哪一种导出文件对象
        if(type==1){
            api = new ExportTxtFile();
        }else if(type==2){
            api = new ExportDB();
        }
        return api;
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

实现导出数据的业务功能对象

package cn.javass.dp.factorymethod.example7;
/**
 * 实现导出数据的业务功能对象
 */
public class ExportOperate {
    /**
     * 导出文件
     * @param type 用户选择的导出类型
     * @param data 需要保存的数据
     * @return 是否成功导出文件
     */
    public boolean export(int type,String data){
        //使用工厂方法
        ExportFileApi api = MyFactory.factoryMethod(type);
        return api.export(data);
    }
    /**
     * 工厂方法，创建导出的文件对象的接口对象
     * @param type 用户选择的导出类型
     * @return 导出的文件对象的接口对象
     */

}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

扩展ExportOperate对象，加入可以导出XML文件

package cn.javass.dp.factorymethod.example7;
/**
 * 扩展ExportOperate对象，加入可以导出XML文件
 */
public class ExportOperate2 extends ExportOperate{
    /**
     * 覆盖父类的工厂方法，创建导出的文件对象的接口对象
     * @param type 用户选择的导出类型
     * @return 导出的文件对象的接口对象
     */
//  protected ExportFileApi factoryMethod(int type){
//      ExportFileApi api = null;
//      //可以全部覆盖，也可以选择自己感兴趣的覆盖，
//      //这里只想添加自己新的实现，其他的不管
//      if(type==3){
//          api = new ExportXml();
//      }else{
//          //其他的还是让父类来实现
//          api = super.factoryMethod(type); 
//      }
//      return api; 
//  }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

客户端

package cn.javass.dp.factorymethod.example7;

public class Client {
    public static void main(String[] args) {
        //创建需要使用的Creator对象
//      ExportOperate operate = new ExportOperate();
//      //调用输出数据的功能方法，传入选择到处类型的参数
//      operate.export(1,"测试数据");

        //创建需要使用的Creator对象
        ExportOperate operate = new ExportOperate2();
//      //下面变换传入的参数来测试参数化工厂方法
//      operate.export(1,"Test1");
//      operate.export(2,"Test2");
//      operate.export(3,"Test3");
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19

（2）再体会一下，当需要扩展新的实现，使用参数化工厂方法，扩展起来会常容易

工厂方法模式的优缺点

• 1：可以在不知具体实现的情况下编程
• 2：更容易扩展对象的新版本
• 3：连接平行的类层次

- 4：具体产品对象和工厂方法的耦合性

思考工厂方法模式

工厂方法模式的本质

工厂方法模式的本质是：延迟到子类来选择实现

对设计原则的体现

工厂方法模式很好的体现了“依赖倒置原则”。
依赖倒置原则告诉我们“要依赖抽象，不要依赖于具体类”，简单点说就
是：不能让高层组件依赖于低层组件，而且不管高层组件还是低层组件，都应该
依赖于抽象。

何时选用工厂方法模式

• 1：如果一个类需要创建某个接口的对象，但是又不知道具体的实现，这种情况可以
  选用工厂方法模式，把创建对象的工作延迟到子类去实现
• 2：如果一个类本身就希望，由它的子类来创建所需的对象的时候，应该使用工厂方
  法模式