工厂模式

想不到一个好的ID
16 阅读13分钟

封装对象复杂的创建过程，将对象的创建和使用分离，让代码更加清晰

工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。不过，在 GoF 的《设计模式》一书中，它将简单工厂模式看作是工厂方法模式的一种特例，所以工厂模式只被分成了工厂方法和抽象工厂两类。日常工作中，第一种分类方法更加常见。将工厂模式分为三种更加细分的类型：简单工厂、工厂方法和抽象工厂。

在这三种细分的工厂模式中，简单工厂、工厂方法原理比较简单，在实际的项目中也比较常用。而抽象工厂的原理稍微复杂点，在实际的项目中相对也不常用。

1. 披萨规模化生产的需求

1.1 需求：pizza订购的问题

pizza的制作的步骤需要准备原材料，烘烤，切块，打包。每种pizza的制作原材料是不一样的。

图片

package com.evan.factory.simpleFactory;

/**
 * @Description
 * @ClassName Pizza
 * @Author Evan
 * @date 2019.11.27 23:44
 */
public abstract class Pizza {

    // pizza 的名字
    private String name;

    // 准备材料，不同的名字的pizza 材料不一样
    public abstract void prepare();


    public void bake() {
        System.out.println("烘烤");
    }

    // cut
    public void cut() {
        System.out.println("切分");
    }

    // box
    public void box() {
        System.out.println("打包");
    }


    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

public class GreekPizza  extends Pizza {
    @Override
    public void prepare() {
        System.out.println("greek pizza prepare");
    }
}

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("奶酪 prepare ");

    }

}

public class OrderPizza {

    public OrderPizza() {

        Pizza pizza = null;

        do {
            String pizzaType = getType();
            if (pizzaType.equals("greek")) {
                pizza = new GreekPizza();
                pizza.setName("greek");
            } else if (pizzaType.equals("cheese")) {
                pizza = new CheesePizza();
                pizza.setName("cheese");
            } else {
                break;
            }

            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        } while (true);
    }

    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza();
    }
}

通过定义Pizza抽象类将Pizza的制作过程定义出来。其他实现类GreekPizza、CheesePizza实现Pizza抽象类完成不同类型Pizza的创建。此处的抽象类Pizza相当于一个模版，定义了规范。

不好的地方就是OrderPizza中的创建Pizza的过程。是面上过程的，把Pizza的制作过程完全暴露给OrderPizza。Pizza不太符合面向对象中的封装特性。所以我们需要一个创建Pizza的类。

2 简单工厂（Simple Factory）

  1. 简单工厂模式：是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。
  2. 简单工厂模式：定义一个创建对象的类，由这个类来封装实例化对象的行为
  3. 在软件开发中，当我们会用到大量的创建某种，某类或者某批对象时，就会使用到工厂模式

图片

为了让代码逻辑更加清晰，可读性更好，我们要善于将功能独立的代码块封装成函数。按照这个设计思路，我们可以将代码中 createPizza 创建的部分逻辑剥离出来，抽象成 createPizza() 函数。

为了让类的职责更加单一、代码更加清晰，我们还可以进一步将 createPizza() 函数剥离到一个独立的类中，让这个类只负责对象的创建。而这个类就是我们现在要讲的简单工厂模式类。具体的代码如下所示：

package com.evan.factory.simpleFactory;

import com.evan.factory.CheesePizza;
import com.evan.factory.GreekPizza;
import com.evan.factory.Pizza;

/**
 * @Description
 * @ClassName SimpleFactory
 * @Author Evan
 * @date 2019.11.28 21:07
 */
public class SimpleFactory {


    // 根据pizzaType创建pizza
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("greek");
        } else if (pizzaType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName("cheese");
        }

        return pizza;
    }
}

大部分工厂类都是以“Factory”这个单词结尾的，但也不是必须的，比如 Java 中的 DateFormat、Calender。除此之外，工厂类中创建对象的方法一般都是 create 开头，比如代码中的 createParser()，但有的也命名为 getInstance()、createInstance()、newInstance()，有的甚至命名为 valueOf()（比如 Java String 类的 valueOf() 函数）等等，这个我们根据具体的场景和习惯来命名就好。

除此之外，在 SimpleFactory 的代码实现中，有一组 if 分支判断逻辑，是不是应该用多态或其他设计模式来替代呢？实际上，如果 if 分支并不是很多，代码中有 if 分支也是完全可以接受的。应用多态或设计模式来替代 if 分支判断逻辑，也并不是没有任何缺点的，它虽然提高了代码的扩展性，更加符合开闭原则，但也增加了类的个数，牺牲了代码的可读性。

package com.evan.factory;

import com.evan.factory.simpleFactory.SimpleFactory;

import java.io.BufferedReader;

import java.io.InputStreamReader;

/**
 * @Description
 * @ClassName OrderPizza
 * @Author Evan
 * @date 2019.11.27 23:59
 */
public class OrderPizza {


    SimpleFactory simpleFactory;

    Pizza pizza;

    public OrderPizza(SimpleFactory simpleFactory){
        setSimpleFactory(simpleFactory);
    }

    public void setSimpleFactory(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;

        do {
            String pizzaType = getType();
            // pizza的创建过程交给simpleFactory类来完成
            pizza = this.simpleFactory.createPizza(pizzaType);

            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        } while (true);

    }


    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza(new SimpleFactory());
    }
}

2.1 简单工厂模式又叫静态工厂模式

对SimpleFactory 进行重构，将SimpleFactory中的创建Pizza方法更改成静态方法。

public class SimpleFactory2 {

    // 根据pizzaType创建pizza
    public static Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("greek")) {
            pizza = new GreekPizza();
            pizza.setName("greek");
        } else if (pizzaType.equals("cheese")) {
            pizza = new CheesePizza();
            pizza.setName("cheese");
        }
        return pizza;
    }
}

public class OrderPizza2 {

    private Pizza pizza;

    public OrderPizza2(){
        do {
            String pizzaType = getType();
            pizza = SimpleFactory2.createPizza(pizzaType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        } while (true);
    }

pizza是在工厂类中创建完成的。

3 工厂方法模式

3.1 需求：

pizza项目中新的需求，可以点不同口味的pizza,比如北京口味的奶酪pizza,北京口味的胡椒pizza 伦敦口味的奶酪pizza.

3.2 代码实现

将pizza项目的实例化功能抽象成抽象方法，在不同的口味点餐子类中具体实现

工厂方法模式：定义一个创建对象的抽象方法，由子类决定要实例化的类，工厂方法模式将对象的实例化推迟到子类。

图片

public abstract class OrderPizza {
    public abstract Pizza createPizza(String pizzaType);

    public OrderPizza() {
        Pizza pizza;
        do {
            String pizzaType = getType();
            pizza = createPizza(pizzaType);
            if (pizza != null) {
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
            }
        } while (true);
    }


    private String getType() {
        try {
            BufferedReader strin = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("input pizza type");
            String str = strin.readLine();
            return str;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }
}

public class LDOrderPizza extends OrderPizza {

    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        // 创建伦敦 奶酪 pizza
        if (pizzaType.equals("ldcheese")) {
            pizza = new LDCheesePizza();
            pizza.setName("ldcheese");
        } 
        return pizza;
    }
}

public class BJOrderPizza extends OrderPizza {

    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        // 创建 北京 奶酪 pizza
        if (pizzaType.equals("bjcheese")) {
            pizza = new BJCheesePizza();
            pizza.setName("bjcheese");
        // 创建 北京 胡椒 pizza
        } else if (pizzaType.equals("bjpepper")) {
            pizza = new BJpepperPizza();
            pizza.setName("bjpepper");
        }
        return pizza;
    }
}

pizza 是在子类中具体实现

public class MainClass {

    public static void main(String[] args) {
        new BJOrderPizza();
    }
}

3.3 另一个demo

我们根据配置文件的后缀（json、xml、yaml、properties），选择不同的解析器（JsonRuleConfigParser、XmlRuleConfigParser……），将存储在文件中的配置解析成内存对象 RuleConfig。

public interface IRuleConfigParserFactory {
  IRuleConfigParser createParser();
}
public class JsonRuleConfigParserFactory implements IRuleConfigParserFactory {
  @Override
  public IRuleConfigParser createParser() {
    return new JsonRuleConfigParser();
  }
}
public class XmlRuleConfigParserFactory implements IRuleConfigParserFactory {
  @Override
  public IRuleConfigParser createParser() {
    return new XmlRuleConfigParser();
  }
}
public class YamlRuleConfigParserFactory implements IRuleConfigParserFactory {
  @Override
  public IRuleConfigParser createParser() {
    return new YamlRuleConfigParser();
  }
}
public class PropertiesRuleConfigParserFactory implements IRuleConfigParserFactory {
  @Override
  public IRuleConfigParser createParser() {
    return new PropertiesRuleConfigParser();
  }
}

实际上，这就是工厂方法模式的典型代码实现。这样当我们新增一种 parser 的时候，只需要新增一个实现了 IRuleConfigParserFactory 接口的 Factory 类即可。所以，工厂方法模式比起简单工厂模式更加符合开闭原则。

从上面的工厂方法的实现来看，一切都很完美，但是实际上存在挺大的问题。问题存在于这些工厂类的使用上。接下来，我们看一下，如何用这些工厂类来实现 RuleConfigSource 的 load() 函数。具体的代码如下所示：

public class RuleConfigSource {
  
    public RuleConfig load(String ruleConfigFilePath) {

        String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
        
        // 获取解析工厂类
        IRuleConfigParserFactory parserFactory = null;
        if ("json".equalsIgnoreCase(ruleConfigFileExtension)) {
          parserFactory = new JsonRuleConfigParserFactory();
        } else if ("xml".equalsIgnoreCase(ruleConfigFileExtension)) {
          parserFactory = new XmlRuleConfigParserFactory();
        } else if ("yaml".equalsIgnoreCase(ruleConfigFileExtension)) {
          parserFactory = new YamlRuleConfigParserFactory();
        } else if ("properties".equalsIgnoreCase(ruleConfigFileExtension)) {
          parserFactory = new PropertiesRuleConfigParserFactory();
        } else {
          throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }
        // 解析操作
        IRuleConfigParser parser = parserFactory.createParser();
        String configText = "";
        //从ruleConfigFilePath文件中读取配置文本到configText中
        RuleConfig ruleConfig = parser.parse(configText);
        return ruleConfig;
      }
      
      // 解析文件名获取扩展名
      private String getFileExtension(String filePath) {
        //...解析文件名获取扩展名，比如rule.json，返回json
        //...解析文件名获取扩展名，比如rule.xml，返回xml
      }
}

从上面的代码实现来看，工厂类对象的创建逻辑又耦合进了 load() 函数中，跟我们最初的代码版本非常相似，引入工厂方法非但没有解决问题，反倒让设计变得更加复杂了。那怎么来解决这个问题呢？

我们可以为工厂类再创建一个简单工厂，也就是工厂的工厂，用来创建工厂类对象。这段话听起来有点绕，我把代码实现出来了，你一看就能明白了。其中，RuleConfigParserFactoryMap 类是创建工厂对象的工厂类，getParserFactory() 返回的是缓存好的单例工厂对象。

public class RuleConfigSource {
  public RuleConfig load(String ruleConfigFilePath) {
    String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
    IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(ruleConfigFileExtension);
    if (parserFactory == null) {
      throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
    }
    IRuleConfigParser parser = parserFactory.createParser();
    String configText = "";
    //从ruleConfigFilePath文件中读取配置文本到configText中
    RuleConfig ruleConfig = parser.parse(configText);
    return ruleConfig;
  }
  private String getFileExtension(String filePath) {
    //...解析文件名获取扩展名，比如rule.json，返回json
    return "json";
  }
}


//因为工厂类只包含方法，不包含成员变量，完全可以复用，
//不需要每次都创建新的工厂类对象。
public class RuleConfigParserFactoryMap { //工厂的工厂
  private static final Map<String, IRuleConfigParserFactory> cachedFactories = new HashMap<>();
  static {
    cachedFactories.put("json", new JsonRuleConfigParserFactory());
    cachedFactories.put("xml", new XmlRuleConfigParserFactory());
    cachedFactories.put("yaml", new YamlRuleConfigParserFactory());
    cachedFactories.put("properties", new PropertiesRuleConfigParserFactory());
  }
  public static IRuleConfigParserFactory getParserFactory(String type) {
    if (type == null || type.isEmpty()) {
      return null;
    }
    IRuleConfigParserFactory parserFactory = cachedFactories.get(type.toLowerCase());
    return parserFactory;
  }
}

当我们需要添加新的规则配置解析器的时候，我们只需要创建新的 parser 类和 parser factory 类，并且在 RuleConfigParserFactoryMap 类中，将新的 parser factory 对象添加到 cachedFactories 中即可。代码的改动非常少，基本上符合开闭原则。

实际上，对于规则配置文件解析这个应用场景来说，工厂模式需要额外创建诸多 Factory 类，也会增加代码的复杂性，而且，每个 Factory 类只是做简单的 new 操作，功能非常单薄（只有一行代码），也没必要设计成独立的类，所以，在这个应用场景下，简单工厂模式简单好用，比工方法厂模式更加合适。

3.4 那什么时候该用工厂方法模式，而非简单工厂模

之所以将某个代码块剥离出来，独立为函数或者类，原因是这个代码块的逻辑过于复杂，剥离之后能让代码更加清晰，更加可读、可维护。但是，如果代码块本身并不复杂，就几行代码而已，我们完全没必要将它拆分成单独的函数或者类。

基于这个设计思想，当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。而使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂。

除此之外，在某些场景下，如果对象不可复用，那工厂类每次都要返回不同的对象。如果我们使用简单工厂模式来实现，就只能选择 if 分支逻辑的实现方式。如果我们还想避免烦人的 if-else 分支逻辑，这个时候，我们就推荐使用工厂方法模式。

4 抽象工厂模式

抽象工厂模式的应用场景比较特殊，没有前两种常用

简单工厂和工厂方法中，适合类只有一种分类方式。

比如，在规则配置解析那个例子中，解析器类只会根据配置文件格式（Json、Xml、Yaml……）来分类。但是，如果类有两种分类方式，比如，我们既可以按照配置文件格式来分类，也可以按照解析的对象（Rule 规则配置还是 System 系统配置）来分类，那就会对应下面这 8 个 parser 类。

针对规则配置的解析器：基于接口IRuleConfigParser
JsonRuleConfigParser
XmlRuleConfigParser
YamlRuleConfigParser
PropertiesRuleConfigParser

针对系统配置的解析器：基于接口ISystemConfigParser
JsonSystemConfigParser
XmlSystemConfigParser
YamlSystemConfigParser
PropertiesSystemConfigParser

针对这种特殊的场景，如果还是继续用工厂方法来实现的话，我们要针对每个 parser 都编写一个工厂类，也就是要编写 8 个工厂类。如果我们未来还需要增加针对业务配置的解析器（比如 IBizConfigParser），那就要再对应地增加 4 个工厂类。而我们知道，过多的类也会让系统难维护。这个问题该怎么解决呢？

抽象工厂就是针对这种非常特殊的场景而诞生的。我们可以让一个工厂负责创建多个不同类型的对象（IRuleConfigParser、ISystemConfigParser 等），而不是只创建一种 parser 对象。这样就可以有效地减少工厂类的个数。具体的代码实现如下所示：

public interface IConfigParserFactory {
  IRuleConfigParser createRuleParser();
  ISystemConfigParser createSystemParser();
  //此处可以扩展新的parser类型，比如IBizConfigParser
}

public class JsonConfigParserFactory implements IConfigParserFactory {
  @Override
  public IRuleConfigParser createRuleParser() {
    return new JsonRuleConfigParser();
  }
  @Override
  public ISystemConfigParser createSystemParser() {
    return new JsonSystemConfigParser();
  }
}

public class XmlConfigParserFactory implements IConfigParserFactory {
  @Override
  public IRuleConfigParser createRuleParser() {
    return new XmlRuleConfigParser();
  }
  @Override
  public ISystemConfigParser createSystemParser() {
    return new XmlSystemConfigParser();
  }
}
// 省略YamlConfigParserFactory和PropertiesConfigParserFactory代码

4.1 基于抽象工厂模式实现Pizza制作

图片

public interface AbsFactory {
    public abstract Pizza createPizza(String pizzaType);
}

public class LDPizzaFactory implements AbsFactory {

    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new LDCheesePizza();
            pizza.setName("ldcheese");
        } else if (pizzaType.equals("pepper")) {
            pizza = new LDpepperpizza();
            pizza.setName("ldpepper");
        }
        return pizza;
    }

}

public class BJPizzaFactory implements AbsFactory{


    @Override
    public Pizza createPizza(String pizzaType) {
        Pizza pizza = null;
        if (pizzaType.equals("cheese")) {
            pizza = new BJCheesePizza();
            pizza.setName("bjcheese");
        } else if (pizzaType.equals("pepper")) {
            pizza = new BJpepperPizza();
            pizza.setName("bjpepper");
        }
        return pizza;
    }
}

 public static void main(String[] args) {
        new OrderPizza(new BJPizzaFactory());
        new OrderPizza(new LDPizzaFactory());
    }

5 工厂模式小结

5.1 工厂模式的意义

将实例化对象的代码提出出来，放在一个类中统一管理维护，达到和主项目的依赖解耦。从而提高项目的扩展和维护性

  1. 三种工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）
  2. 设计模式的依赖抽象原则
    • 创建对象实例时，不要直接new类，而是把这个new类的动作放在一个工厂方法中，并返回。有的书上说，变量不要直接持有具体类的引用
    • 不要让类继承具体类，而是继承抽象类或者实现接口
    • 不要覆盖基类中已经实现的方法

5.2 什么时候使用工厂模式

当创建逻辑比较复杂，是一个“大工程”的时候，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。何为创建逻辑比较复杂呢？有下面两种情况。

  • 第一种情况：代码中存在 if-else 分支判断，动态地根据不同的类型创建不同的对象。针对这种情况，我们就考虑使用工厂模式，将这一大坨 if-else 创建对象的代码抽离出来，放到工厂类中。
  • 还有一种情况：尽管我们不需要根据不同的类型创建不同的对象，但是，单个对象本身的创建过程比较复杂，比如前面提到的要组合其他类对象，做各种初始化操作。在这种情况下，我们也可以考虑使用工厂模式，将对象的创建过程封装到工厂类中。

对于第一种情况，当每个对象的创建逻辑都比较简单的时候，推荐使用简单工厂模式，将多个对象的创建逻辑放到一个工厂类中。当每个对象的创建逻辑都比较复杂的时候，为了避免设计一个过于庞大的简单工厂类，推荐使用工厂方法模式，将创建逻辑拆分得更细，每个对象的创建逻辑独立到各自的工厂类中。同理，对于第二种情况，因为单个对象本身的创建逻辑就比较复杂，所以，我建议使用工厂方法模式。

除了刚刚提到的这几种情况之外，如果创建对象的逻辑并不复杂，那我们就直接通过 new 来创建对象就可以了，不需要使用工厂模式。

现在，我们上升一个思维层面来看工厂模式，它的作用无外乎下面这四个。这也是判断要不要使用工厂模式的最本质的参考标准。

  • 封装变化：创建逻辑有可能变化，封装成工厂类之后，创建逻辑的变更对调用者透明。
  • 代码复用：创建代码抽离到独立的工厂类之后可以复用。
  • 隔离复杂性：封装复杂的创建逻辑，调用者无需了解如何创建对象。
  • 控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。

作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

5.3 工厂模式的优缺点

优点：

  1. 一个调用者想创建一个对象，只要知道其名称就可以了。
  2. 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
  3. 屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：

每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

avatar
文章
阅读
粉丝