工厂方法模式、简单工厂模式、抽象工厂模式

  • 前言：平时创建对象时，通过new关键字，如User user = new User();，在一些情况下，要创建的对象需要经过一系列复杂的初始化操作，比如查配置文件、查数据库、初始化成员对象等，如果都放在构造函数，极大的影响性能。这时候一个专门负责对象的创建的类就是必要的，这就是工厂类，这种做法就是工厂模式，在任何需要生成复杂对象的地方，都可以使用。包括简单工厂（不在23中设计模式中）、工厂方法和抽象工厂。

    解决的问题

  • 客户端再调用时不想判断实例化哪一个类，或者实例化的过程过于复杂。

再工厂模式中，具体的实现类创建过程中对客户端是透明的，客户端不决定具体实例化哪一个类，而是交由”工厂“来实例化。

应用场景

  • JDK中Calendar的getInstance方法()。
  • JDBC中的Connection对象的获取。
  • Spring中IOC容器创建管理bean对象。
  • 反射中Class对象的newInstance()方法。

简单工厂模式(静态工厂)

用来生产同一等级结构中的的任意产品（对于增加新的产品，需覆盖已有代码）

  • 结构：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类。

设计模式!--工厂方法、简单工厂、抽象工厂 - 图1

  • 抽象类或接口：定义了要创建的产品对象的接口
  • 具体方法：具有统一父类的具体类型的产品

  • 产品工厂：负责创建产品对象。工厂模式同样体现了开闭原则，将”创建具体产品实现类“这部分变化的代码从不变化的代码”使用产品“中分离出来，之后想要新增产品时，只需要扩展工厂的实现类即可。

    1. //创建不同品牌的键盘
    2. //抽象接口总
    3. publci interface Keyboard{
    4. void print();
    5. void input(Context context);
    6. }
    7. //具体产品实现A
    8. class HPkeyboard implements Keyboard{
    9.   @Override
    10.   public void print(){
    11.   }
    12.   @Override
    13.   public void input(Context context){
    14.   }
    15. }
    16. //具体产品实现B
    17. class DellKeyboard implements Keyboard{
    18.   @Override
    19.   public void print(){
    20.   }
    21.   @Override
    22.   public void input(Context context){
    23.   }
    24. }
    25. //具体产品实现C
    26. class LenovoKeyboard implements Keyboard{
    27.   @Override
    28.   public void print(){
    29.   }
    30.   @Override
    31.   public void input(Context context){
    32.   }
    33. }
    34. //产品核心工厂--->调用产品实现
    35. public class KeyboardFactory{
    36.   public Keyboard getInstance(int brand){
    37.       if(BrandEnum.HP.getCode() == brand){
    38.           return new HPKeyboard();
    39.        }else if(BrandEnum.LENOVO.getCode() == brand){
    40.           return new LenovoKeyboard();
    41.        }else if(BrandEnum.DELL.getCode() == brand){
    42.           return new DellKeyboard();
    43.        }
    44.       return null;
    45.   }
    46.   public static void main(String[] args){
    47.       KeyboardFactory keyboardFactory = new KeyboardFactory();
    48.       keyboard lenovoKeyboard = KeyboardFactory.getInstance(BrandEnum.LENOVO.getCode());
    49.   }
    50. }

  • 上边的工厂实现是一个具体的类KeyboardFactory，而非接口或者抽象类，getInstance()方法利用if-else创建并返回具体的键盘实例，如果增加新的键盘子类，键盘工厂的创建方法中就要增加新的if-else。这种做法扩展性差，违背了开闭原则，也影响了可读性。所以，这种方式使用在业务较简单，工厂类不会经常更改的情况。

    工厂方法模式

    用来生产同一等级结构中的固定产品（支持增加任意产品）

  • 为了解决上面提到的”增加if-esle“的问题，可以为每一个键盘子类建立一个对应的工厂子类，这些工厂子类实现同一个抽象工厂接口。这样，创建不同品牌的键盘，只需要实现不同的工厂子类。当有新品牌加入时，新建具体工厂继承抽象工厂，而不用修改任何一个类。

  • 结构

设计模式!--工厂方法、简单工厂、抽象工厂 - 图2

  • 抽象工厂：声明了工厂方法的接口。
  • 具体产品工厂：实现工厂方法的接口，负责创建产品对象。

  • 产品抽象类或接口：定义工厂方法所创建

    1. //抽象工厂
    2. public interface IKeyboardFactory{
    3.   Keyboard getInstance();
    4. }
    5. //具体产品A工厂
    6. public class HPKeyboardFactory implements IKeyboardFactory{
    7.   @Override
    8.   public Keyboard getInstance(){
    9.       return new HPKeyboard();
    10.   }
    11. }
    12. //具体产品B工厂
    13. public class LenovoFactory implements IKeyboardFactory{
    14.   @Override
    15.   public Keyboard getInstance(){
    16.       return new lenovoKeyboard();    
    17.   }
    18. }
    19. //具体产品C工厂
    20. public class DellFactory implements IKeyboardFactory{
    21.   @Override
    22.   public Keyboard getInstance(){
    23.       return new DellKeyboard();  
    24.   }
    25. }

  • 缺点：每一种品牌对应一个工厂类，在创建具体键盘对象时，实例化不同的工厂类。但是，如业务涉及的子类越来越多，子类对应的工厂类也多，这样会使得系统中类的个数成倍增加，增加了代码的复杂的。

    抽象工厂模式

    围绕一个超级工厂创建其他工厂。该超级工厂又称工厂的工厂。

  • 为了缩减工厂实现子类的数量，不必给每一个产品分配一个工厂类，可以将产品进行分组，每组中的不同产品由同一个工厂类的不同方法来创建。例如，键盘。主机这两种产品可以分配到同一个分组—-电脑，而不同品牌的电脑由不同的制造商工厂来创建。

设计模式!--工厂方法、简单工厂、抽象工厂 - 图3

  • 把产品类分组，组内不同产品由同一工厂类的不同方法实现的设计模式，就是抽象工厂模式。
  • 抽象工厂适用于：
    • 一个系统要独立于它的产品的创建、组合和表示时；
    • 一个系统要由多个产品系列中的一个来配置时；
    • 要强调一系列相关的产品对象的设计以便进行联合使用时；
    • 当你提供一个产品类库，而只想显示他们的接口而不是实现时；
  • 结构

设计模式!--工厂方法、简单工厂、抽象工厂 - 图4
设计模式!--工厂方法、简单工厂、抽象工厂 - 图5

  • 抽象工厂：声明了创建抽象产品对象的操作接口。
  • 具体产品工厂：实现了抽象工厂的接口，负责创建产品对象。
  • 产品抽象类或接口：定义一类产品对象的接口。

  • 具体产品实现：定义一个将被相应具体工厂创建的产品对象。

    1. //零件X工厂+产品X模型工厂-->总工厂
    2. //零件A抽象工厂
    3. public interface Keyboard{
    4. void printf();
    5. }
    6. //具体产品A工厂，抽象的实现
    7. public class DellKeyboard implements Keyboard{
    8.   @Override
    9.   public void print(){
    10.   //TODO
    11.   }
    12. }
    13. //具体B产品工厂
    14. public class HPKeyboard implements Keyboard{
    15.   @Override
    16.   public void printf(){
    17.   //TODO
    18.   }
    19. }
    20. //零件B抽象工厂
    21. public interface Monitor{
    22.   void play();
    23. }
    24. //具体产品B工厂
    25. public class DellMonitor implements Monitor{
    26.   @Override
    27.   public void play(){
    28.   //TODO
    29.   }
    30. }
    31. //具体产品B工厂
    32. public class HPMonitor implements Monitor{
    33.   @Override
    34.   public void play(){
    35.   //TODO
    36.   }
    37. }
    38. //零件C抽象工厂
    39. public interface MainFrame{
    40.   void run();
    41. }
    42. //具体产品工厂
    43. public class DellMainFrame implements MainFrame{
    44.   @Override
    45.   public void run(){
    46.   //TODO
    47.   }
    48. }
    49. //具体产品工厂
    50. public class HPMainFrame implements MainFrame{
    51.   @Override
    52.   public void run(){
    53.   //TODO
    54.   }
    55. }
    56. //工厂类。工厂分Dell工厂和HP工厂，各自负责品牌内产品的创建。
    57. //产品X抽象类或接口：定义一类产品对象的接口
    58. public interface IFactory{
    59.   MainFrame createMainFrame();
    60.   //Mointor createMainFrame();
    61.   Mointor createMoitor();
    62.   Keyboard createkeyboard();
    63. }
    64. //具体产品实现
    65. public class DellFactory implements IFactory{
    66.   @Override
    67.   public MainFrame createMainFrame(){
    68.       MainFrame mainFrame = new DellMainFrame();
    69.       //...
    70.       return mainFrame
    71.   }
    72.   @Override
    73.   public Mointor createMonitor(){
    74.       Monitor monitor = new DellMonitor();
    75.       //...
    76.       return monitor;
    77.   }
    78.   @Override
    79.   public Keyboard createKeyboard(){
    80.       Keyboard keyboard = new DellKeyboard();
    81.       //...
    82.       return keyboard;
    83.   }
    84. }
    85. //具体产品实现
    86. public class HPFactory implements IFactory{
    87.   @Override
    88.   public MainFrame createMainFrame(){
    89.       MainFrame mainFrame = new HPMainFrame();
    90.       //...
    91.       return mainFrame
    92.   }
    93.   @Override
    94.   public Mointor createMonitor(){
    95.       Monitor monitor = new HPMonitor();
    96.       //...
    97.       return monitor;
    98.   }
    99.   @Override
    100.   public Keyboard createKeyboard(){
    101.       Keyboard keyboard = new HPKeyboard();
    102.       //...
    103.       return keyboard;
    104.   }
    105. }
    106. //客户端代码，实例化不同的工厂子类，可通过不同的创建方法创建不同的产品
    107. public class Main{
    108.   public static void main(String[] args){
    109.       IFactory dellFactory = new DellFactory();
    110.       IFactory HPFactory = new HPFactory();
    111.       //创建键盘
    112.       Keyboard dellKeyboard = dellFactory.createKeyboard();
    113.   }
    114. }

  • 优缺点：增加分组很简单，分组中的产品扩展很困难，要增加一个鼠标Mouse，既要创建抽象接口Mouse，又要增加具体实现DellMouse，还要在每个Factory中定义创建鼠标的方法实现createMouse()。

  • 总结：
    • 简单工厂：唯一工厂类，一个产品抽象类，工厂类的创建方法依据入参判断并创建具体产品对象。
    • 工厂方法：多个工厂类，一个产品抽象，利用多态创建不同的产品对象，避免了大量if-else判断。
    • 抽象工厂：多个工厂类，多个产品抽象类，产品子类分组，同一个工厂实现类创建同组中的不同产品，减少了工厂子类的数量。
  • 可以在一下情况考虑工厂模式：
    • 在编码时不能预见需要创建哪种类型的实例。
    • 系统不应依赖于产品类实例如何被创建、组合和表达的细节。
  • 总之，工厂模式就是为了方便创建同一接口定义的具有复杂参数和初始化步骤的不同对象。工厂模式一般用来创建复杂对象。只需用new就可以创建成功的简单读一下，无需使用工厂模式，否则会增加系统的复杂度。
  • 此外，若对象的参数是不固定，推荐使用Bulider模式。在实际项目中，结合Spring中的InitializingBean接口，可以利用@Autowried注解实现工厂。