抽象工厂模式

介绍

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供一个接口来创建一系列相关或相互依赖的对象，而无需指定它们的具体类。抽象工厂模式适用于创建产品族，其中产品之间存在着天然的联系。

原理

抽象工厂模式的核心原理包括：

1. 抽象产品：定义产品的接口
2. 具体产品：实现抽象产品接口
3. 抽象工厂：声明创建一系列产品的方法
4. 具体工厂：实现抽象工厂的方法，创建具体产品实例

图示

+----------------+        +----------------+
|   AbstractProductA|<----|   AbstractFactory  |
+----------------+        +----------------+
| + operationA() |        | + createProductA()|
+-------^--------+        | + createProductB()|
        |                 +--------^-------+
+-------+--------+                  |
| ConcreteProductA1|        +--------+-------+
+----------------+        | ConcreteFactory1 |
| + operationA() |        +----------------+
+----------------+        | + createProductA()|
                          | + createProductB()|
                          +----------------+

+----------------+        +----------------+
|   AbstractProductB|<----|   ConcreteFactory2 |
+----------------+        +----------------+
| + operationB() |        | + createProductA()|
+-------^--------+        | + createProductB()|
        |                 +----------------+
+-------+--------+                  
| ConcreteProductB1|        
+----------------+        
| + operationB() |        
+----------------+        

代码示例

抽象产品

public interface AbstractProductA {
    void operationA();
}

public interface AbstractProductB {
    void operationB();
}

具体产品

public class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operation");
    }
}

public class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operation");
    }
}

public class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1 operation");
    }
}

public class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operation");
    }
}

抽象工厂

public interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

具体工厂

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

客户端代码

public class Client {
    private AbstractProductA productA;
    private AbstractProductB productB;
    
    public Client(AbstractFactory factory) {
        productA = factory.createProductA();
        productB = factory.createProductB();
    }
    
    public void doSomething() {
        productA.operationA();
        productB.operationB();
    }
    
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        Client client1 = new Client(factory1);
        client1.doSomething();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        Client client2 = new Client(factory2);
        client2.doSomething();
    }
}

解决方案

应用场景

1. 创建产品族：当需要创建的产品之间存在着天然的联系时
2. 跨平台应用：为不同平台创建适配的组件
3. 配置化应用：根据配置创建不同的产品组合
4. 依赖注入容器：管理对象之间的依赖关系

最佳实践

1. 面向接口编程：客户端代码只依赖抽象工厂和抽象产品
2. 使用工厂注册表：管理多个工厂实例
3. 结合单例模式：确保全局只有一个工厂实例
4. 考虑使用反射：动态创建产品实例

优缺点

优点：

• 确保产品之间的兼容性
• 解耦客户端与具体产品实现
• 符合开闭原则
• 便于替换整个产品族

缺点：

• 增加代码复杂度
• 难以扩展新的产品类型

工具推荐

1. Spring Framework：通过IoC容器实现抽象工厂模式
2. Google Guice：提供@Provides注解和模块系统实现抽象工厂
3. Apache Commons Configuration：用于创建配置相关的产品族
4. FactoryKit：支持构建复杂的产品族