一工厂模式

1.1 工厂模式定义

工厂模式包括简单工厂、工厂方法和抽象工厂三个部分。其中，简单工厂可以看作工厂方法的一种特例形式。

1.2 工厂模式的作用

将类的创建与类的使用分离，职责单一，减少代码的复杂度，降低代码的耦合性，增加代码的可读性和可扩展性。

封装变化。如果逻辑有可能变化，封装成工厂类之后，创建逻辑的变更不会影响调用者。
代码复用。创建代码抽离到单独的工厂类之后可以复用。
隔离复杂性。封装复杂的创建逻辑，调用者无需知道对象是如何创建的。
控制复杂度。将创建代码抽离出来，让原本的函数或类职责更单一，代码更简洁。

1.3 工厂模式的经典实现

简单工厂

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

特点：使用一个工厂类和一个方法来通过传入参数的不同类型来创建对应的对象。

工厂方法

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

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

特点：每一个对象的创建都对应一个工厂类，然后，添加一个工厂管理类来对所有工厂来进行管理，也就是工厂的工厂。很多时间，每一个对象的创建都对应一个工厂类，而工厂类中又只是创建一个对象，功能相对会比较单薄，直接用简单工厂更加合适。

抽象工厂

什么时候使用抽象工厂？
如果类的分类方式大于或等于 2 时，使用抽象工厂实现方式，可以避免工厂方法实现中工厂类膨胀的问题。
总的来说就是让一个工厂负责多个不同类型对象的创建工作。

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代码

1.4 什么时候用简单工厂，什么时候用工厂方法，什么时候使用抽象工厂？

使用简单工厂的场景

一般需要工厂来创建的对象，逻辑并不复杂，通常只需要几行代码或者直接 new 出来就完成了创建。这种情况下，直接使用简单工厂比较合适。

一句话概括：对象的初始化比较简单，通过 new 就可以搞定的情况。

使用工厂方法的场景

当对象的创建逻辑比较复杂，不是简单使用 new 一下就可以，而是要依赖其它的类，做各种初始化的时候，推荐使用工厂方法模式。

还有一种是如果每次创建的对象都是不同的，不需要复用的情况下，如果想避免烦人的 if-else 分支逻辑，这个时候就可以使用工厂模式实现（通过在工厂的工厂中缓存创建对象所对应的工厂类，然后，直接通过类型来获取对应的工厂类，工厂类里面的实现是直接通过 new 来创建的）。

一名话概括：对象的创建比较复杂，需要依赖很多外部类，并且初始化过程比较复杂的情况。

使用抽象工厂的场景

如果类的分类方式大于或等于 2 时，使用抽象工厂实现方式，可以避免工厂方法实现中工厂类膨胀的问题。

总的来说就是让一个工厂负责多个不同类型对象的创建工作。

一句话概括：对象的创建分为 2 个或以上的维度（分类）

一 工厂模式