设计模式学习笔记 - 设计模式与范式 - 创建型:4.工厂模式(上):工厂模式的介绍和使用场景分析

概述

一般情况下工厂模式分为三种更加细分的类型:简单工厂、工厂方法和抽象工厂。

在三种细分的工厂模式中,简单工厂、工厂方法原理比较简单,在实际的项目中也比较常用。而抽象工厂的原理稍微有点复杂,在实际的项目中也相对不常用。所以,重点讲解前两种工厂模式。


简单工厂(Simple Factory)

我们通过一个例子来解释下简单工厂模式。下面这段代码中,根据配置文件的后缀(json、xml、yaml、properties),选择不同的解析器,将存储在文件中的配置解析成内存对象 RuleConfig。

java 复制代码
public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
        IRuleConfigParser parser = null;
        if ("json".equals(ruleConfigFileExtension)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equals(ruleConfigFileExtension)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equals(ruleConfigFileExtension)) {
            parser = new YamlRuleConfigParser();
        } else if ("properties".equals(ruleConfigFileExtension)) {
            parser = new PropertiesRuleConfigParser();
        } else {
            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";
    }
}

在 "规范和重构" 那部分文章中,我们讲到,为了让代码逻辑更加清晰,可读性更好,要善于将功能独立的代码封装成函数。按照这个设计思路,我们可以将涉及 parser 创建的那部分逻辑剥离出来,抽象成 createParser() 函数。重构之后的代码如下:

java 复制代码
public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
        IRuleConfigParser parser = 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";
    }

    private IRuleConfigParser createParser(String configFormat) {
        IRuleConfigParser parser = null;
        if ("json".equals(configFormat)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equals(configFormat)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equals(configFormat)) {
            parser = new YamlRuleConfigParser();
        } else if ("properties".equals(configFormat)) {
            parser = new PropertiesRuleConfigParser();
        }
        return parser;
    }
}

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

java 复制代码
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".equals(configFormat)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equals(configFormat)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equals(configFormat)) {
            parser = new YamlRuleConfigParser();
        } else if ("properties".equals(configFormat)) {
            parser = new PropertiesRuleConfigParser();
        }
        return parser;
    }
}

大部分工厂类都是以 "Factory" 这个单词结尾的,但也不是必须的,比如 Java 中的 DateFormarCalendar。此外,工厂可以做工创建对象的方法一般都是以 create 开头,比如代码中的 createParser(),但有的也命名为 getInstance()createInstance()newInstance() ,有的甚至命名为 valueOf() 等等,这个我们根据具体的场景和习惯来命名就好。

在上面的代码实现中,每次调用 RuleConfigParserFactorycreateParser() 时,都要创建一个新的 parser。实际上,如果 parser 可以复用,为了节省内存和对象创建的时间,可以将 parser 事先创建好缓存起来。当调用 createParser() 时,从缓存中取出 parser 对象直接使用。

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

java 复制代码
public class RuleConfigParserFactory {
    private static final Map<String, IRuleConfigParser> cachedParser = new HashMap<>();
    
    static {
        cachedParser.put("json", new JsonRuleConfigParser());
        cachedParser.put("xml", new XmlRuleConfigParser());
        cachedParser.put("yaml", new YamlRuleConfigParser());
        cachedParser.put("properties", new PropertiesRuleConfigParser());
    }
    
    public static IRuleConfigParser createParser(String configFormat) {
        if (configFormat == null || configFormat.isEmpty()) {
            return null;
        }
        IRuleConfigParser parser = cachedParser.get(configFormat);
        return parser;
    }
}

对于上面两种简单工厂模式的实现方法,如果要添加新的 parser,那势必要改动到 RuleConfigParserFactory 的代码,那这是不是违反开闭原则呢?实际上,如果不是需要频繁地添加新的 parser,只是偶尔修改一下 RuleConfigParserFactory 的代码,也是可以接受的。

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

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

工厂方法(Factory Method)

如果我们非要将 if 分支逻辑去掉,那该怎么办被? 比较经典处理方法就是利用多态。按照多态的实现思路,对上面的代码进行重构。重构之后的代码如下所示:

java 复制代码
public interface IRuleConfigParseFactory {
    IRuleConfigParser createParser();
}

public class JsonRuleConfigParserFactory implements IRuleConfigParseFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new JsonRuleConfigParser();
    }
}

public class XmlRuleConfigParserFactory implements IRuleConfigParseFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new XmlRuleConfigParser();
    }
}

public class YamlRuleConfigParserFactory implements IRuleConfigParseFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new YamlRuleConfigParser();
    }
}

public class PropertiesRuleConfigParserFactory implements IRuleConfigParseFactory {
    @Override
    public IRuleConfigParser createParser() {
        return new PropertiesRuleConfigParser();
    }
}

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

从上面的工厂方法的实现来看,一切都很完美,但实际上存在挺大的问题。问题存在于这些工厂的使用上。接下来,一起看下如何用这些工厂类来实现 RuleConfigSourceload() 函数。

java 复制代码
public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String ruleConfigFilePathExtension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParseFactory parseFactory = null;
        if ("json".equals(ruleConfigFilePathExtension)) {
            parseFactory = new JsonRuleConfigParserFactory();
        } else if ("xml".equals(ruleConfigFilePathExtension)) {
            parseFactory = new XmlRuleConfigParserFactory();
        } else if ("yaml".equals(ruleConfigFilePathExtension)) {
            parseFactory = new YamlRuleConfigParserFactory();
        } else if ("properties".equals(ruleConfigFilePathExtension)) {
            parseFactory = new PropertiesRuleConfigParserFactory();
        }else {
            throw new InvalidRuleConfigException(
                    "Rule config file format is not supported: " + ruleConfigFilePath);
        }

        IRuleConfigParser parser = parseFactory.createParser();
        String configText = "";
        // 从ruleConfigFilePath文件中读取配置文件到configText中
        RuleConfig ruleConfig = parser.parse(configText);
        return ruleConfig;
    }

    private String getFileExtension(String filePath) {
        // ...解析文件名获取扩展名,比如 rule.json,返回json
        return "json";
    }
}

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

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

java 复制代码
public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String ruleConfigFilePathExtension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParseFactory parseFactory = RuleConfigParserFactoryMap.getParseFactory(ruleConfigFilePathExtension);
        if (parseFactory == null) {
            throw new InvalidRuleConfigException(
                    "Rule config file format is not supported: " + ruleConfigFilePath);
        }

        IRuleConfigParser parser = parseFactory.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, IRuleConfigParseFactory> cachedFactories = new HashMap<>();

    static {
        cachedFactories.put("json", new JsonRuleConfigParserFactory());
        cachedFactories.put("xml", new XmlRuleConfigParserFactory());
        cachedFactories.put("yaml", new JsonRuleConfigParserFactory());
        cachedFactories.put("properties", new PropertiesRuleConfigParserFactory());
    }

    public static IRuleConfigParseFactory getParseFactory(String type) {
        if (type == null || type.isEmpty()) {
            return null;
        }
        IRuleConfigParseFactory parseFactory = cachedFactories.get(type);
        return parseFactory;
    }
}

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

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

什么时候该用工厂方法模式,而非简单工厂模式呢?

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

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

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

抽象工厂(Abstract Factory)

讲完了简单工厂、工厂方法,我们再来看下抽象工厂模式。抽象工厂模式的应用场景比较特殊,没有前两种常用,所以不是本节学习的重点,简单了解一下就好。

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

java 复制代码
针对规则配置的解析器:基于接口 IRuleConfigParser
JsonRuleConfigParser
XmlRuleConfigParser
YamlRuleConfigParser
PropertiesRuleConfigParser

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

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

抽象工厂就是针对这种特殊的场景而诞生的。我们可以让一个工厂负责创建多个不同类型的对象(IRuleConfigParserISystemConfigParser 等),而不是只创建一种 parser 对象。这样就可以有效的减少工厂类的个数。具体的实现代码如下所示:

java 复制代码
public interface IConfigParseFactory {
    IRuleConfigParser createRuleParser();
    ISystemConfigParser createSystemParser();
}

public class JsonConfigParserFactory implements IConfigParseFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new JsonRuleConfigParser();
    }

    @Override
    public ISystemConfigParser createSystemParser() {
        return new JsonSystemConfigParser();
    }
}

public class XmlConfigParserFactory implements IConfigParseFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new XmlRuleConfigParser();
    }

    @Override
    public ISystemConfigParser createSystemParser() {
        return new XmlSystemConfigParser();
    }
}

public class YamlConfigParserFactory implements IConfigParseFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new YamlRuleConfigParser();
    }

    @Override
    public ISystemConfigParser createSystemParser() {
        return new YamlSystemConfigParser();
    }
}

public class PropertiesConfigParserFactory implements IConfigParseFactory {
    @Override
    public IRuleConfigParser createRuleParser() {
        return new PropertiesRuleConfigParser();
    }

    @Override
    public ISystemConfigParser createSystemParser() {
        return new PropertiesSystemConfigParser();
    }
}

总结

今天讲的三种工厂模式中,简单工厂和工厂方法比较常用,抽象工厂的应用场景比较特殊,所以很少用到。下面只对前两种工厂模式的应用场景进行总结。

当创建逻辑比较复杂,是一个 "大工程" 时,我们就考虑使用工厂模式,封装对象的创建过程,将对象的创建和使用逻辑分离。何为创建逻辑比较复杂呢?

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

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

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

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

  • 封装变化:创建逻辑有可能变化,封装成工厂类之后,创建逻辑的变更对调用者透明。
  • 代码复用:创建代码抽离到独立的工厂类之后可以复用。
  • 隔离复杂性:封装复杂的创建逻辑,调用者无需了解如何创建对象。
  • 控制复杂度:将创建代码抽离出来,让原本的函数或类职责更单一,代码更简洁。
相关推荐
小白不太白95027 分钟前
设计模式之 模板方法模式
java·设计模式·模板方法模式
色空大师1 小时前
23种设计模式
java·开发语言·设计模式
闲人一枚(学习中)1 小时前
设计模式-创建型-建造者模式
java·设计模式·建造者模式
博风2 小时前
设计模式:6、装饰模式(包装器)
设计模式
A_cot2 小时前
理解设计模式与 UML 类图:构建稳健软件架构的基石
microsoft·设计模式·简单工厂模式·工厂方法模式·uml
君败红颜2 小时前
设计模式之创建模式篇
设计模式
闲人一枚(学习中)5 小时前
设计模式-创建型-抽象工厂模式
设计模式·抽象工厂模式
小白不太白9507 小时前
设计模式之 观察者模式
观察者模式·设计模式
小白不太白9508 小时前
设计模式之 责任链模式
python·设计模式·责任链模式
吾与谁归in9 小时前
【C#设计模式(13)——代理模式(Proxy Pattern)】
设计模式·c#·代理模式