抽象工厂 Abstract Factory

抽象工厂定义

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

抽象工厂类图

• AbstractFactory：抽象工厂，定义创建一系列产品对象的操作接口。

• ConcreteFactory：具体的工厂，实现抽象工厂定义的方法，具体实现一系列产品对象的创建。

• AbstractProduct：定义一类产品对象的接口。

• ConcreteProduct：具体的产品实现对象，通常在具体工厂里面，会选择具体的产品实现对象，来创建符合抽象工厂定义的方法返回的产品类型的对象。

• Client：客户端，主要使用抽象工厂来获取一系列所需要的产品对象，然后面向这些产品对象的接口编程，以实现需要的功能。

抽象工厂代码实现

1. 先看看抽象工厂的定义，示例代码如下：

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

2. 接下来看看产品的定义，示例代码如下：

   public interface AbstractProductA {
       void executeA(String word);
   }
   
   public interface AbstractProductB {
       void executeB(String word);
   }
   
   

3. 具体产品的实现，示例代码如下：

   public class ProductA1 implements AbstractProductA {
       @Override
       public void executeA(String word) {
           System.out.println("a1 say " + word);
       }
   }
   
   public class ProductA2 implements AbstractProductA {
       @Override
       public void executeA(String word) {
           System.out.println("a2 say " + word);
       }
   }
   
   public class ProductB1 implements AbstractProductB {
       @Override
       public void executeB(String word) {
           System.out.println("b1 say " + word);
       }
   }
   
   
   public class ProductB2 implements AbstractProductB {
       @Override
       public void executeB(String word) {
           System.out.println("b2 say " + word);
       }
   }
   

4. 接下来看看具体的工厂的实现示意，示例代码如下：

   public class ConcreteFactory1 implements AbstractFactory {
       @Override
       public AbstractProductA createProductA() {
           return new ProductA1();
       }
   
       @Override
       public AbstractProductB createProductB() {
           return new ProductB1();
       }
   }
   
   public class ConcreteFactory2 implements AbstractFactory {
       @Override
       public AbstractProductA createProductA() {
           return new ProductA2();
       }
   
       @Override
       public AbstractProductB createProductB() {
           return new ProductB2();
       }
   }
   
   

5. 一般客户端不会直接使用抽象工厂，一般会加工一下，示例代码如下：

   public class Pack {
   
       private AbstractProductA productA;
       private AbstractProductB productB;
   
       public Pack(AbstractFactory factory){
           this.productA = factory.createProductA();
           this.productB = factory.createProductB();
       }
   
       public void execute(String word){
           productA.executeA(word);
           productB.executeB(word);
       }
   }
   

6. 最后来看看客户端的实现示意，示例代码如下：

   public class Client {
       public static void main(String[] args) {
           AbstractFactory factory = new ConcreteFactory1();
           Pack outSide = new Pack(factory);
           outSide.execute("abstract_factory");
       }
   }
   

抽象工厂的思考

抽象工厂的本质

抽象工厂的本质是选择产品簇实现。

何时选择抽象工厂

1. 如果希望一个系统独立于它的产品的创建，组合和表示的时候，换句话说，希望一个系统只是知道产品的接口，而不关心实现的时候。
2. 如果一个系统要由多个产品系列中的一个来配置的时候，换句话说，就是可以动态的切换产品簇的时候。
3. 如果要强调一系列相关产品的接口，以便联合使用它们的时候。

抽象工厂的优缺点

优点

1. 分离接口和实现
2. 使得切换产品簇变得容易

缺点

1. 不太容易扩展新的产品
2. 容易造成类层次复杂

体现了设计模式中的哪些原则

• “开闭原则”的倾斜行

  如果只增加新的产品簇，抽象工厂能很好的支持开闭原则

  如果增加新的产品结构，抽象工厂需要修改所有的工厂和抽象工厂

抽象工厂相关模式

抽象工厂模式和工厂方法模式

这两个模式既有区别，又有联系，可以组合使用。

工厂方法模式一般是针对单独的产品对象的创建，而抽象工厂模式注重产品簇对象的创建，这是它们的区别。

如果把抽象工厂创建的产品簇简化，这个产品簇就只有一个产品，那么这个时候的抽象工厂跟工厂方法是差不多的，也就是抽象工厂可以退化成工厂方法，而工厂方法又可以退化成简单工厂，这是它们的联系。

在抽象工厂的实现中，还可以使用工厂方法来提供抽象工厂的具体实现，也就是说它们可以组合使用。

抽象工厂模式和单例模式

这两个模式可以组合使用。

在抽象工厂模式里面，具体的工厂实现，在整个应用中，通常一个产品系列只需要一个实例就可以了，因此可以把具体的工厂实现成为单例。

参考资料

【创建型模式三】抽象工厂(Abstract Factory)
设计模式--抽象工厂模式