抽象工厂模式（Abstract Factory Pattern）是一种比较常用的模式，其定义如下：Provide an interface for creating families of related or dependent objects without specifying their concrete classes.（为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。）

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

3.1、场景示例

例如在简单工厂模式中，我们创建了不同颜色的书籍，红书，绿书，以及蓝书，随着工厂的日益增长，书店讨论创建分店，一个店卖IT技术类书籍，一类专门卖小说。这个时候我们简单工厂就不太方便实现这种需求了，所以抽象工厂模式来了。

3.2、代码分析

因为有了新的产品，所以基于书店的模式，我们需要对书籍作出调增，如下:

3、抽象工厂模式(AbstractFactoryPattern) - 图1 基于上面的修改，其代码如下：

  1.   abstract class Book {
  2.     abstract String getType();
  4.     abstract String getColor();
  6.     abstract Float getPrice();
  7.   }
  9.   abstract class RedBook extends Book {
  11.     @Override
  12.     String getColor() {
  13.       return "RED";
  14.     }
  15.   }
  17.   abstract class GreenBook extends Book {
  19.     @Override
  20.     String getColor() {
  21.       return "GREEN";
  22.     }
  23.   }
  25.   // 具体书籍实现
  26.   class RedITBook extends RedBook {
  28.     @Override
  29.     String getType() {
  30.       return "IT";
  31.     }
  33.     @Override
  34.     Float getPrice() {
  35.       return 123F;
  36.     }
  37.   }
  39.   class RedStoreBook extends RedBook {
  41.     @Override
  42.     String getType() {
  43.       return "Store";
  44.     }
  46.     @Override
  47.     Float getPrice() {
  48.       return 3243.43F;
  49.     }
  50.   }
  52.   // 蓝色的书籍
  53.   class BlueITBook extends RedBook {
  55.     @Override
  56.     String getType() {
  57.       return "IT";
  58.     }
  60.     @Override
  61.     Float getPrice() {
  62.       return 123F;
  63.     }
  64.   }
  66.   class BlueStoreBook extends RedBook {
  68.     @Override
  69.     String getType() {
  70.       return "Store";
  71.     }
  73.     @Override
  74.     Float getPrice() {
  75.       return 3243.43F;
  76.     }
  77.   }

工厂新增创建ITFactory 以及 StoreFactory 

  1. interface Factory {
  3.     Book createRedBook();
  5.     Book createBlueBook();
  6.   }
  8.   class ITBookFactory implements Factory {
  10.     @Override
  11.     public Book createRedBook() {
  12.       return new RedITBook();
  13.     }
  15.     @Override
  16.     public Book createBlueBook() {
  17.       return new BlueITBook();
  18.     }
  19.   }
  21.   class StoreBookFactory implements Factory {
  23.     @Override
  24.     public Book createRedBook() {
  25.       return new RedStoreBook();
  26.     }
  28.     @Override
  29.     public Book createBlueBook() {
  30.       return new BlueStoreBook();
  31.     }
  32.   }

3.3、总结

  • 封闭性，每个产品的实现类不是高层模块要关心的
  • 产品族内的约束为非公开状态，例如，在书籍的比例上，上层代码不需要了解，仅由内部控制
  • 抽象工厂模式拓展产品族困难，比如新增了紫色书籍，对应的 ITBookFactory 和 StoreBookFactory 均需要修改，违反了开闭原则。
  • 从上面的UML类图中可以看到如果新增一个英文书籍，是非常方便的，只需要创建 RedEngishBook extends RedBook 、 BlueEnglishBook extends BlueBook 以及 EnglishFactory implement Factory 即可，没有对其他代码进行修改，符合开闭原则。