设计模式（一）：工厂模式

概述

工厂模式（Factory Pattern）属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式旨在与解决接口实现类选择这一类问题，让实例创建的代码使用实例的方法解耦。

当我们需要根据不同的明确条件下创建不同的实例的时候，就可以使用工厂模式。

工厂模式分为三类：

• 工厂方法模式：一个工厂生产固定的一个类。
• 简单/静态工厂模式：一个工厂生产固定种类的多个类。
• 抽象工厂模式：一个抽象工厂生产一

一、工厂方法模式

假设我们有一个导出报表的抽象类：

/**
 * 文件导出接口
 */
public abstract class Exporter {
    void export();
}

他现在有一个Excel导出实现类：

/**
 * Excel导出实现类
 */
public class ExcelExporter extend Exporter{
    
    private String modelPath;
    
    private String fileName;
    
    @Override
    public void export() {
        System.out.println("导出Excel:"+"模板路径："+ modelPath +"文件名：" + fileName);
    }
    
    public ExcelExporter(String modelPath, String fileName) {
        this.modelPath = modelPath;
        this.fileName = fileName;
    }
}

现在我们需要在一个方法里去调用它，让客户可以导出报表：

//从配置中读取模板路径
String modelPath = Config.getExcelModelPath();
//获取文件名
String fileName = name + Config.getExcelLastName(); 
ExcelExporter ee = new ExcelExporter(modelPath, fileName);
//一些其他业务逻辑
... ...
ee.export();

我们在很多方法都需要调用这个类，但是每次使用都要写那么多行代码，实在太麻烦，而且万一忽然modelPath或者fileName这些参数要改，那工程量也很让人头痛。

所以我们可以把获取对象的操作提出来，把读取配置路径等方法都单独提出来，最后统一放到一个工厂类里：

/**
 * Excel文件导出实现类的工厂
 */
public class ExcelExporterFactory {
    
    public String getExcelLastName(){
        return Config.getExcelLastName();
    }

    public String getModePath(){
        return Config.getExcelModelPath();
    }

    public ExcelExporter getExporter(String type) {
        return new ExcelExporter(getModePath(),getExcelLastName());
    }
}

最后使用的时候不需要在意实例化的过程，只需要调用方法获取新对象就行了：

ExcelExporterFactory factory = new ExcelExporterFactory();
factory.getExcelExporter().export();

值得一提的是，由于工厂的特殊性，它大多数情况下都是单例的。

不难发现，工厂方法模式有以下优点：

• 1:客户端不需要在负责对象的创建,明确了各个类的职责；
• 2:如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可；
• 3:不会影响已有的代码,后期维护容易,增强系统的扩展性。

二、简单/静态工厂

工厂方法模式确实好，但是有时候我们需要用工厂生产的往往只有特定的几个类，其他的直接new就可以了。这种情况下在为每一个类单独创建一个工厂类太过麻烦，为此我们让一个工厂去生产固定的那几种类，这就是简单/静态工厂。

假设我们目前只需要导出Excel和word类型的报表，我们在上一个例子的基础上再加一WordExporter实现类：

/**
 * Excel导出实现类
 */
public class WordExporter extend Exporter {

    private String modelPath;

    private String fileName;

    @Override
    public void export() {
        System.out.println("导出Word！");
    }

    public WordExporter(String modelPath, String fileName) {
        this.modelPath = modelPath;
        this.fileName = fileName;
    }

}

然后我们改造一下原本的ExcelExporterFactory，让他也能生产WordExporter：

/**
 * 文件导出实现类的简单工厂
 */
public class ExporterFactory {

    public String getExcelLastName(){
        return Config.getExcelLastName();
    }

    public String getModePath(){
        return Config.getExcelModelPath();
    }

    public Exporter getExporter(String type) {
        //根据条件返回对应的实例
        if ("word".equals(type)) {
            return new WordExporter(getModePath(),getExcelLastName());
        } else if ("excel".equals(type)) {
            return new ExcelExporter(getModePath(),getExcelLastName());
        }else {
            throw new RuntimeException("导出类型不存在！");
        }
    }

}

当我们要调用的时候，直接通过工厂调用就可以了：

ExporterFactory factory = new ExporterFactory();
factory.getExcelExporter(type).export();

这个就是简单工厂。

在简单工厂的基础上，我们不难看出，现在的ExporterFactory总是只能生产固定的那几种类，那么其实调用getExporter()去获取实现类的时候根本没必要new一个新工厂。

于是我们将这个工程里的所有方法都变成静态方法，调用的时候就很方便了：

ExportService es = ExporterFactory.getExporter(type);

这个就是静态工厂。

三、抽象工厂模式

简单工厂对工厂方法做了减法，简化了代码结构，但是简单工厂违背了开闭原则，如果要添加新的产品，就需要修改工厂类代码。而传统的工厂方法模式，如果有很多产品的情况下又会创建过多的工厂类。

为此，我们对工厂方法模式做加法，就有了抽象工厂模式：由顶层的抽象工厂提供生产产品的接口，具体的生产过程由继承了抽象工厂的子工厂去实现。

举个例子：

根据上文，我们现在有了Exporter接口，和两个实现类ExcelExporter和WordExporter，现在我们有了新的需求：

导出的报表要分成两种类型：有数据的表格和没有数据的表格。（empty）

1.产品的抽象

我们先对产品进行抽象：

Exporter这个类不管是否有数据，都需要导出方法 export()，然后根据表格是否有数据，还需要一个方法 empty()。

我们将其分为由原本的ExcelExporter和WordExporter也变成抽象类，只实现各种的export()方法，然后再针对ExcelExporter和WordExporter再拆分，得到无数据表格类EmptyExcelExporter，EmptyWordExporter，有数据表格类FullExcelExporter，FullWordExporter。

2.工厂的抽象

由于产品的层级变成了三层，原本用于生产WordExporter和ExcelExporter的工厂ExporterFactory也要进行拆分。

将ExporterFactory变为接口，里面规定了getExcelExporter()和getWordExporter()两个接口方法，然后由EmptyExporterFactory还有FullExporterFactory工厂去

不难看出，抽象工厂通过多了一层抽象，减少了工厂类的数量，但是当要添加一类产品，比如加一个导出PDF类，同样要修改ExporterFactory及其实现类。