从零开始学设计模式（二）——抽象工厂模式

抽象工厂模式（Abstract Factory）

抽象工厂模式可以说是对简单工厂模式的一种延伸，它是围绕一个超级工厂来创建其他简单工厂，该超级工厂又称为其他工厂的工厂。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类，每个生成的工厂都能按照工厂模式提供对象。

意图

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

主要解决：主要解决接口选择的问题。

何时使用：系统的产品有多于一个的产品族类，而系统只消费其中某一族类的产品。

如何解决：在一个产品族里面，定义多个产品。

关键代码：在一个工厂里聚合多个同类产品。

解释

现实世界的例子

要创建一个王国，我们需要有共同主题的物体。精灵王国需要精灵国王、精灵城堡和精灵军队，而兽人王国需要兽人国王、兽人城堡和兽人军队。王国中的对象之间存在依赖关系

简而言之

工厂的工厂；将个别但相关/从属工厂组合在一起而不指定其具体类别的工厂。

维基百科

The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes(抽象工厂模式提供了一种封装一组具有共同主题的独立工厂的方法，而无需指定它们的具体类)

程序代码实现

以上面现实世界的王国例子。下面的类图展示了不同具体的工厂和它们生产的不同具体产品，精灵王国的工厂生产精灵城堡和精灵军队，兽人王国的工厂生产兽人城堡和兽人军队。

diagram_kingdom1.png

按照上面的类图，我们首先来定义一些接口和实现类在王国中：

public interface Castle {
  String getDescription();
}
public interface King {
  String getDescription();
}
public interface Army {
  String getDescription();
}

// Elven implementations ->
public class ElfCastle implements Castle {
  static final String DESCRIPTION = "This is the Elven castle!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ElfKing implements King {
  static final String DESCRIPTION = "This is the Elven king!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}
public class ElfArmy implements Army {
  static final String DESCRIPTION = "This is the Elven Army!";
  @Override
  public String getDescription() {
    return DESCRIPTION;
  }
}

// Orcish implementations similarly... 兽人实现与上面类似

接下来我们再来定义抽象的王国工厂接口和他的具体实现工厂

public interface KingdomFactory {
  Castle createCastle();
  King createKing();
  Army createArmy();
}

public class ElfKingdomFactory implements KingdomFactory {
  public Castle createCastle() {
    return new ElfCastle();
  }
  public King createKing() {
    return new ElfKing();
  }
  public Army createArmy() {
    return new ElfArmy();
  }
}

public class OrcKingdomFactory implements KingdomFactory {
  public Castle createCastle() {
    return new OrcCastle();
  }
  public King createKing() {
    return new OrcKing();
  }
  public Army createArmy() {
    return new OrcArmy();
  }
}

现在我们有了我们的抽象工厂，让我们制作相关联类别的家族对象，例如精灵王国工厂创建精灵城堡、精灵国王和精灵军队等

KingdomFactory factory = new ElfKingdomFactory();
Castle castle = factory.createCastle();
King king = factory.createKing();
Army army = factory.createArmy();

castle.getDescription();  // Output: This is the Elven castle!
king.getDescription(); // Output: This is the Elven king!
army.getDescription(); // Output: This is the Elven Army!

最后我们再设计一个超级工厂来生产不同种类的王国工厂。在本例中我们创建一个FactoryMaker来生产ElfKingdomFactory or OrcKingdomFactory

客户端可以通过FactoryMaker类来创建期望的具体王国工厂，具体的工厂将会生产具体的对象（军队、国王、城堡）

同样在本例中我们客户端也使用枚举作为参数来指明我们想创建具体哪一类的工厂。这一块UML关系class类图如下：

diagram_kingdom2

部分重要代码如下：

public static class FactoryMaker {

  public enum KingdomType {
    ELF, ORC
  }

  public static KingdomFactory makeFactory(KingdomType type) {
    switch (type) {
      case ELF:
        return new ElfKingdomFactory();
      case ORC:
        return new OrcKingdomFactory();
      default:
        throw new IllegalArgumentException("KingdomType not supported.");
    }
  }
}

public static void main(String[] args) {
  
    App app = new App();

    LOGGER.info("Elf Kingdom");
    app.createKingdom(FactoryMaker.makeFactory(KingdomType.ELF));
    LOGGER.info(app.getArmy().getDescription());
    LOGGER.info(app.getCastle().getDescription());
    LOGGER.info(app.getKing().getDescription());

    LOGGER.info("Orc Kingdom");
    app.createKingdom(FactoryMaker.makeFactory(KingdomType.ORC));
    LOGGER.info(app.getArmy().getDescription());
    LOGGER.info(app.getCastle().getDescription());
    LOGGER.info(app.getKing().getDescription());
  }

运行程序app输出：

16:06:12.289 [main] INFO com.iluwatar.abstractfactory.App - Elf Kingdom
16:06:12.295 [main] INFO com.iluwatar.abstractfactory.App - This is the Elven Army!
16:06:12.295 [main] INFO com.iluwatar.abstractfactory.App - This is the Elven castle!
16:06:12.295 [main] INFO com.iluwatar.abstractfactory.App - This is the Elven king!
16:06:12.296 [main] INFO com.iluwatar.abstractfactory.App - Orc Kingdom
16:06:12.297 [main] INFO com.iluwatar.abstractfactory.App - This is the Orc Army!
16:06:12.297 [main] INFO com.iluwatar.abstractfactory.App - This is the Orc castle!
16:06:12.297 [main] INFO com.iluwatar.abstractfactory.App - This is the Orc king!

应用场景

当遇到如下情形时，你应该考虑使用抽象工厂模式：

1. 一个系统应该独立于它的产品是如何创建、组成和表现的
2. 系统应该配置有多个产品系列之一
3. 相关产品对象系列被设计为一起使用，你需要强制执行此约束
4. 你想提供一个产品类库，你想展示的只是他们的接口，而不是他们的实现
5. 依赖项的生命周期在概念上比消费者的生命周期短
6. 你需要一个运行时值来构造一个特定的依赖关系
7. 你想决定在运行时从一个家族中调用哪个产品
8. 你需要通过提供一个或多个仅在运行时已知的参数，就能来解析依赖项

使用场景

• 应用在运行时需要选择调用适当的实现如FileSystemAcmeService or DatabaseAcmeService or NetworkAcmeService
• 单元测试用例编写变的更加简单

Java中的现实例子

• javax.xml.parsers.DocumentBuilderFactory
• javax.xml.transform.TransformerFactory
• javax.xml.xpath.XPathFactory

优缺点

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码

写在最后

抽象工厂模式是工厂模式的超级聚合，当产品只有一个的时候，抽象工厂模式也就变成了工厂模式，当工厂模式的产品变成多个时，工厂模式也就变成了抽象工厂模式。

抽象工厂的模式比工厂模式要复杂很多，这也就导致系统在扩展一个工厂或者一个产品时，需要改动的地方会很多，程序耦合性较高。

以上面王国的例子，假如我们要新增一个人类王国，那么我们需要新增人类王国工厂，人类城堡、人类军队，UML类图如下：

diagram_humanKingdom.png

同样再想想，假如我们要新增一个产品的时候，如一个王国除了国王、城堡、军队之外还应该有瞭望塔，那么在上图的基础上我们需要修改和新增哪些接口和类呢？读者可以自己思考一下，试着画一下UML图。

下一章节我将书写单例模式
码字不易，各位看官喜欢的话，请给点个赞 ❤️，我将持续更新，谢谢！