• 设计模式-02-工厂模式

           经典的设计模式有23种，但是常用的设计模式一般情况下不会到一半，我们就针对一些常用的设计模式进行一些详细的讲解和分析，方便大家更加容易理解和使用设计模式。

    1-简单介绍

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

    2-简单工厂（Simple Factory）

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

    1. public class RuleConfigSource {
    2.   public RuleConfig load(String ruleConfigFilePath) {
    3.     String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
    4.     IRuleConfigParser parser = null;
    5.     if ("json".equalsIgnoreCase(ruleConfigFileExtension)) {
    6.       parser = new JsonRuleConfigParser();
    7.     } else if ("xml".equalsIgnoreCase(ruleConfigFileExtension)) {
    8.       parser = new XmlRuleConfigParser();
    9.     } else if ("yaml".equalsIgnoreCase(ruleConfigFileExtension)) {
    10.       parser = new YamlRuleConfigParser();
    11.     } else if ("properties".equalsIgnoreCase(ruleConfigFileExtension)) {
    12.       parser = new PropertiesRuleConfigParser();
    13.     } else {
    14.       throw new InvalidRuleConfigException(
    15.              "Rule config file format is not supported: " + ruleConfigFilePath);
    16.     }
    17.  
    18.     String configText = "";
    19.     //从ruleConfigFilePath文件中读取配置文本到configText中
    20.     RuleConfig ruleConfig = parser.parse(configText);
    21.     return ruleConfig;
    22.   }
    23.  
    24.   private String getFileExtension(String filePath) {
    25.     //...解析文件名获取扩展名，比如rule.json，返回json
    26.     return "json";
    27.   }
    28. }

           为了让类的职责更加单一、代码更加清晰，IRuleConfigParser的创建功能抽取到独立的类中，让这个类只负责对象的创建。而这个类就是我们现在要讲的简单工厂模式类。

    1. public class RuleConfigSource {
    2.   public RuleConfig load(String ruleConfigFilePath) {
    3.     String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
    4.     IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
    5.     if (parser == null) {
    6.       throw new InvalidRuleConfigException(
    7.               "Rule config file format is not supported: " + ruleConfigFilePath);
    8.     }
    9.  
    10.     String configText = "";
    11.     //从ruleConfigFilePath文件中读取配置文本到configText中
    12.     RuleConfig ruleConfig = parser.parse(configText);
    13.     return ruleConfig;
    14.   }
    15.  
    16.   private String getFileExtension(String filePath) {
    17.     //...解析文件名获取扩展名，比如rule.json，返回json
    18.     return "json";
    19.   }
    20. }
    21.  
    22. public class RuleConfigParserFactory {
    23.   public static IRuleConfigParser createParser(String configFormat) {
    24.     IRuleConfigParser parser = null;
    25.     if ("json".equalsIgnoreCase(configFormat)) {
    26.       parser = new JsonRuleConfigParser();
    27.     } else if ("xml".equalsIgnoreCase(configFormat)) {
    28.       parser = new XmlRuleConfigParser();
    29.     } else if ("yaml".equalsIgnoreCase(configFormat)) {
    30.       parser = new YamlRuleConfigParser();
    31.     } else if ("properties".equalsIgnoreCase(configFormat)) {
    32.       parser = new PropertiesRuleConfigParser();
    33.     }
    34.     return parser;
    35.   }
    36. }

            我们每次调用RuleConfigParserFactory的createParser()的时候，都要创建一个新的parser。实际上，如果parser可以复用，为了节省内存和对象创建的时间，我们可以将parser事先创建好缓存起来。当调用createParser()函数的时候，我们从缓存中取出parser对象直接使用。

           这有点类似单例模式和简单工厂模式的结合，具体的代码实现如下所示。在接下来的讲解中，我们把上一种实现方法叫作简单工厂模式的第一种实现方法，把下面这种实现方法叫作简单工厂模式的第二种实现方法。

    1. public class RuleConfigParserFactory {
    2.   private static final Map cachedParsers = new HashMap<>();
    3.  
    4.   static {
    5.     cachedParsers.put("json", new JsonRuleConfigParser());
    6.     cachedParsers.put("xml", new XmlRuleConfigParser());
    7.     cachedParsers.put("yaml", new YamlRuleConfigParser());
    8.     cachedParsers.put("properties", new PropertiesRuleConfigParser());
    9.   }
    10.  
    11.   public static IRuleConfigParser createParser(String configFormat) {
    12.     if (configFormat == null || configFormat.isEmpty()) {
    13.       return null;//返回null还是IllegalArgumentException全凭你自己说了算
    14.     }
    15.     IRuleConfigParser parser = cachedParsers.get(configFormat.toLowerCase());
    16.     return parser;
    17.   }
    18. }

           尽管简单工厂模式的代码实现中，有多处if分支判断逻辑，违背开闭原则，但权衡扩展性和可读性，这样的代码实现在大多数情况下（比如，不需要频繁地添加parser，也没有太多的parser）是没有问题的。

    3-工厂方法（Factory Method）

           如果我们非得要将if分支逻辑去掉，那该怎么办呢？比较经典处理方法就是利用多态。按照多态的实现思路，对上面的代码进行重构。

    1. public interface IRuleConfigParserFactory {
    2.   IRuleConfigParser createParser();
    3. }
    4.  
    5. public class JsonRuleConfigParserFactory implements IRuleConfigParserFactory {
    6.   @Override
    7.   public IRuleConfigParser createParser() {
    8.     return new JsonRuleConfigParser();
    9.   }
    10. }
    11.  
    12. public class XmlRuleConfigParserFactory implements IRuleConfigParserFactory {
    13.   @Override
    14.   public IRuleConfigParser createParser() {
    15.     return new XmlRuleConfigParser();
    16.   }
    17. }
    18.  
    19. public class YamlRuleConfigParserFactory implements IRuleConfigParserFactory {
    20.   @Override
    21.   public IRuleConfigParser createParser() {
    22.     return new YamlRuleConfigParser();
    23.   }
    24. }
    25.  
    26. public class PropertiesRuleConfigParserFactory implements IRuleConfigParserFactory {
    27.   @Override
    28.   public IRuleConfigParser createParser() {
    29.     return new PropertiesRuleConfigParser();
    30.   }
    31. }

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

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

    1. public class RuleConfigSource {
    2.   public RuleConfig load(String ruleConfigFilePath) {
    3.     String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
    4.  
    5.     IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(ruleConfigFileExtension);
    6.     if (parserFactory == null) {
    7.       throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
    8.     }
    9.     IRuleConfigParser parser = parserFactory.createParser();
    10.  
    11.     String configText = "";
    12.     //从ruleConfigFilePath文件中读取配置文本到configText中
    13.     RuleConfig ruleConfig = parser.parse(configText);
    14.     return ruleConfig;
    15.   }
    16.  
    17.   private String getFileExtension(String filePath) {
    18.     //...解析文件名获取扩展名，比如rule.json，返回json
    19.     return "json";
    20.   }
    21. }
    22.  
    23. //因为工厂类只包含方法，不包含成员变量，完全可以复用，
    24. //不需要每次都创建新的工厂类对象，所以，简单工厂模式的第二种实现思路更加合适。
    25. public class RuleConfigParserFactoryMap { //工厂的工厂
    26.   private static final Map cachedFactories = new HashMap<>();
    27.  
    28.   static {
    29.     cachedFactories.put("json", new JsonRuleConfigParserFactory());
    30.     cachedFactories.put("xml", new XmlRuleConfigParserFactory());
    31.     cachedFactories.put("yaml", new YamlRuleConfigParserFactory());
    32.     cachedFactories.put("properties", new PropertiesRuleConfigParserFactory());
    33.   }
    34.  
    35.   public static IRuleConfigParserFactory getParserFactory(String type) {
    36.     if (type == null || type.isEmpty()) {
    37.       return null;
    38.     }
    39.     IRuleConfigParserFactory parserFactory = cachedFactories.get(type.toLowerCase());
    40.     return parserFactory;
    41.   }
    42. }

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

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

    4-如何选择 简单工厂 和工厂方法

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

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

    5-抽象工厂（Abstract Factory）

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

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

    1. public interface IConfigParserFactory {
    2.   IRuleConfigParser createRuleParser();
    3.   ISystemConfigParser createSystemParser();
    4.   //此处可以扩展新的parser类型，比如IBizConfigParser
    5. }
    6.  
    7. public class JsonConfigParserFactory implements IConfigParserFactory {
    8.   @Override
    9.   public IRuleConfigParser createRuleParser() {
    10.     return new JsonRuleConfigParser();
    11.   }
    12.  
    13.   @Override
    14.   public ISystemConfigParser createSystemParser() {
    15.     return new JsonSystemConfigParser();
    16.   }
    17. }
    18.  
    19. public class XmlConfigParserFactory implements IConfigParserFactory {
    20.   @Override
    21.   public IRuleConfigParser createRuleParser() {
    22.     return new XmlRuleConfigParser();
    23.   }
    24.  
    25.   @Override
    26.   public ISystemConfigParser createSystemParser() {
    27.     return new XmlSystemConfigParser();
    28.   }
    29. }
    30.  
    31. // 省略YamlConfigParserFactory和PropertiesConfigParserFactory代码

    5-判断标准

    判断要不要使用工厂模式的最本质的参考标准：

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

    6-小结

           第一种情况：类似规则配置解析的例子，代码中存在if-else分支判断，动态地根据不同的类型创建不同的对象。针对这种情况，我们就考虑使用工厂模式，将这一大坨if-else创建对象的代码抽离出来，放到工厂类中。
           还有一种情况，尽管我们不需要根据不同的类型创建不同的对象，但是，单个对象本身的创建过程比较复杂，比如前面提到的要组合其他类对象，做各种初始化操作。在这种情况下，我们也可以考虑使用工厂模式，将对象的创建过程封装到工厂类中。
            对于第一种情况，当每个对象的创建逻辑都比较简单的时候，我推荐使用简单工厂模式，将多个对象的创建逻辑放到一个工厂类中。当每个对象的创建逻辑都比较复杂的时候，为了避免设计一个过于庞大的简单工厂类，我推荐使用工厂方法模式，将创建逻辑拆分得更细，每个对象的创建逻辑独立到各自的工厂类中。
           同理，对于第二种情况，因为单个对象本身的创建逻辑就比较复杂，所以，我建议使用工厂方法模式。
           除了刚刚提到的这几种情况之外，如果创建对象的逻辑并不复杂，那我们就直接通过new来创建对象就可以了，不需要使用工厂模式。

    ps:比如Java中的Calendar、DateFormat类等，都采用了工厂模式。

  • 相关阅读:
    服务号升级为订阅号的方法
    java 八股文 基础 每天笔记随机刷
    【考研复习】《操作系统原理》孟庆昌等编著课后习题+答案——第三章
    [附源码]计算机毕业设计基于SpringBoot文曦家教预约系统
    Element实现行合并
    dom——防抖与节流
    分类、回归算法简单介绍
    102.(前端)分类管理增加窗口显示——dialog弹窗的基本使用与在form表单显示变量
    今天起，Windows可以一键召唤GPT-4了
    springmvc 的web.xml 中无法解析org.springframework.web.servlet.DispatcherServlet爆红解决方法
  • 原文地址：https://blog.csdn.net/ycmy2017/article/details/134334060