抽象工厂模式全方位深度解析

数据中穿行
4 阅读17分钟

一、模式定义

抽象工厂模式是一种创建型设计模式，用于创建一系列相关或相互依赖的对象家族，而无需指定它们的具体类。它提供一个接口，用于创建相关或依赖对象的家族，而不需要指定具体的类。

二、Java源代码实现

1. 经典抽象工厂模式实现

// 1. 抽象产品族接口
// 按钮接口
public interface Button {
    void render();
    void onClick();
}

// 文本框接口
public interface TextField {
    void render();
    String getValue();
    void setValue(String value);
}

// 复选框接口
public interface Checkbox {
    void render();
    boolean isChecked();
    void setChecked(boolean checked);
}

// 滚动条接口
public interface ScrollBar {
    void render();
    void scroll(int position);
}

// 2. 具体产品实现
// Windows风格产品
public class WindowsButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Windows风格按钮");
    }
    
    @Override
    public void onClick() {
        System.out.println("Windows按钮被点击");
    }
}

public class WindowsTextField implements TextField {
    private String value = "";
    
    @Override
    public void render() {
        System.out.println("渲染Windows风格文本框，当前值: " + value);
    }
    
    @Override
    public String getValue() {
        return value;
    }
    
    @Override
    public void setValue(String value) {
        this.value = value;
    }
}

public class WindowsCheckbox implements Checkbox {
    private boolean checked = false;
    
    @Override
    public void render() {
        System.out.println("渲染Windows风格复选框，选中状态: " + checked);
    }
    
    @Override
    public boolean isChecked() {
        return checked;
    }
    
    @Override
    public void setChecked(boolean checked) {
        this.checked = checked;
    }
}

public class WindowsScrollBar implements ScrollBar {
    @Override
    public void render() {
        System.out.println("渲染Windows风格滚动条");
    }
    
    @Override
    public void scroll(int position) {
        System.out.println("Windows滚动条滚动到位置: " + position);
    }
}

// Mac风格产品
public class MacButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染macOS风格按钮");
    }
    
    @Override
    public void onClick() {
        System.out.println("macOS按钮被点击");
    }
}

public class MacTextField implements TextField {
    private String value = "";
    
    @Override
    public void render() {
        System.out.println("渲染macOS风格文本框，当前值: " + value);
    }
    
    @Override
    public String getValue() {
        return value;
    }
    
    @Override
    public void setValue(String value) {
        this.value = value;
    }
}

public class MacCheckbox implements Checkbox {
    private boolean checked = false;
    
    @Override
    public void render() {
        System.out.println("渲染macOS风格复选框，选中状态: " + checked);
    }
    
    @Override
    public boolean isChecked() {
        return checked;
    }
    
    @Override
    public void setChecked(boolean checked) {
        this.checked = checked;
    }
}

public class MacScrollBar implements ScrollBar {
    @Override
    public void render() {
        System.out.println("渲染macOS风格滚动条");
    }
    
    @Override
    public void scroll(int position) {
        System.out.println("macOS滚动条滚动到位置: " + position);
    }
}

// Linux风格产品
public class LinuxButton implements Button {
    @Override
    public void render() {
        System.out.println("渲染Linux风格按钮");
    }
    
    @Override
    public void onClick() {
        System.out.println("Linux按钮被点击");
    }
}

public class LinuxTextField implements TextField {
    private String value = "";
    
    @Override
    public void render() {
        System.out.println("渲染Linux风格文本框，当前值: " + value);
    }
    
    @Override
    public String getValue() {
        return value;
    }
    
    @Override
    public void setValue(String value) {
        this.value = value;
    }
}

// 3. 抽象工厂接口
public interface GUIFactory {
    Button createButton();
    TextField createTextField();
    Checkbox createCheckbox();
    ScrollBar createScrollBar();
    
    // 可选：创建默认产品的方法
    default Button createDefaultButton() {
        return createButton();
    }
}

// 4. 具体工厂实现
public class WindowsFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new WindowsButton();
    }
    
    @Override
    public TextField createTextField() {
        return new WindowsTextField();
    }
    
    @Override
    public Checkbox createCheckbox() {
        return new WindowsCheckbox();
    }
    
    @Override
    public ScrollBar createScrollBar() {
        return new WindowsScrollBar();
    }
}

public class MacFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new MacButton();
    }
    
    @Override
    public TextField createTextField() {
        return new MacTextField();
    }
    
    @Override
    public Checkbox createCheckbox() {
        return new MacCheckbox();
    }
    
    @Override
    public ScrollBar createScrollBar() {
        return new MacScrollBar();
    }
}

public class LinuxFactory implements GUIFactory {
    @Override
    public Button createButton() {
        return new LinuxButton();
    }
    
    @Override
    public TextField createTextField() {
        return new LinuxTextField();
    }
    
    @Override
    public Checkbox createCheckbox() {
        // Linux可能没有复选框，返回Windows风格作为兼容
        return new WindowsCheckbox();
    }
    
    @Override
    public ScrollBar createScrollBar() {
        // 使用适配器模式返回兼容的滚动条
        return new WindowsScrollBar();
    }
}

// 5. 工厂提供者/工厂选择器
public class GUIFactoryProvider {
    public enum OS_TYPE {
        WINDOWS,
        MACOS,
        LINUX
    }
    
    public static GUIFactory getFactory(OS_TYPE osType) {
        switch (osType) {
            case WINDOWS:
                return new WindowsFactory();
            case MACOS:
                return new MacFactory();
            case LINUX:
                return new LinuxFactory();
            default:
                throw new IllegalArgumentException("不支持的操作系统类型: " + osType);
        }
    }
    
    // 自动检测操作系统
    public static GUIFactory getFactory() {
        String osName = System.getProperty("os.name").toLowerCase();
        
        if (osName.contains("win")) {
            return new WindowsFactory();
        } else if (osName.contains("mac")) {
            return new MacFactory();
        } else if (osName.contains("nix") || osName.contains("nux")) {
            return new LinuxFactory();
        } else {
            // 默认返回Windows风格
            return new WindowsFactory();
        }
    }
}

// 6. 客户端使用示例
public class AbstractFactoryClient {
    public static void main(String[] args) {
        System.out.println("=== 抽象工厂模式示例 ===");
        
        // 示例1：指定工厂类型
        testSpecificFactory();
        
        // 示例2：自动检测工厂
        testAutoDetectFactory();
        
        // 示例3：完整GUI应用
        testFullGUIApplication();
    }
    
    private static void testSpecificFactory() {
        System.out.println("\n1. 指定Windows工厂:");
        GUIFactory windowsFactory = GUIFactoryProvider.getFactory(GUIFactoryProvider.OS_TYPE.WINDOWS);
        createAndUseUIComponents(windowsFactory);
        
        System.out.println("\n2. 指定macOS工厂:");
        GUIFactory macFactory = GUIFactoryProvider.getFactory(GUIFactoryProvider.OS_TYPE.MACOS);
        createAndUseUIComponents(macFactory);
        
        System.out.println("\n3. 指定Linux工厂:");
        GUIFactory linuxFactory = GUIFactoryProvider.getFactory(GUIFactoryProvider.OS_TYPE.LINUX);
        createAndUseUIComponents(linuxFactory);
    }
    
    private static void testAutoDetectFactory() {
        System.out.println("\n4. 自动检测操作系统工厂:");
        GUIFactory factory = GUIFactoryProvider.getFactory();
        System.out.println("检测到的操作系统: " + System.getProperty("os.name"));
        createAndUseUIComponents(factory);
    }
    
    private static void testFullGUIApplication() {
        System.out.println("\n5. 完整GUI应用示例:");
        
        // 创建应用
        GUIApplication app = new GUIApplication();
        
        // 使用Windows风格
        System.out.println("\nWindows风格应用:");
        app.setFactory(new WindowsFactory());
        app.renderUI();
        
        // 使用macOS风格
        System.out.println("\nmacOS风格应用:");
        app.setFactory(new MacFactory());
        app.renderUI();
    }
    
    private static void createAndUseUIComponents(GUIFactory factory) {
        Button button = factory.createButton();
        TextField textField = factory.createTextField();
        Checkbox checkbox = factory.createCheckbox();
        ScrollBar scrollBar = factory.createScrollBar();
        
        button.render();
        button.onClick();
        
        textField.setValue("Hello, Abstract Factory!");
        textField.render();
        
        checkbox.setChecked(true);
        checkbox.render();
        
        scrollBar.render();
        scrollBar.scroll(50);
    }
}

// 完整的GUI应用
class GUIApplication {
    private GUIFactory factory;
    private List<Button> buttons = new ArrayList<>();
    private List<TextField> textFields = new ArrayList<>();
    private List<Checkbox> checkboxes = new ArrayList<>();
    private List<ScrollBar> scrollBars = new ArrayList<>();
    
    public void setFactory(GUIFactory factory) {
        this.factory = factory;
        createUIComponents();
    }
    
    private void createUIComponents() {
        buttons.clear();
        textFields.clear();
        checkboxes.clear();
        scrollBars.clear();
        
        // 创建一系列UI组件
        for (int i = 0; i < 3; i++) {
            buttons.add(factory.createButton());
            textFields.add(factory.createTextField());
            checkboxes.add(factory.createCheckbox());
            scrollBars.add(factory.createScrollBar());
        }
    }
    
    public void renderUI() {
        System.out.println("渲染UI界面:");
        System.out.println("- 按钮数量: " + buttons.size());
        System.out.println("- 文本框数量: " + textFields.size());
        System.out.println("- 复选框数量: " + checkboxes.size());
        System.out.println("- 滚动条数量: " + scrollBars.size());
        
        // 渲染第一个组件作为示例
        if (!buttons.isEmpty()) {
            buttons.get(0).render();
        }
    }
}

2. 数据库连接工厂示例

// 1. 数据库产品族
// 连接接口
public interface Connection {
    void connect();
    void disconnect();
    boolean isConnected();
    void executeQuery(String sql);
}

// 语句接口
public interface Statement {
    void execute(String sql);
    ResultSet executeQuery(String sql);
    int executeUpdate(String sql);
}

// 结果集接口
public interface ResultSet {
    boolean next();
    String getString(String column);
    int getInt(String column);
    void close();
}

// 事务接口
public interface Transaction {
    void begin();
    void commit();
    void rollback();
    boolean isActive();
}

// 2. MySQL具体产品
public class MySQLConnection implements Connection {
    private boolean connected = false;
    
    @Override
    public void connect() {
        System.out.println("连接到MySQL数据库");
        connected = true;
    }
    
    @Override
    public void disconnect() {
        System.out.println("断开MySQL数据库连接");
        connected = false;
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public void executeQuery(String sql) {
        System.out.println("MySQL执行查询: " + sql);
    }
}

public class MySQLStatement implements Statement {
    @Override
    public void execute(String sql) {
        System.out.println("MySQL执行语句: " + sql);
    }
    
    @Override
    public ResultSet executeQuery(String sql) {
        System.out.println("MySQL执行查询并返回结果集: " + sql);
        return new MySQLResultSet();
    }
    
    @Override
    public int executeUpdate(String sql) {
        System.out.println("MySQL执行更新: " + sql);
        return 1; // 模拟更新行数
    }
}

public class MySQLResultSet implements ResultSet {
    private int currentRow = -1;
    private int totalRows = 5; // 模拟5行数据
    
    @Override
    public boolean next() {
        if (currentRow < totalRows - 1) {
            currentRow++;
            return true;
        }
        return false;
    }
    
    @Override
    public String getString(String column) {
        return "MySQL数据[" + column + "]在第" + currentRow + "行";
    }
    
    @Override
    public int getInt(String column) {
        return currentRow * 10;
    }
    
    @Override
    public void close() {
        System.out.println("关闭MySQL结果集");
    }
}

public class MySQLTransaction implements Transaction {
    private boolean active = false;
    
    @Override
    public void begin() {
        System.out.println("开始MySQL事务");
        active = true;
    }
    
    @Override
    public void commit() {
        System.out.println("提交MySQL事务");
        active = false;
    }
    
    @Override
    public void rollback() {
        System.out.println("回滚MySQL事务");
        active = false;
    }
    
    @Override
    public boolean isActive() {
        return active;
    }
}

// 3. PostgreSQL具体产品
public class PostgreSQLConnection implements Connection {
    private boolean connected = false;
    
    @Override
    public void connect() {
        System.out.println("连接到PostgreSQL数据库");
        connected = true;
    }
    
    @Override
    public void disconnect() {
        System.out.println("断开PostgreSQL数据库连接");
        connected = false;
    }
    
    @Override
    public boolean isConnected() {
        return connected;
    }
    
    @Override
    public void executeQuery(String sql) {
        System.out.println("PostgreSQL执行查询: " + sql);
    }
}

public class PostgreSQLStatement implements Statement {
    @Override
    public void execute(String sql) {
        System.out.println("PostgreSQL执行语句: " + sql);
    }
    
    @Override
    public ResultSet executeQuery(String sql) {
        System.out.println("PostgreSQL执行查询并返回结果集: " + sql);
        return new PostgreSQLResultSet();
    }
    
    @Override
    public int executeUpdate(String sql) {
        System.out.println("PostgreSQL执行更新: " + sql);
        return 1;
    }
}

public class PostgreSQLResultSet implements ResultSet {
    private int currentRow = -1;
    private int totalRows = 3;
    
    @Override
    public boolean next() {
        if (currentRow < totalRows - 1) {
            currentRow++;
            return true;
        }
        return false;
    }
    
    @Override
    public String getString(String column) {
        return "PostgreSQL数据[" + column + "]在第" + currentRow + "行";
    }
    
    @Override
    public int getInt(String column) {
        return currentRow * 20;
    }
    
    @Override
    public void close() {
        System.out.println("关闭PostgreSQL结果集");
    }
}

public class PostgreSQLTransaction implements Transaction {
    private boolean active = false;
    
    @Override
    public void begin() {
        System.out.println("开始PostgreSQL事务");
        active = true;
    }
    
    @Override
    public void commit() {
        System.out.println("提交PostgreSQL事务");
        active = false;
    }
    
    @Override
    public void rollback() {
        System.out.println("回滚PostgreSQL事务");
        active = false;
    }
    
    @Override
    public boolean isActive() {
        return active;
    }
}

// 4. 抽象数据库工厂
public interface DatabaseFactory {
    Connection createConnection();
    Statement createStatement();
    Transaction createTransaction();
    
    // 默认方法，提供通用功能
    default void executeTransaction(Runnable operation) {
        Transaction transaction = createTransaction();
        try {
            transaction.begin();
            operation.run();
            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            throw e;
        }
    }
}

// 5. 具体数据库工厂
public class MySQLFactory implements DatabaseFactory {
    @Override
    public Connection createConnection() {
        return new MySQLConnection();
    }
    
    @Override
    public Statement createStatement() {
        return new MySQLStatement();
    }
    
    @Override
    public Transaction createTransaction() {
        return new MySQLTransaction();
    }
}

public class PostgreSQLFactory implements DatabaseFactory {
    @Override
    public Connection createConnection() {
        return new PostgreSQLConnection();
    }
    
    @Override
    public Statement createStatement() {
        return new PostgreSQLStatement();
    }
    
    @Override
    public Transaction createTransaction() {
        return new PostgreSQLTransaction();
    }
}

// 6. 数据库管理器
public class DatabaseManager {
    private DatabaseFactory factory;
    private Connection connection;
    
    public DatabaseManager(DatabaseFactory factory) {
        this.factory = factory;
    }
    
    public void connect() {
        connection = factory.createConnection();
        connection.connect();
    }
    
    public void disconnect() {
        if (connection != null && connection.isConnected()) {
            connection.disconnect();
        }
    }
    
    public void executeQuery(String sql) {
        if (connection == null || !connection.isConnected()) {
            throw new IllegalStateException("数据库未连接");
        }
        
        factory.executeTransaction(() -> {
            Statement statement = factory.createStatement();
            ResultSet resultSet = statement.executeQuery(sql);
            
            try {
                while (resultSet.next()) {
                    System.out.println("行数据: " + resultSet.getString("name"));
                }
            } finally {
                resultSet.close();
            }
        });
    }
    
    public int executeUpdate(String sql) {
        if (connection == null || !connection.isConnected()) {
            throw new IllegalStateException("数据库未连接");
        }
        
        final int[] result = {0};
        
        factory.executeTransaction(() -> {
            Statement statement = factory.createStatement();
            result[0] = statement.executeUpdate(sql);
        });
        
        return result[0];
    }
}

// 7. 客户端使用
public class DatabaseClient {
    public static void main(String[] args) {
        System.out.println("=== 数据库抽象工厂示例 ===\n");
        
        // 使用MySQL
        System.out.println("1. 使用MySQL数据库:");
        testDatabase(new MySQLFactory());
        
        // 使用PostgreSQL
        System.out.println("\n2. 使用PostgreSQL数据库:");
        testDatabase(new PostgreSQLFactory());
    }
    
    private static void testDatabase(DatabaseFactory factory) {
        DatabaseManager dbManager = new DatabaseManager(factory);
        
        try {
            // 连接数据库
            dbManager.connect();
            
            // 执行查询
            System.out.println("执行查询:");
            dbManager.executeQuery("SELECT * FROM users");
            
            // 执行更新
            System.out.println("执行更新:");
            int affectedRows = dbManager.executeUpdate("UPDATE users SET name='张三' WHERE id=1");
            System.out.println("影响行数: " + affectedRows);
            
        } finally {
            // 断开连接
            dbManager.disconnect();
        }
    }
}

3. 抽象工厂模式的高级变体

// 1. 支持配置的抽象工厂
public interface ConfigurableFactory<T> {
    T createProductA();
    T createProductB();
    T createProductC();
    
    // 配置方法
    void configure(FactoryConfiguration config);
}

// 2. 可扩展的抽象工厂
public abstract class AbstractExtendedFactory {
    // 核心产品创建方法
    public abstract Product createCoreProduct();
    
    // 可选产品创建方法
    public Product createOptionalProduct() {
        return new DefaultOptionalProduct(); // 默认实现
    }
    
    // 钩子方法
    protected void beforeCreate() {
        // 子类可以覆盖
    }
    
    protected void afterCreate(Product product) {
        // 子类可以覆盖
    }
}

// 3. 组合工厂模式
public class CompositeFactory implements GUIFactory {
    private List<GUIFactory> factories = new ArrayList<>();
    
    public void addFactory(GUIFactory factory) {
        factories.add(factory);
    }
    
    @Override
    public Button createButton() {
        // 返回第一个可用的按钮
        for (GUIFactory factory : factories) {
            try {
                return factory.createButton();
            } catch (UnsupportedOperationException e) {
                // 这个工厂不支持，尝试下一个
            }
        }
        throw new UnsupportedOperationException("没有工厂支持创建按钮");
    }
    
    @Override
    public TextField createTextField() {
        // 返回所有工厂产品的组合
        return new CompositeTextField(factories.stream()
            .map(GUIFactory::createTextField)
            .collect(Collectors.toList()));
    }
}

// 组合产品
class CompositeTextField implements TextField {
    private List<TextField> textFields = new ArrayList<>();
    
    public CompositeTextField(List<TextField> textFields) {
        this.textFields = textFields;
    }
    
    @Override
    public void render() {
        textFields.forEach(TextField::render);
    }
    
    @Override
    public String getValue() {
        return textFields.stream()
            .map(TextField::getValue)
            .collect(Collectors.joining(", "));
    }
    
    @Override
    public void setValue(String value) {
        textFields.forEach(tf -> tf.setValue(value));
    }
}

三、应用场景深度解析

1. 跨平台UI框架

// 跨平台应用框架
public interface CrossPlatformFactory {
    Window createWindow();
    Menu createMenu();
    Dialog createDialog();
    Button createButton();
}

// 具体平台实现
public class WindowsUIFactory implements CrossPlatformFactory { /* ... */ }
public class MacUIFactory implements CrossPlatformFactory { /* ... */ }
public class LinuxUIFactory implements CrossPlatformFactory { /* ... */ }
public class WebUIFactory implements CrossPlatformFactory { /* ... */ }
public class MobileUIFactory implements CrossPlatformFactory { /* ... */ }

// 应用代码
public class Application {
    private CrossPlatformFactory factory;
    private Window mainWindow;
    private Menu mainMenu;
    
    public Application(CrossPlatformFactory factory) {
        this.factory = factory;
    }
    
    public void createUI() {
        mainWindow = factory.createWindow();
        mainMenu = factory.createMenu();
        // 创建其他UI组件...
    }
    
    public void run() {
        createUI();
        mainWindow.render();
        mainMenu.show();
    }
}

2. 数据库抽象层

// 数据库抽象层
public interface DatabaseAbstractionFactory {
    Connection createConnection();
    QueryBuilder createQueryBuilder();
    SchemaManager createSchemaManager();
    MigrationTool createMigrationTool();
    BackupService createBackupService();
}

// 具体数据库实现
public class MySQLFactory implements DatabaseAbstractionFactory { /* ... */ }
public class PostgreSQLFactory implements DatabaseAbstractionFactory { /* ... */ }
public class OracleFactory implements DatabaseAbstractionFactory { /* ... */ }
public class SQLServerFactory implements DatabaseAbstractionFactory { /* ... */ }

// 数据库迁移工具
public class DatabaseMigrator {
    private DatabaseAbstractionFactory sourceFactory;
    private DatabaseAbstractionFactory targetFactory;
    
    public void migrateSchema() {
        SchemaManager sourceSchema = sourceFactory.createSchemaManager();
        SchemaManager targetSchema = targetFactory.createSchemaManager();
        MigrationTool migrationTool = sourceFactory.createMigrationTool();
        
        // 迁移逻辑...
    }
}

3. 游戏开发

// 游戏图形引擎工厂
public interface GraphicsEngineFactory {
    Renderer createRenderer();
    Texture createTexture(String path);
    Shader createShader(String vertexSrc, String fragmentSrc);
    Mesh createMesh(float[] vertices, int[] indices);
    Camera createCamera();
}

// 具体图形API实现
public class OpenGLFactory implements GraphicsEngineFactory { /* ... */ }
public class DirectXFactory implements GraphicsEngineFactory { /* ... */ }
public class VulkanFactory implements GraphicsEngineFactory { /* ... */ }
public class MetalFactory implements GraphicsEngineFactory { /* ... */ }

// 游戏对象工厂
public interface GameObjectFactory {
    Character createCharacter(String type);
    Weapon createWeapon(String type);
    Armor createArmor(String type);
    Potion createPotion(String type);
    Enemy createEnemy(String type);
}

// 具体游戏主题实现
public class MedievalFactory implements GameObjectFactory { /* ... */ }
public class SciFiFactory implements GameObjectFactory { /* ... */ }
public class FantasyFactory implements GameObjectFactory { /* ... */ }
public class CyberpunkFactory implements GameObjectFactory { /* ... */ }

4. 企业级应用

// 报表系统工厂
public interface ReportFactory {
    ReportGenerator createReportGenerator();
    DataSource createDataSource();
    Formatter createFormatter();
    Exporter createExporter();
    Validator createValidator();
}

// 具体报表类型
public class FinancialReportFactory implements ReportFactory { /* ... */ }
public class SalesReportFactory implements ReportFactory { /* ... */ }
public class InventoryReportFactory implements ReportFactory { /* ... */ }
public class HRReportFactory implements ReportFactory { /* ... */ }

// 日志系统工厂
public interface LoggingFactory {
    Logger createLogger(String name);
    Appender createAppender();
    Formatter createFormatter();
    Filter createFilter();
    
    // 默认实现
    default Logger getLogger(Class<?> clazz) {
        return createLogger(clazz.getName());
    }
}

// 具体日志实现
public class Log4jFactory implements LoggingFactory { /* ... */ }
public class LogbackFactory implements LoggingFactory { /* ... */ }
public class JULFactory implements LoggingFactory { /* ... */ }
public class CustomLogFactory implements LoggingFactory { /* ... */ }

四、优缺点深度解析

优点

  1. 产品族一致性保证

    • 确保创建的对象属于同一产品族
    • 避免不兼容的产品组合
    • 强制使用同一风格/主题的对象

  2. 符合开闭原则

    • 添加新产品族容易
    • 扩展新的具体工厂简单
    • 客户端代码与具体产品解耦

  3. 单一职责原则

    • 每个具体工厂只负责创建特定产品族
    • 产品创建逻辑集中管理
    • 便于维护和测试

  4. 依赖倒置原则

    • 客户端依赖抽象而非具体实现
    • 降低模块间耦合度
    • 提高代码的灵活性和可测试性

  5. 良好的封装性

    • 隐藏产品创建细节
    • 客户端只关心抽象接口
    • 实现细节可以独立变化

缺点

  1. 代码复杂度增加

    • 需要定义大量接口和类
    • 产品族和产品等级结构复杂
    • 增加系统理解和维护难度

  2. 扩展新产品困难

    • 添加新产品需要修改抽象工厂
    • 所有具体工厂都需要实现新方法
    • 违反开闭原则（对产品维度）

  3. 过度设计风险

    • 简单场景下显得臃肿
    • 增加不必要的抽象层次
    • 可能降低性能

  4. 理解成本高

    • 需要理解多个产品族的层次结构
    • 设计模式初学者难以掌握
    • 团队成员需要统一的设计理念

  5. 初始化开销

    • 需要创建多个工厂实例
    • 可能产生大量的对象
    • 内存占用相对较高

五、使用要点与最佳实践

1. 工厂方法vs抽象工厂

// 场景选择指南
public class PatternSelector {
    /*
     * 使用工厂方法模式当：
     * 1. 只有一个产品等级结构
     * 2. 不知道确切的产品类型
     * 3. 需要扩展新产品类型
     * 
     * 使用抽象工厂模式当：
     * 1. 有多个产品等级结构（产品族）
     * 2. 需要保证产品族的兼容性
     * 3. 系统不应该依赖具体产品
     */
    
    // 示例：混合使用两种模式
    public interface HybridFactory {
        // 抽象工厂方法
        ProductA createProductA();
        ProductB createProductB();
        
        // 工厂方法
        default ProductC createProductC(String type) {
            switch (type) {
                case "type1": return new ProductC1();
                case "type2": return new ProductC2();
                default: throw new IllegalArgumentException("未知类型: " + type);
            }
        }
    }
}

2. 动态工厂选择

// 运行时动态选择工厂
public class DynamicFactorySelector {
    private Map<String, Supplier<GUIFactory>> factoryRegistry = new HashMap<>();
    
    public DynamicFactorySelector() {
        // 注册工厂
        factoryRegistry.put("windows", WindowsFactory::new);
        factoryRegistry.put("mac", MacFactory::new);
        factoryRegistry.put("linux", LinuxFactory::new);
        
        // 从配置文件加载
        loadFromConfig();
    }
    
    public GUIFactory getFactory(String key) {
        Supplier<GUIFactory> supplier = factoryRegistry.get(key.toLowerCase());
        if (supplier == null) {
            throw new IllegalArgumentException("未注册的工厂类型: " + key);
        }
        return supplier.get();
    }
    
    public GUIFactory getFactoryBasedOnCondition(Condition condition) {
        // 根据条件选择工厂
        if (condition.isHighPerformance()) {
            return new OptimizedFactory();
        } else if (condition.isLowMemory()) {
            return new LightweightFactory();
        } else {
            return new DefaultFactory();
        }
    }
    
    private void loadFromConfig() {
        Properties props = new Properties();
        try (InputStream input = getClass().getResourceAsStream("/factory-config.properties")) {
            if (input != null) {
                props.load(input);
                props.forEach((key, value) -> 
                    factoryRegistry.put(key.toString(), 
                        () -> createFactory(value.toString())));
            }
        } catch (IOException e) {
            // 使用默认配置
        }
    }
    
    private GUIFactory createFactory(String className) {
        try {
            Class<?> clazz = Class.forName(className);
            return (GUIFactory) clazz.getDeclaredConstructor().newInstance();
        } catch (Exception e) {
            throw new RuntimeException("无法创建工厂: " + className, e);
        }
    }
}

3. 延迟初始化和缓存

// 带缓存的抽象工厂
public class CachedFactory implements GUIFactory {
    private final GUIFactory delegate;
    private final Map<String, Object> cache = new ConcurrentHashMap<>();
    
    public CachedFactory(GUIFactory delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public Button createButton() {
        return (Button) cache.computeIfAbsent("button", k -> delegate.createButton());
    }
    
    @Override
    public TextField createTextField() {
        return (TextField) cache.computeIfAbsent("textfield", k -> delegate.createTextField());
    }
    
    @Override
    public Checkbox createCheckbox() {
        return (Checkbox) cache.computeIfAbsent("checkbox", k -> delegate.createCheckbox());
    }
    
    @Override
    public ScrollBar createScrollBar() {
        return (ScrollBar) cache.computeIfAbsent("scrollbar", k -> delegate.createScrollBar());
    }
    
    public void clearCache() {
        cache.clear();
    }
    
    public void clearCache(String key) {
        cache.remove(key);
    }
}

// 延迟加载工厂
public class LazyFactory implements GUIFactory {
    private final Supplier<GUIFactory> factorySupplier;
    private GUIFactory factory;
    
    public LazyFactory(Supplier<GUIFactory> factorySupplier) {
        this.factorySupplier = factorySupplier;
    }
    
    private GUIFactory getFactory() {
        if (factory == null) {
            synchronized (this) {
                if (factory == null) {
                    factory = factorySupplier.get();
                }
            }
        }
        return factory;
    }
    
    @Override
    public Button createButton() {
        return getFactory().createButton();
    }
    
    @Override
    public TextField createTextField() {
        return getFactory().createTextField();
    }
    
    @Override
    public Checkbox createCheckbox() {
        return getFactory().createCheckbox();
    }
    
    @Override
    public ScrollBar createScrollBar() {
        return getFactory().createScrollBar();
    }
}

4. 验证和错误处理

// 带验证的抽象工厂
public abstract class ValidatingFactory implements GUIFactory {
    private final List<FactoryValidator> validators = new ArrayList<>();
    
    public ValidatingFactory() {
        // 添加默认验证器
        validators.add(new CompatibilityValidator());
        validators.add(new PerformanceValidator());
        validators.add(new SecurityValidator());
    }
    
    public void addValidator(FactoryValidator validator) {
        validators.add(validator);
    }
    
    protected void validateCreation(String productType) {
        for (FactoryValidator validator : validators) {
            if (!validator.validate(this, productType)) {
                throw new ValidationException(
                    "验证失败: " + validator.getClass().getSimpleName() +
                    " 对于产品类型: " + productType);
            }
        }
    }
    
    // 模板方法
    protected abstract Button doCreateButton();
    protected abstract TextField doCreateTextField();
    
    @Override
    public Button createButton() {
        validateCreation("button");
        return doCreateButton();
    }
    
    @Override
    public TextField createTextField() {
        validateCreation("textfield");
        return doCreateTextField();
    }
}

// 验证器接口
interface FactoryValidator {
    boolean validate(GUIFactory factory, String productType);
}

class CompatibilityValidator implements FactoryValidator {
    @Override
    public boolean validate(GUIFactory factory, String productType) {
        // 检查产品兼容性
        return true;
    }
}

5. 线程安全实现

// 线程安全的抽象工厂
public class ThreadSafeFactory implements GUIFactory {
    private final GUIFactory factory;
    private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private final Map<String, Object> instances = new ConcurrentHashMap<>();
    
    public ThreadSafeFactory(GUIFactory factory) {
        this.factory = factory;
    }
    
    @Override
    public Button createButton() {
        return (Button) getOrCreate("button", factory::createButton);
    }
    
    @Override
    public TextField createTextField() {
        return (TextField) getOrCreate("textfield", factory::createTextField);
    }
    
    private Object getOrCreate(String key, Supplier<?> creator) {
        // 双重检查锁定
        Object instance = instances.get(key);
        if (instance == null) {
            lock.writeLock().lock();
            try {
                instance = instances.get(key);
                if (instance == null) {
                    instance = creator.get();
                    instances.put(key, instance);
                }
            } finally {
                lock.writeLock().unlock();
            }
        }
        return instance;
    }
    
    // 线程安全的工厂注册表
    public static class FactoryRegistry {
        private static final Map<String, GUIFactory> registry = new ConcurrentHashMap<>();
        private static final ReadWriteLock registryLock = new ReentrantReadWriteLock();
        
        public static void registerFactory(String name, GUIFactory factory) {
            registryLock.writeLock().lock();
            try {
                registry.put(name, factory);
            } finally {
                registryLock.writeLock().unlock();
            }
        }
        
        public static GUIFactory getFactory(String name) {
            registryLock.readLock().lock();
            try {
                GUIFactory factory = registry.get(name);
                if (factory == null) {
                    throw new IllegalArgumentException("工厂未注册: " + name);
                }
                return factory;
            } finally {
                registryLock.readLock().unlock();
            }
        }
    }
}

6. 测试策略

// 抽象工厂测试
@Test
public void testAbstractFactoryPattern() {
    // 测试不同工厂创建的产品族一致性
    testFactoryConsistency(new WindowsFactory());
    testFactoryConsistency(new MacFactory());
    testFactoryConsistency(new LinuxFactory());
    
    // 测试产品兼容性
    testProductCompatibility();
    
    // 测试性能
    testFactoryPerformance();
    
    // 测试线程安全
    testThreadSafety();
}

private void testFactoryConsistency(GUIFactory factory) {
    Button button = factory.createButton();
    TextField textField = factory.createTextField();
    Checkbox checkbox = factory.createCheckbox();
    ScrollBar scrollBar = factory.createScrollBar();
    
    // 验证所有产品属于同一风格
    assertTrue(areProductsConsistent(button, textField, checkbox, scrollBar),
        "产品族应保持风格一致性");
    
    // 验证产品功能
    assertNotNull(button, "按钮不应为null");
    assertNotNull(textField, "文本框不应为null");
    assertNotNull(checkbox, "复选框不应为null");
    assertNotNull(scrollBar, "滚动条不应为null");
}

private boolean areProductsConsistent(Product... products) {
    // 检查产品风格一致性
    String style = extractStyle(products[0]);
    for (Product product : products) {
        if (!extractStyle(product).equals(style)) {
            return false;
        }
    }
    return true;
}

private String extractStyle(Product product) {
    // 从产品类名提取风格
    String className = product.getClass().getSimpleName();
    if (className.startsWith("Windows")) return "windows";
    if (className.startsWith("Mac")) return "mac";
    if (className.startsWith("Linux")) return "linux";
    return "unknown";
}

private void testProductCompatibility() {
    // 测试不同工厂产品的兼容性
    GUIFactory windowsFactory = new WindowsFactory();
    GUIFactory macFactory = new MacFactory();
    
    // 不应混合使用不同工厂的产品
    Button windowsButton = windowsFactory.createButton();
    TextField macTextField = macFactory.createTextField();
    
    // 验证混合使用会抛出异常
    assertThrows(IncompatibleProductException.class, () -> {
        useProductsTogether(windowsButton, macTextField);
    });
}

private void testFactoryPerformance() {
    GUIFactory factory = new WindowsFactory();
    
    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 10000; i++) {
        factory.createButton();
        factory.createTextField();
        factory.createCheckbox();
        factory.createScrollBar();
    }
    long duration = System.currentTimeMillis() - startTime;
    
    assertTrue(duration < 1000, "创建10000个产品应在1秒内完成");
}

private void testThreadSafety() throws InterruptedException {
    GUIFactory factory = new ThreadSafeFactory(new WindowsFactory());
    int threadCount = 10;
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    List<Future<?>> futures = new ArrayList<>();
    
    for (int i = 0; i < threadCount; i++) {
        futures.add(executor.submit(() -> {
            for (int j = 0; j < 1000; j++) {
                factory.createButton();
                factory.createTextField();
            }
        }));
    }
    
    // 等待所有任务完成
    for (Future<?> future : futures) {
        future.get();
    }
    
    executor.shutdown();
    assertTrue(executor.awaitTermination(5, TimeUnit.SECONDS));
}

六、与其他模式的比较

模式相似点不同点适用场景
工厂方法​都用于创建对象工厂方法创建单一产品，抽象工厂创建产品族单个产品用工厂方法，相关产品族用抽象工厂
建造者​都创建复杂对象建造者关注构建过程，抽象工厂关注产品族构建单个复杂对象用建造者，创建相关对象族用抽象工厂
原型​都创建对象原型通过复制，抽象工厂通过工厂创建已有相似对象用原型，需要多种相关对象用抽象工厂
单例​都控制对象创建单例确保唯一实例，抽象工厂创建多个实例全局唯一对象用单例，多种相关对象用抽象工厂

七、实际应用示例

示例1：Spring框架中的抽象工厂

// Spring配置示例
@Configuration
public class DatabaseConfig {
    
    @Bean
    @Profile("dev")
    public DataSource devDataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:h2:mem:devdb")
                .username("sa")
                .password("")
                .build();
    }
    
    @Bean
    @Profile("prod")
    public DataSource prodDataSource() {
        return DataSourceBuilder.create()
                .url("jdbc:mysql://localhost:3306/proddb")
                .username("admin")
                .password("securepass")
                .build();
    }
    
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
    
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

// 抽象工厂在Spring中的体现
public interface PlatformTransactionManager {
    TransactionStatus getTransaction(TransactionDefinition definition);
    void commit(TransactionStatus status);
    void rollback(TransactionStatus status);
}

// 具体实现
public class DataSourceTransactionManager implements PlatformTransactionManager { /* ... */ }
public class JpaTransactionManager implements PlatformTransactionManager { /* ... */ }
public class HibernateTransactionManager implements PlatformTransactionManager { /* ... */ }

示例2：Java标准库中的抽象工厂

// Java标准库中的抽象工厂模式
public class JavaStandardLibraryExamples {
    public static void main(String[] args) {
        // 1. 集合框架
        List<String> arrayList = new ArrayList<>();
        List<String> linkedList = new LinkedList<>();
        
        // 2. 日期时间API
        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        
        // 3. XML处理
        DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
        SAXParserFactory saxFactory = SAXParserFactory.newInstance();
        
        // 4. 加密API
        try {
            KeyGenerator keyGen = KeyGenerator.getInstance("AES");
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
            
            // 5. 并发工具
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(10);
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(5);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

八、注意事项

  1. 避免过度设计：只有真正需要产品族时才使用抽象工厂
  2. 合理划分产品等级：确保产品族划分合理
  3. 考虑扩展性：设计时考虑未来可能添加的新产品
  4. 保持接口稳定：抽象工厂接口应保持稳定
  5. 合理使用默认方法：Java 8+可以使用默认方法提供通用实现
  6. 注意性能影响：大量小对象可能影响性能
  7. 文档化产品兼容性：明确记录哪些产品可以一起使用
  8. 使用依赖注入：结合Spring等框架管理工厂实例

九、总结

抽象工厂模式是一种强大的创建型模式，特别适用于：

  • 需要创建一系列相关或依赖的对象
  • 系统需要独立于产品创建、组合和表示
  • 需要确保产品族的一致性
  • 系统配置多个产品族中的一个

使用抽象工厂模式的关键考量：

  1. 产品族复杂度：有多个相关的产品需要一起工作
  2. 系统独立性：希望系统独立于具体产品的创建、组合和表示
  3. 产品一致性：需要确保使用兼容的产品系列
  4. 扩展需求：预计未来会添加新的产品族

最佳实践建议：

  1. 合理设计抽象接口：确保抽象工厂接口稳定且合理
  2. 使用工厂方法组合：在抽象工厂中合理使用工厂方法
  3. 提供默认实现：为可选产品提供合理的默认实现
  4. 考虑性能优化：对频繁创建的产品考虑使用缓存
  5. 完善错误处理：提供清晰的错误信息和验证机制
  6. 编写充分测试：确保不同产品族能正确工作

抽象工厂模式是构建大型、可维护系统的重要工具，在框架开发、跨平台应用、企业级系统等领域有广泛应用。正确使用抽象工厂模式可以显著提高代码的可维护性、可扩展性和可测试性。

**

avatar
文章
阅读
粉丝