设计模式3-工厂模式

工厂模式（Factory Design Pattern）分类：简单工厂、工厂方法和抽象工厂。

之所以将某个代码块剥离出来，独立为函数或者类，原因是这个代码块的逻辑过于复杂，剥离之后能让代码更加清晰，更加可读、可维护。

应用场景：
什么时候该用工厂模式？
相对于直接 new 来创建对象，用工厂模式来创建究竟有什么好处呢？

1. 简单工厂

Code 如下：

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

2. 工厂方法（Factory Method）

如果我们非得要将 if 分支逻辑去掉，那该怎么办呢？比较经典处理方法就是利用多态。

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

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;  }}

3. 抽象工厂（Abstract Factory）

3.1 示例1

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

针对这种特殊的场景，如果还是继续用工厂方法来实现的话，我们要针对每个 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代码

3.2 示例2

https://blog.csdn.net/konglon...
抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类.

举个例子吧，就拿键盘和鼠标来说吧，键盘和鼠标就是一些列的类。而键盘鼠标又有微软的和联想的区别。所以有了微软的工厂和联想的工厂。键盘和鼠标具体的创建由工厂来负责，而具体创建微软的还是联想的则由客户端来指定，而客户端根本不用知道鼠标和键盘这些类。此例的示例代码如下：

// AbstractFactoryModel.h文件#pragma once#include <iostream>// 1 --- 键盘// 键盘class KeyBoard{public:    virtual void show() = 0;};// 微软的键盘class KeyBoardMicro : public KeyBoard{public:    void show()    {        std::cout << "微软的键盘" << std::endl;    }};// 联想的键盘class KeyBoardLenovo : public KeyBoard{public:    void show()    {        std::cout << "联想的键盘" << std::endl;    }};// 2 --- 鼠标// 鼠标class Mouse{public:    virtual void show() = 0;};class MouseMicro : public Mouse{public:    void show()    {        std::cout << "微软的鼠标" << std::endl;    }};class MouseLenovo : public Mouse{public:    void show()    {        std::cout << "联想的鼠标" << std::endl;    }};// 3 --- 工厂// 工厂class Factory{public:    virtual KeyBoard * createKeyBoard() = 0;    virtual Mouse * createMouse() = 0;};// 微软的工厂class FactoryMicro : public Factory{public:    KeyBoard * createKeyBoard()    {        return new KeyBoardMicro();    }    Mouse * createMouse()    {        return new MouseMicro();    }};// 联想的工厂class FactoryLenovo : public Factory{public:    KeyBoard * createKeyBoard()    {        return new KeyBoardLenovo();    }    Mouse * createMouse()    {        return new MouseLenovo();    }};

测试代码如下：

#include <iostream>#include "AbstractFactoryModel.h"int main(){    using namespace std;    // 抽象工厂模式    Factory * p = new FactoryMicro();    KeyBoard * pKeyBoard = p->createKeyBoard();    Mouse * pMouse = p->createMouse();    pKeyBoard->show();    pMouse->show();    delete pMouse;    delete pKeyBoard;    delete p;    p = new FactoryLenovo();    pKeyBoard = p->createKeyBoard();    pMouse = p->createMouse();    pKeyBoard->show();    pMouse->show();    delete pMouse;    delete pKeyBoard;    delete p;    getchar();    return 0;}