设计模式之工厂方法模式

工厂方法模式（Factory Method）是一种创建型设计模式，用于定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。通过这种方式，工厂方法模式将对象的创建过程延迟到子类，从而使得设计更加灵活，易于扩展和维护。在软件开发过程中，特别是在面向对象编程中，工厂方法模式被广泛应用于减少代码耦合、提高代码复用性和增强系统的可维护性。

使用场景

工厂方法模式在以下几种情况下特别有用：

1. 避免直接实例化类： 当你不希望直接实例化一个类时，可以使用工厂方法模式来创建对象。这有助于避免代码中大量的 new 操作，使得代码更具弹性和可扩展性。
2. 复杂的对象构建过程： 如果对象的创建过程非常复杂，不想将复杂的构建逻辑重复写在需要实例化对象的地方，可以使用工厂方法模式将创建逻辑集中在一个地方，简化代码的维护。
3. 对象构建过程中依赖其他类： 当对象的创建依赖于很多其他类，而这些类的实例在调用的地方无法提供时，可以使用工厂方法模式来集中管理这些依赖关系。

主要角色

工厂方法模式涉及以下几个主要角色：

1. 抽象产品（Abstract Product）： 定义了产品的接口，是具体产品类的父类或接口。
2. 具体产品（Concrete Product）： 实现了抽象产品接口的具体类，是最终被工厂方法创建的对象。
3. 抽象工厂（Abstract Factory）： 声明了工厂方法，用于返回一个抽象产品。
4. 具体工厂（Concrete Factory）： 实现了抽象工厂接口，并且具体实现了创建对象的方法。

类图

示例代码

接下来，通过一个创建计算机对象的示例，详细讲解工厂方法模式的实现。

抽象产品类

首先定义一个抽象产品类 Computer：

@Data
public abstract class Computer {
    protected String brand;
    protected String operationSystem;
}

具体产品类

定义具体产品类 Computer4Mac 和 Computer4Mi：

public class Computer4Mac extends Computer {
    public Computer4Mac() {
        this.brand = "Mac";
        this.operationSystem = "Mac操作系统";
    }
}
```java
public class Computer4Mi extends Computer {
    public Computer4Mi() {
        this.brand = "小米";
        this.operationSystem = "小米操作系统";
    }
}

抽象工厂接口

定义抽象工厂接口 ComputerFactory：

public interface ComputerFactory {
    Computer makeComputer();
}

具体工厂类

实现具体工厂类 ComputerFactory4Mac 和 ComputerFactory4Mi：

public class ComputerFactory4Mac implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new Computer4Mac();
    }
}
```java
public class ComputerFactory4Mi implements ComputerFactory {
    @Override
    public Computer makeComputer() {
        return new Computer4Mi();
    }
}

客户端代码

最后，在客户端代码中使用工厂方法模式来创建计算机对象：

public class Client {
    public static void main(String[] args) {
        // 生产Mac电脑
        ComputerFactory macFactory = new ComputerFactory4Mac();
        Computer computer4Mac = macFactory.makeComputer();
        System.out.println("computer4Mac = " + computer4Mac);

        // 生产小米电脑
        ComputerFactory miFactory = new ComputerFactory4Mi();
        Computer computer4mi = miFactory.makeComputer();
        System.out.println("computer4mi = " + computer4mi);
    }
}

工厂方法模式的优缺点

优点

1. 代码解耦： 工厂方法模式通过工厂接口创建对象，避免了客户端直接依赖具体产品类，降低了代码的耦合度。
2. 增强代码的可扩展性： 新增产品时，只需增加具体的产品类和对应的工厂类，符合开闭原则（OCP，Open/Closed Principle）。
3. 集中管理对象创建： 将对象创建集中在一个地方，便于维护和管理，尤其是对象创建过程较为复杂时。

缺点

1. 类的数量增加： 由于每个具体产品需要一个对应的工厂类，导致系统中类的数量增加，增加了代码的复杂性。
2. 增加系统的抽象性： 工厂方法模式引入了额外的抽象层次，可能会使系统结构变得更复杂，理解和调试难度增加。

应用实例

日志记录器

假设我们需要实现一个日志记录器，根据不同的日志类型（如文件日志、数据库日志）创建不同的日志记录器，可以使用工厂方法模式来实现：

// 抽象产品
public interface Logger {
    void log(String message);
}

// 具体产品
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to a file: " + message);
    }
}

public class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to a database: " + message);
    }
}

// 抽象工厂
public interface LoggerFactory {
    Logger createLogger();
}

// 具体工厂
public class FileLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new DatabaseLogger();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        LoggerFactory fileLoggerFactory = new FileLoggerFactory();
        Logger fileLogger = fileLoggerFactory.createLogger();
        fileLogger.log("This is a file log message.");

        LoggerFactory databaseLoggerFactory = new DatabaseLoggerFactory();
        Logger databaseLogger = databaseLoggerFactory.createLogger();
        databaseLogger.log("This is a database log message.");
    }
}

GUI控件库

假设我们需要实现一个GUI控件库，根据操作系统的不同创建不同风格的按钮，可以使用工厂方法模式来实现：

// 抽象产品
public interface Button {
    void render();
}

// 具体产品
public class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering a button in Windows style.");
    }
}

public class MacOSButton implements Button {
    @Override
    public void render() {
        System.out.println("Rendering a button in MacOS style.");
    }
}

// 抽象工厂
public interface ButtonFactory {
    Button createButton();
}

// 具体工厂
public class WindowsButtonFactory implements ButtonFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
}

public class MacOSButtonFactory implements ButtonFactory {
    @Override
    public Button createButton() {
        return new MacOSButton();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ButtonFactory windowsFactory = new WindowsButtonFactory();
        Button windowsButton = windowsFactory.createButton();
        windowsButton.render();

        ButtonFactory macFactory = new MacOSButtonFactory();
        Button macButton = macFactory.createButton();
        macButton.render();
    }
}

工厂方法模式与其他设计模式的关系

1. 简单工厂模式： 简单工厂模式是工厂方法模式的简化版，使用一个静态方法根据传入的参数决定创建哪种具体产品。简单工厂模式违背了开闭原则，不如工厂方法模式灵活。
2. 抽象工厂模式： 抽象工厂模式提供了一个接口，用于创建一系列相关或互相依赖的对象，而不指定具体类。它通常与工厂方法模式一起使用，以实现更加复杂的对象创建逻辑。
3. 建造者模式： 建造者模式关注于如何一步一步构建一个复杂对象，而工厂方法模式则关注于通过接口创建对象。建造者模式更适合需要多个步骤创建复杂对象的情况。

结论

工厂方法模式通过定义创建对象的接口并将对象的创建延迟到子类，从而提供了一种灵活的对象创建方式。它在许多实际应用场景中都能发挥重要作用，如日志记录、GUI控件创建等。尽管工厂方法模式增加了系统的复杂性，但它显著提高了系统的扩展性和可维护性，使得代码更加模块化和可重用。在实际开发中，根据具体情况选择合适的设计模式，可以显著提高代码质量和开发效率。