工厂方法模式与抽象工厂模式实战解析

1. 工厂方法模式：解耦对象创建的经典实践

工厂方法模式（Factory Method Pattern）是我在大型项目架构中最常用的设计模式之一。它的核心价值在于将对象的实例化过程延迟到子类，实现了创建者与具体产品的解耦。想象一下，当你需要开发一个跨平台的UI组件库时，按钮（Button）在不同操作系统下的实现各不相同。如果直接在代码中写死new WindowsButton()或new MacOSButton()，不仅违反开闭原则，还会导致代码难以维护。

1.1 模式结构与典型实现

标准的工厂方法模式包含四个关键角色：

• Product：定义产品的接口（如Button接口）
• ConcreteProduct：实现接口的具体产品（如WindowsButton、MacOSButton）
• Creator：声明工厂方法返回Product类型对象
• ConcreteCreator：重写工厂方法返回具体ConcreteProduct

以Java实现为例：

java复制// 产品接口
interface Button {
    void render();
    void onClick();
}

// 具体产品
class WindowsButton implements Button {
    public void render() { System.out.println("Windows风格按钮渲染"); }
    public void onClick() { System.out.println("Windows按钮点击事件处理"); }
}

// 创建者抽象类
abstract class Dialog {
    abstract Button createButton();
    
    void renderWindow() {
        Button button = createButton();
        button.render();
    }
}

// 具体创建者
class WindowsDialog extends Dialog {
    Button createButton() {
        return new WindowsButton();
    }
}

1.2 实战中的典型应用场景

在我参与的电商系统中，支付模块就完美运用了工厂方法模式。当用户选择支付宝、微信或银联支付时，系统通过PaymentFactory的子类创建对应的支付处理器。这种设计的优势在于：

1. 扩展性强：新增支付方式只需添加新的ConcreteProduct和ConcreteCreator
2. 代码整洁：支付逻辑与创建逻辑分离，符合单一职责原则
3. 测试友好：可以轻松mock具体支付产品进行单元测试

重要经验：工厂方法模式特别适合那些产品类型相对固定但可能频繁扩展的场景。如果产品类型本身就会剧烈变化（如需要动态组合多种属性），可能需要考虑其他模式。

2. 抽象工厂模式：构建产品家族的终极方案

当系统需要创建多个相互关联或依赖的产品对象时，抽象工厂模式（Abstract Factory Pattern）就显示出其强大威力。它与工厂方法模式的关键区别在于：

• 工厂方法：针对单个产品等级结构
• 抽象工厂：针对多个产品等级结构（产品家族）

2.1 模式架构深度解析

抽象工厂模式包含以下核心组件：

• AbstractFactory：声明创建一系列产品的方法（如createButton() + createCheckbox()）
• ConcreteFactory：实现具体产品的创建（如MacFactory创建Mac风格组件）
• AbstractProduct：定义产品接口（如Button、Checkbox）
• Product：具体产品实现

用C++示例演示跨平台UI组件库：

cpp复制// 抽象产品
class Button {
public:
    virtual void paint() = 0;
};

// 具体产品
class WinButton : public Button {
public:
    void paint() override { cout << "Windows按钮绘制" << endl; }
};

// 抽象工厂
class GUIFactory {
public:
    virtual Button* createButton() = 0;
    virtual Checkbox* createCheckbox() = 0;
};

// 具体工厂
class WinFactory : public GUIFactory {
public:
    Button* createButton() override { return new WinButton(); }
    Checkbox* createCheckbox() override { return new WinCheckbox(); }
};

2.2 实际项目中的精妙应用

在开发数据库兼容层时，我成功运用抽象工厂模式处理不同SQL方言的适配问题。定义DatabaseFactory接口包含createConnection()、createQueryBuilder()等方法，然后为MySQL、PostgreSQL等实现具体工厂。这样上层业务代码只需通过抽象接口操作数据库，完全无需关心底层具体实现。

典型应用场景包括：

• 跨平台UI系统（如Electron应用）
• 游戏引擎中的多渲染后端支持
• 企业应用中的多数据源适配

避坑指南：抽象工厂模式虽然强大，但也会增加系统复杂度。如果产品家族中的产品数量经常变化（比如需要频繁添加新产品类型），会导致需要修改抽象工厂接口，此时可能不适合使用该模式。

3. 两种工厂模式的对比与选型策略

3.1 核心差异点对照表

3.2 选型决策流程图

根据我的项目经验，建议按照以下逻辑选择：

1. 是否需要创建多个相关联的产品？ → 是 → 抽象工厂
2. 产品类型是否经常变化？ → 是 → 考虑Builder模式
3. 是否需要高度定制化的创建过程？ → 是 → 考虑工厂方法+策略模式
4. 默认情况 → 工厂方法模式

4. 高级应用技巧与性能优化

4.1 使用反射机制实现动态工厂

在Java生态中，我经常结合注解和反射实现灵活的工厂：

java复制@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface ProductType {
    String value();
}

public class DynamicFactory {
    private Map<String, Class<?>> productMap = new HashMap<>();
    
    public void registerProduct(String type, Class<?> productClass) {
        productMap.put(type, productClass);
    }
    
    public Product createProduct(String type) throws Exception {
        Class<?> productClass = productMap.get(type);
        return (Product) productClass.getDeclaredConstructor().newInstance();
    }
}

4.2 对象池与工厂模式的结合

对于创建成本高的对象（如数据库连接），可以在工厂中集成对象池：

python复制class ConnectionPool:
    def __init__(self, size):
        self._pool = [self._create_conn() for _ in range(size)]
    
    def _create_conn(self):
        return psycopg2.connect(DATABASE_URL)
    
    def get_connection(self):
        if not self._pool:
            self._pool.append(self._create_conn())
        return self._pool.pop()
    
    def release_connection(self, conn):
        self._pool.append(conn)

class PgConnectionFactory:
    def __init__(self):
        self._pool = ConnectionPool(10)
    
    def create_connection(self):
        return self._pool.get_connection()

4.3 现代语言中的简化实现

在Kotlin中，可以利用伴生对象和顶级函数简化工厂实现：

kotlin复制interface Document {
    fun save()
}

class WordDocument : Document {
    override fun save() = println("保存Word文档")
}

// 使用伴生对象作为工厂
class DocumentFactory {
    companion object {
        fun create(type: String): Document = when(type) {
            "word" -> WordDocument()
            else -> throw IllegalArgumentException("未知文档类型")
        }