工厂方法模式概述

工厂方法模式通过引入抽象的工厂类，是的它具有超越简单工厂模式的优越性，让系统更加符合开闭原则。

定义：

工厂方法模式：定义一个用于创建对象的接口，但是让子类决定将那个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

工厂方法模式简称为工厂模式，又可称为虚拟构造器模式或多态工厂模式。工厂方法模式是一种类创建型模式。

在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类负责生成具体的产品对象。

工厂方法模式的结构与实现

工厂方法模式的结构

组成（角色） 关系 作用
抽象产品（Product） 具体产品的父类 描述具体产品的公共接口
具体产品（Concrete Product） 抽象产品的子类；工厂类创建的目标类 描述生产的具体产品
抽象工厂（Creator） 具体工厂的父类 描述具体工厂的公共接口
具体工厂（Concrete Creator） 抽象工厂的子类；被外界调用 描述具体工厂；实现FactoryMethod工厂方法创建产品的实例

a79ecabd63cbfb32399569bcd73e4963.png

工厂方法模式的实现

以下通过“形状生成”场景展示工厂方法模式的实现，新增产品时无需修改原有代码，只需扩展新的工厂和产品类。

1. 抽象产品：Shape接口

定义所有形状的公共行为：

// 抽象产品：形状接口
public interface Shape {
    void draw(); // 绘制方法
}

2. 具体产品：实现抽象产品

创建两种具体形状（可扩展更多）

// 具体产品：圆形
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形（工厂方法模式）");
    }
}
 
// 具体产品：方形
public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制方形（工厂方法模式）");
    }
}

3. 抽象工厂：ShapeFactory接口

声明创建产品的抽象方法：

// 抽象工厂：形状工厂接口
public interface ShapeFactory {
    Shape createShape(); // 抽象方法：创建形状
}

4. 具体工厂：对应具体产品

每个具体工厂负责创建一种产品：

// 具体工厂：圆形工厂
public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle(); // 返回圆形实例
    }
}
 
// 具体工厂：方形工厂
public class SquareFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Square(); // 返回方形实例
    }
}

5. 客户端调用

通过具体工厂获取产品，无需依赖具体产品类：

// 客户端测试类
public class Client {
    public static void main(String[] args) {
        // 使用圆形工厂创建圆形
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // 输出：绘制圆形（工厂方法模式）
  
        // 使用方形工厂创建方形
        ShapeFactory squareFactory = new SquareFactory();
        Shape square = squareFactory.createShape();
        square.draw(); // 输出：绘制方形（工厂方法模式）
    }
}

工厂方法的重载

在某些情况下，可以通过多种方法来初始化同一个产品类。

抽象工厂：IDocumentFactory

定义重载的工厂方法，支持不同配置的文档创建：

// 抽象工厂：文档工厂接口（含重载方法）
public interface IDocumentFactory {
    // 重载1：默认配置（不加密+A4页面）
    IDocument createDocument();
 
    // 重载2：指定是否加密（默认A4页面）
    IDocument createDocument(boolean encrypted);
 
    // 重载3：指定加密状态+页面大小
    IDocument createDocument(boolean encrypted, String pageSize);
}

具体工厂：Word/PDF工厂

实现抽象工厂的重载方法，创建对应配置的文档：

// 具体工厂：Word文档工厂
public class WordFactory implements IDocumentFactory {
    @Override
    public IDocument createDocument() {
        // 默认配置：不加密+A4
        return new WordDocument(false, "A4");
    }
 
    @Override
    public IDocument createDocument(boolean encrypted) {
        // 指定加密，默认A4
        return new WordDocument(encrypted, "A4");
    }
 
    @Override
    public IDocument createDocument(boolean encrypted, String pageSize) {
        // 完全自定义配置
        return new WordDocument(encrypted, pageSize);
    }
}
 
// 具体工厂：PDF文档工厂
public class PdfFactory implements IDocumentFactory {
    @Override
    public IDocument createDocument() {
        return new PdfDocument(false, "A4");
    }
 
    @Override
    public IDocument createDocument(boolean encrypted) {
        return new PdfDocument(encrypted, "A4");
    }
 
    @Override
    public IDocument createDocument(boolean encrypted, String pageSize) {
        return new PdfDocument(encrypted, pageSize);
    }
}

工厂方法的隐藏

有时候，为了进一步简化简化客户端的使用，还可以对客户端隐藏工厂方法，此时，在工厂类中直接调用产品类的业务方法，客户端无需调用工厂方法创建产品对象，直接使用工厂对象即可调用所创建的产品对象中的业务方法。

与传统工厂方法的区别：

  • 传统模式：客户端 → 工厂.createProduct() → 获取产品 → 调用产品方法。
  • 隐藏模式：客户端 → 工厂.业务方法 → 工厂内部创建产品并执行功能 → 返回结果。

定义产品接口与具体产品

// 产品接口：定义核心功能
interface DataProcessor {
    String process(String input); // 业务方法：处理数据
}
 
// 具体产品1：JSON格式处理
class JsonProcessor implements DataProcessor {
    @Override
    public String process(String input) {
        return "JSON结果：" + input.toUpperCase();
    }
}
 
// 具体产品2：XML格式处理
class XmlProcessor implements DataProcessor {
    @Override
    public String process(String input) {
        return "XML结果：" + input.toLowerCase();
    }
}

定义工厂接口（代理产品方法）

工厂接口不再暴露 createProduct，而是直接提供业务方法：

// 工厂接口：代理产品的业务方法
interface ProcessorFactory {
    String handleData(String input); // 代理DataProcessor的process方法
}

实现具体工厂类

工厂内部创建产品并转发业务调用：

// 具体工厂1：JSON处理工厂
class JsonFactory implements ProcessorFactory {
    private DataProcessor processor;
 
    public JsonFactory() {
        this.processor = new JsonProcessor(); // 内部创建产品
    }
 
    @Override
    public String handleData(String input) {
        return processor.process(input); // 代理产品方法
    }
}
 
// 具体工厂2：XML处理工厂
class XmlFactory implements ProcessorFactory {
    private DataProcessor processor;
 
    public XmlFactory() {
        this.processor = new XmlProcessor();
    }
 
    @Override
    public String handleData(String input) {
        return processor.process(input);
    }
}

客户端调用（无感知产品）

public class Client {
    public static void main(String[] args) {
        // 客户端仅与工厂交互，无需知道DataProcessor的存在
        ProcessorFactory factory = new JsonFactory();
        System.out.println(factory.handleData("hello")); // 输出：JSON结果：HELLO
  
        // 切换产品只需更换工厂，客户端代码不变
        factory = new XmlFactory();
        System.out.println(factory.handleData("HELLO")); // 输出：XML结果：hello
    }
}

工厂方法模式优缺点与适用环境

工厂方法模式是简单工厂模式的延伸，它继承了简单工厂模式的优点，同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一，是很多开源框架和API类库的核心模式。

1、 主要优点

(1) 在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无须关心创建细节，甚至无须知道具体产品类的类名。
(2) 基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，就正是因为所有的具体工厂类都具有同一抽象父类。
(3) 使用工厂方法模式的另一个优点是在系统中加入新产品时，无须修改抽象工厂和抽象产品提供的接口，无须修改客户端，也无须修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则。

2、 主要缺点

(1) 在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
(2) 由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。

3、 适用场景

在以下情况下可以考虑使用工厂方法模式：
(1) **客户端不知道它所需要的对象的类。**在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建，可将具体工厂类的类名存储在配置文件或数据库中。
(2) **抽象工厂类通过其子类来指定创建哪个对象。**在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。