简单工厂设计模式

模式定义

简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，通过工厂类统一创建对象实例，客户端无需直接实例化具体类。该模式包含三个核心组件：

1. 抽象产品（Product）：定义产品接口
2. 具体产品（ConcreteProduct）：实现接口的具体类
3. 工厂类（Factory）：根据输入创建具体产品实例

UML类图

+----------------+       +-------------------+       +-----------------+
|   <<接口>>     |       |      Factory      |       |   ConcreteProdA |
|   Product      |<------|-------------------|------>|-----------------|
+----------------+       | +createProduct()  |       | +operation()    |
| +operation()   |       +-------------------+       +-----------------+
+----------------+                  ▲
          ▲                         |
          |                         |       +-----------------+
          |                         +------>|   ConcreteProdB |
          |                                 |-----------------|
          +---------------------------------| +operation()    |
                                            +-----------------+

代码实现

// 1. 抽象产品接口
interface Product {
    void operation();
}

// 2. 具体产品实现
class ConcreteProdA implements Product {
    @Override
    public void operation() {
        System.out.println("执行产品A的操作");
    }
}

class ConcreteProdB implements Product {
    @Override
    public void operation() {
        System.out.println("执行产品B的操作");
    }
}

// 3. 工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        switch(type.toUpperCase()) {
            case "A": return new ConcreteProdA();
            case "B": return new ConcreteProdB();
            default: throw new IllegalArgumentException("无效的产品类型");
        }
    }
}

// 4. 客户端使用
public class Client {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        
        Product productA = factory.createProduct("A");
        productA.operation();  // 输出: 执行产品A的操作
        
        Product productB = factory.createProduct("B");
        productB.operation();  // 输出: 执行产品B的操作
    }
}

核心优势

1. 解耦对象创建

   • 客户端只需知道产品接口，无需了解具体实现类
   • 符合迪米特法则：减少对象间的依赖

2. 集中控制

   • 创建逻辑封装在工厂类中，便于统一管理
   • 修改产品创建逻辑只需调整工厂类

3. 可扩展性

   • 新增产品类型时，只需扩展工厂类（需修改工厂代码）

适用场景

1. 产品类型有限且不频繁变化
2. 客户端不关心具体实现类
3. 需要统一管理对象创建逻辑
4. 系统需要动态选择产品实现

局限性分析

1. 违反开闭原则

   • 新增产品类型需修改工厂类代码

2. 工厂职责过重

   • 所有创建逻辑集中在一个类中
   • 产品类型过多时工厂类会臃肿

3. 类型安全风险

   • 依赖字符串/枚举标识产品类型
   • 错误类型导致运行时异常

模式演进

当产品类型频繁变化时，可考虑：

1. 工厂方法模式：将创建延迟到子类
2. 抽象工厂模式：创建产品族
3. 依赖注入：通过容器管理对象创建

最佳实践建议

1. 结合枚举类型避免字符串错误：

enum ProductType { A, B }

class EnhancedFactory {
    public Product createProduct(ProductType type) {
        switch(type) {
            case A: return new ConcreteProdA();
            case B: return new ConcreteProdB();
        }
    }
}

1. 使用静态工厂方法简化调用：

class StaticFactory {
    public static Product createA() { 
        return new ConcreteProdA(); 
    }
}

总结：简单工厂模式是创建型模式的入门设计，适用于产品类型固定且创建逻辑简单的场景。其核心价值在于分离使用与创建，但需注意在复杂场景下向更灵活的模式演进。