Java 工厂模式：告别硬编码，拥抱灵活可扩展设计

在 Java 开发中，我们经常需要创建各种对象。如果直接在代码中使用 new 关键字，会导致代码高度耦合，难以维护和扩展。想象一下，如果你的系统依赖于具体的数据库连接对象，而未来需要切换到另一种数据库，你就需要修改大量的代码。Java设计模式之工厂模式正是解决这类问题的利器。它可以将对象的创建过程封装起来，客户端只需要知道工厂的名称，而无需关心具体的对象创建细节。

问题场景：硬编码的数据库连接

假设我们有一个数据访问层（DAO），需要根据不同的数据库类型创建不同的数据库连接对象。最初的代码可能是这样的：

public class DataAccess {
    public Connection getConnection(String dbType) {
        if ("mysql".equals(dbType)) {
            return new MySqlConnection(); // 硬编码 MySQL 连接
        } else if ("oracle".equals(dbType)) {
            return new OracleConnection(); // 硬编码 Oracle 连接
        } else {
            throw new IllegalArgumentException("Unsupported database type: " + dbType);
        }
    }
}

class MySqlConnection implements Connection {
    // MySQL 连接实现
}

class OracleConnection implements Connection {
    // Oracle 连接实现
}

interface Connection {
    // 定义连接接口
}

这种方式存在以下问题：

• 代码高度耦合：DataAccess 类直接依赖于 MySqlConnection 和 OracleConnection。
• 可扩展性差：如果需要添加新的数据库类型，需要修改 DataAccess 类的代码。
• 维护困难：修改一个数据库连接的实现，可能会影响到其他使用 DataAccess 的地方。

工厂模式解决方案

为了解决上述问题，我们可以使用工厂模式。工厂模式的核心思想是定义一个工厂接口，用于创建对象。具体的工厂类实现该接口，负责创建特定类型的对象。

简单工厂模式

首先，我们来看一下简单工厂模式的实现：

public class ConnectionFactory {
    public static Connection createConnection(String dbType) {
        if ("mysql".equals(dbType)) {
            return new MySqlConnection();
        } else if ("oracle".equals(dbType)) {
            return new OracleConnection();
        } else {
            throw new IllegalArgumentException("Unsupported database type: " + dbType);
        }
    }
}

// 使用
Connection connection = ConnectionFactory.createConnection("mysql");

简单工厂将对象的创建集中到一个工厂类中，客户端只需要调用工厂类的静态方法即可获取对象。虽然解决了直接 new 对象的问题，但仍然存在可扩展性问题。如果要添加新的数据库类型，仍然需要修改 ConnectionFactory 类的代码。

工厂方法模式

为了解决简单工厂模式的可扩展性问题，我们可以使用工厂方法模式。工厂方法模式定义一个工厂接口，每个具体的产品都有一个对应的工厂类。客户端只需要选择对应的工厂类，即可获取对应的产品。

interface ConnectionFactory {
    Connection createConnection();
}

class MySqlConnectionFactory implements ConnectionFactory {
    @Override
    public Connection createConnection() {
        return new MySqlConnection();
    }
}

class OracleConnectionFactory implements ConnectionFactory {
    @Override
    public Connection createConnection() {
        return new OracleConnection();
    }
}

// 使用
ConnectionFactory factory = new MySqlConnectionFactory();
Connection connection = factory.createConnection();

工厂方法模式将对象的创建延迟到子类中，客户端只需要选择对应的工厂类即可获取对应的产品。如果要添加新的数据库类型，只需要添加一个新的工厂类即可，无需修改现有的代码。

抽象工厂模式

如果我们的产品族比较复杂，例如数据库连接、命令、语句等，可以使用抽象工厂模式。抽象工厂模式定义一个抽象工厂接口，用于创建一系列相关或相互依赖的对象。每个具体的工厂类实现该接口，负责创建特定产品族的对象。

interface DatabaseFactory {
    Connection createConnection();
    Statement createStatement();
}

interface Statement {
    void execute(String sql);
}

class MySQLDatabaseFactory implements DatabaseFactory {
    @Override
    public Connection createConnection() {
        return new MySqlConnection();
    }

    @Override
    public Statement createStatement() {
        return new MySQLStatement();
    }
}

class MySQLStatement implements Statement {
    @Override
    public void execute(String sql) {
        System.out.println("Executing MySQL statement: " + sql);
    }
}

// 使用
DatabaseFactory factory = new MySQLDatabaseFactory();
Connection connection = factory.createConnection();
Statement statement = factory.createStatement();
statement.execute("SELECT * FROM users");

抽象工厂模式将相关的对象创建封装到一个工厂中，客户端只需要选择对应的工厂即可获取对应的产品族。如果要添加新的数据库类型，只需要添加一个新的工厂类即可，无需修改现有的代码。

实战避坑经验

• 过度设计：不要为了使用工厂模式而使用，只有在确实需要解耦和提高可扩展性的情况下才使用。
• 工厂类的命名：工厂类的命名应该清晰明了，能够反映其创建的对象类型。
• 依赖注入框架：现代 Java 开发中，可以使用 Spring 等依赖注入框架来简化对象的创建和管理，避免手动编写大量的工厂类。例如使用 Spring 的 @Autowired 注解或者 XML 配置来实现依赖注入。
• 考虑并发场景：如果工厂类需要在并发环境下使用，需要考虑线程安全问题。

在实际项目中，例如使用 Nginx 作为反向代理服务器，可以利用工厂模式来创建不同的负载均衡策略，例如轮询、加权轮询、IP Hash 等。通过工厂模式，可以方便地切换和扩展负载均衡策略，而无需修改 Nginx 的核心配置。同时也要关注 Nginx 的并发连接数、宝塔面板的使用以及各种配置文件的优化。