工厂模式深度指南：创建对象的艺术

在软件设计中，创建对象是一个最基本也最常见的需求。当对象的创建逻辑变得复杂，或者对象的创建方式需要灵活切换时，直接使用 new 关键字就不是最佳选择了。工厂模式（Factory Pattern）作为一种创建型设计模式，提供了创建对象的统一接口，让对象的创建与使用解耦。

什么是工厂模式？

工厂模式是一种创建型设计模式，它定义了一个创建对象的接口，但让子类决定实例化哪个类。工厂方法让类的实例化延迟到子类。

简单工厂（Simple Factory）

最简单的工厂形式，通常用一个静态方法根据参数创建不同的对象：

class Product:
    def operation(self):
        pass

class ProductA(Product):
    def operation(self):
        return "Product A"

class ProductB(Product):
    def operation(self):
        return "Product B"

class SimpleFactory:
    @staticmethod
    def create_product(product_type):
        if product_type == "A":
            return ProductA()
        elif product_type == "B":
            return ProductB()
        raise ValueError(f"Unknown product type: {product_type}")

工厂方法模式（Factory Method Pattern）

将对象的创建委托给子类，让子类决定创建哪个对象：

from abc import ABC, abstractmethod

class Creator(ABC):
    @abstractmethod
    def factory_method(self):
        pass

    def some_operation(self):
        product = self.factory_method()
        return f"Creator: {product.operation()}"

class ConcreteCreatorA(Creator):
    def factory_method(self):
        return ProductA()

class ConcreteCreatorB(Creator):
    def factory_method(self):
        return ProductB()

抽象工厂模式（Abstract Factory Pattern）

提供一个创建一系列相关对象的接口，而无需指定它们具体的类：

class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ProductA1()

    def create_product_b(self):
        return ProductB1()

class ConcreteFactory2(AbstractFactory):
    def create_product_a(self):
        return ProductA2()

    def create_product_b(self):
        return ProductB2()

实际应用场景

1. 日志框架

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();
    }
}

2. 支付系统

根据用户选择的支付方式创建不同的支付处理器：

public interface PaymentFactory {
    PaymentProcessor createProcessor();
}

public class AlipayFactory implements PaymentFactory {
    public PaymentProcessor createProcessor() {
        return new AlipayProcessor();
    }
}

public class WechatPayFactory implements PaymentFactory {
    public PaymentProcessor createProcessor() {
        return new WechatPayProcessor();
    }
}

3. 图表库

根据配置创建不同类型的图表：

class ChartFactory {
  static createChart(type) {
    switch(type) {
      case 'line': return new LineChart();
      case 'bar': return new BarChart();
      case 'pie': return new PieChart();
      default: throw new Error('Unknown chart type');
    }
  }
}

工厂模式的优缺点

优点

1. 解耦：将对象的创建与使用分离
2. 可扩展：新增产品类型只需添加新的工厂类
3. 测试友好：可以轻松mock工厂创建的对象
4. 代码复用：创建逻辑可以在多个地方复用

缺点

1. 类数量增加：每种产品都需要对应的工厂类
2. 复杂度上升：引入额外的抽象层
3. 过度设计风险：对于简单场景可能过度复杂

何时使用工厂模式？

• 对象的创建逻辑复杂或有多种变体
• 需要在不同环境/配置下创建不同对象
• 对象的创建涉及第三方库或外部资源
• 需要统一创建接口以便后续替换实现
• 对象的创建逻辑可能频繁变化

总结

工厂模式是软件开发中最常用的设计模式之一。它通过封装对象的创建过程，实现了对象创建与使用的解耦，让代码更加灵活、可维护和可测试。

在实际项目中，不要过度追求设计模式的完美使用，要根据具体场景选择合适的方案。对于简单的对象创建，直接使用 new 或简单的工厂方法即可；对于复杂的创建逻辑，再考虑使用完整的工厂方法或抽象工厂模式。

---

标签: 设计模式, 软件架构, 后端开发, Python, Java