【创建型设计模式】工厂模式

创建型设计模式第二期！本期介绍简单工厂模式和工厂方法模式。

简单工厂模式

简单工厂模式（又叫作静态工厂方法模式），其属于创建型设计模式，简单工厂模式不属于设计模式中的 23 种经典模式。提到它是为了让大家能够更好地理解后面讲到的工厂方法模式。

定义：简单工厂模式属于创建型设计模式，其又被称为静态工厂方法模式，这是由一个工厂对象决定创建出哪一种产品类的实例。

简单工厂模式通过工厂类的静态方法，根据传入的参数创建并返回不同的产品对象。

在简单工厂模式中有如下角色：

• Factory: 工厂类，这是简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
• Product: 抽象产品类，这是简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
• Product: 具体产品类，这是简单工厂模式的创建目标。

省流：

工厂类（Factory）：负责创建具体产品实例的类。

抽象产品（Product）：所有具体产品的父类或接口。

具体产品（Concrete Product）：工厂类所创建的具体对象。

1. 简单工厂模式的简单实现

这里我们用生产计算机来举例，假设有一个计算机的代工生产商，它目前已经可以代工生产联想计算机了。随着业务的拓展，这个代工生产商还要生产惠普和华硕的计算机。这样我们就需用一个单独的类来专门生产计算机，这就用到了简单工厂模式，下面我们来实现简单工厂模式。

（1）抽象产品类 (Shape 接口)

// 抽象产品
public interface Shape {
    void draw();
}

目的：

定义统一的产品接口，所有具体产品都必须实现该接口。

面向接口编程：客户端只需要知道 Shape 的接口，而不需要关心具体实现。

优点：

增强了代码的灵活性，客户端可以通过 Shape 类型调用 draw 方法，减少对具体类的依赖。

（2）具体产品类(Circle, Rectangle, Triangle 类)

// 圆形
public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle");
    }
}

// 矩形
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle");
    }
}

// 三角形
public class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Triangle");
    }
}

目的：

这些类是具体实现，负责实现抽象产品 (Shape) 中的接口方法。

每个具体产品有其独特的行为逻辑。例如，Circle.draw 可能涉及圆的特定绘制逻辑。

优点：

将每个形状的行为封装在独立的类中，满足单一职责原则。

（3）工厂类(ShapeFactory)

// 工厂类
public class ShapeFactory {
    public static Shape createShape(String shapeType) {
        if ("circle".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("rectangle".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        } else if ("triangle".equalsIgnoreCase(shapeType)) {
            return new Triangle();
        } else {
            throw new IllegalArgumentException("Unknown shape type: " + shapeType);
        }
    }
}

目的：

封装对象创建逻辑：工厂类中定义了如何根据传入参数决定返回哪种 Shape 对象。

隐藏具体实现：客户端无需知道具体类名，只需通过简单的字符串参数即可获得对象实例。

实现细节：

静态方法 createShape：接收一个字符串 shapeType，通过条件判断实例化对应的 Shape 对象。

错误处理：如果传入的 shapeType 无法匹配现有的类型，则抛出 IllegalArgumentException，确保程序不会意外运行。

优点：

客户端与具体实现解耦，符合 依赖倒置原则。

通过集中管理对象创建逻辑，可以减少冗余代码。

缺点：

每增加一种产品，都需要修改 ShapeFactory 的代码，违反了 开闭原则。

（4）客户端调用工厂类

public class Main {
    public static void main(String[] args) {
        // 使用工厂创建对象
        Shape circle = ShapeFactory.createShape("circle");
        circle.draw();

        Shape rectangle = ShapeFactory.createShape("rectangle");
        rectangle.draw();

        Shape triangle = ShapeFactory.createShape("triangle");
        triangle.draw();
    }
}

功能：

客户端通过 ShapeFactory 的静态方法获取具体的 Shape 对象。

无需直接调用 new Circle() 或 new Rectangle()，只需提供字符串参数即可完成对象的创建。

优点：

客户端的代码更简洁，只需与 ShapeFactory 和 Shape 接口交互。

隐藏了对象的具体实现，降低了耦合性。

2. 使用简单工厂模式的场景和优缺点

1. 客户端不需要关心对象创建的复杂过程

如果对象的创建涉及复杂的逻辑或依赖大量配置参数，而客户端只关心最终的产品实例，则可以使用简单工厂模式。

示例：日志记录系统根据参数返回文件日志、数据库日志、或控制台日志实例。

2. 产品种类有限且变化不频繁

当需要创建的产品种类数量较少，且不需要频繁扩展或修改时，简单工厂是一个快速实现的选择。

示例：为小型电商系统创建不同类型的支付方式（如支付宝、微信支付、信用卡支付）。

3. 需要在运行时动态决定使用哪个产品

当具体产品的选择需要根据运行时的条件决定，而这些条件可以通过参数来表示时，简单工厂模式非常适用。

示例：根据文件类型（如 .txt, .pdf）返回相应的文件解析器对象。

工厂方法模式

工厂方法模式（Factory Method Pattern）是一种 创建型设计模式，它通过定义一个抽象的工厂接口，由子类决定具体实例化的产品对象，从而让对象的创建延迟到子类中进行。

在工厂方法模式中有如下角色：

抽象工厂（Factory Interface/Abstract Factory）：

• 定义工厂的通用接口，提供一个用于创建产品的方法。

具体工厂（Concrete Factory）：

• 实现抽象工厂接口，负责具体产品的实例化。

抽象产品（Product Interface/Abstract Product）：

• 定义产品的公共接口，确保不同的产品有相同的行为。

具体产品（Concrete Product）：

• 实现抽象产品接口，提供具体的产品功能。

工厂方法模式的优缺点

优点

符合开闭原则：

• 增加新产品时，只需添加对应的具体工厂类，而无需修改已有代码。

高内聚低耦合：

• 客户端依赖于抽象工厂和抽象产品，减少了对具体实现的耦合。

代码更灵活：

• 客户端可以通过切换具体工厂来获得不同的产品实例，而无需更改业务代码。

缺点

增加了系统复杂度：

• 每增加一种产品，就需要增加一个具体工厂类，类的数量会随着产品类型的增加而增加。

不适合产品种类较少的场景：

• 如果产品种类较少，使用工厂方法模式可能会导致代码结构过于冗长。

工厂方法模式的简单实现

工厂方法模式的抽象产品类与具体产品类的创建和简单工厂模式是一样的。

（1）创建抽象工厂

// 抽象工厂接口
public interface ParserFactory {
    DocumentParser createParser();
}

（2）创建具体工厂

// Word 文档解析器工厂
public class WordParserFactory implements ParserFactory {
    @Override
    public DocumentParser createParser() {
        return new WordParser();
    }
}

// PDF 文档解析器工厂
public class PdfParserFactory implements ParserFactory {
    @Override
    public DocumentParser createParser() {
        return new PdfParser();
    }
}

（3）抽象产品

// 抽象产品接口
public interface DocumentParser {
    void parse(String content);
}

（4）具体产品

// Word 文档解析器
public class WordParser implements DocumentParser {
    @Override
    public void parse(String content) {
        System.out.println("Parsing Word document: " + content);
    }
}

// PDF 文档解析器
public class PdfParser implements DocumentParser {
    @Override
    public void parse(String content) {
        System.out.println("Parsing PDF document: " + content);
    }
}

（5）客户端代码

public class Main {
    public static void main(String[] args) {
        // 使用工厂方法创建解析器
        ParserFactory wordFactory = new WordParserFactory();
        DocumentParser wordParser = wordFactory.createParser();
        wordParser.parse("This is a Word document");

        ParserFactory pdfFactory = new PdfParserFactory();
        DocumentParser pdfParser = pdfFactory.createParser();
        pdfParser.parse("This is a PDF document");
    }
}

工厂方法模式与简单工厂模式

特性	简单工厂模式	工厂方法模式
创建逻辑	由单一工厂类负责，集中管理创建逻辑	每个具体工厂负责创建特定类型的产品
扩展性	修改工厂类即可扩展产品，但违反开闭原则	添加新产品时只需添加新的工厂类，符合开闭原则
适用场景	产品种类较少，变化不频繁	产品种类较多，变化频繁，需要满足扩展性要求
类的复杂度	工厂类单一，代码量少	增加每种产品时需要增加对应的工厂类，类的数量较多
客户端与工厂的关系	客户端依赖于具体的工厂类	客户端依赖于抽象工厂，屏蔽具体实现细节