40、工厂模式（上）

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

1、简单工厂

1.1、示例

根据配置文件的后缀（json、xml、yaml、properties），选择不同的解析器（JsonRuleConfigParser、XmlRuleConfigParser ...）
将文件中的配置解析成 RuleConfig

public class RuleConfigSource {

    public RuleConfig load(String ruleConfigFilePath) {
        String extension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParser parser = null;
        if ("json".equalsIgnoreCase(extension)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equalsIgnoreCase(extension)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equalsIgnoreCase(extension)) {
            parser = new YamlRuleConfigParser();
        } else if ("properties".equalsIgnoreCase(extension)) {
            parser = new PropertiesRuleConfigParser();
        } else {
            throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }

        // 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
        String configText = "";
        return parser.parse(configText);
    }

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

1.2、重构

为了让代码逻辑更加清晰，可读性更好，我们要善于将功能独立的代码块封装成函数
我们可以将代码中涉及 parser 创建的部分逻辑剥离出来，抽象成 createParser() 函数，重构之后的代码如下所示

public class RuleConfigSource {

    public RuleConfig load(String ruleConfigFilePath) {
        String extension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParser parser = createParser(extension);
        if (parser == null) {
            throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }

        // 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
        String configText = "";
        return parser.parse(configText);
    }

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

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

1.3、简单工厂一

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

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 class RuleConfigSource {

    public RuleConfig load(String ruleConfigFilePath) {
        String extension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParser parser = RuleConfigParserFactory.createParser(extension);
        if (parser == null) {
            throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }

        // 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
        String configText = "";
        return parser.parse(configText);
    }

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

1.4、简单工厂二

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

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

public class RuleConfigParserFactory {
    private static final Map<String, RuleConfigParser> cachedParsers = new HashMap<>();

    static {
        cachedParsers.put("json", new JsonRuleConfigParser());
        cachedParsers.put("xml", new XmlRuleConfigParser());
        cachedParsers.put("yaml", new YamlRuleConfigParser());
        cachedParsers.put("properties", new PropertiesRuleConfigParser());
    }

    public static IRuleConfigParser createParser(String configFormat) {
        if (configFormat == null || configFormat.isEmpty()) {
            return null; // 返回 null 还是 IllegalArgumentException 全凭你自己说了算
        }
        IRuleConfigParser parser = cachedParsers.get(configFormat.toLowerCase());
        return parser;
    }
}

1.5、总结

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

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

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

2、工厂方法

2.1、示例

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

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 类即可，所以工厂方法模式比起简单工厂模式更加符合开闭原则

2.2、问题

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

public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String extension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParserFactory parserFactory = null;
        if ("json".equalsIgnoreCase(extension)) {
            parserFactory = new JsonRuleConfigParserFactory();
        } else if ("xml".equalsIgnoreCase(extension)) {
            parserFactory = new XmlRuleConfigParserFactory();
        } else if ("yaml".equalsIgnoreCase(extension)) {
            parserFactory = new YamlRuleConfigParserFactory();
        } else if ("properties".equalsIgnoreCase(extension)) {
            parserFactory = new PropertiesRuleConfigParserFactory();
        } else {
            throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }
        IRuleConfigParser parser = parserFactory.createParser();

        // 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
        String configText = "";
        return parser.parse(configText);
    }

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

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

2.3、解决

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

// 因为工厂类只包含方法, 不包含成员变量, 工厂类的对象完全可以复用
// 不需要每次都创建新的工厂类对象, 所以简单工厂模式的第二种实现思路更加合适
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;
    }
}

public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) {
        String extension = getFileExtension(ruleConfigFilePath);

        IRuleConfigParserFactory parserFactory = RuleConfigParserFactoryMap.getParserFactory(extension);
        if (parserFactory == null) {
            throw new InvalidRuleConfigException("Rule config file format is not supported: " + ruleConfigFilePath);
        }
        IRuleConfigParser parser = parserFactory.createParser();

        // 从 ruleConfigFilePath 文件中读取配置文本到 configText 中
        String configText = "";
        return parser.parse(configText);
    }

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

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

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

3、简单工厂 VS 工厂方法

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

当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候
我们推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂
使用简单工厂模式，将所有的创建逻辑都放到一个工厂类中，会导致这个工厂类变得很复杂
在某些场景下，如果对象不可复用，那工厂类每次都要返回不同的对象
如果我们使用简单工厂模式来实现，就只能选择第一种包含 if 分支逻辑的实现方式
如果我们还想避免烦人的 if-else 分支逻辑，这个时候，我们就推荐使用工厂方法模式

4、抽象工厂

4.1、问题

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

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

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

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

4.2、解决

抽象工厂就是针对这种非常特殊的场景而诞生的
我们可以让一个工厂负责创建多个不同类型的对象（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();
    }
}

posted @ 2023-06-26 15:20 lidongdongdong~ 阅读(23) 评论(0) 编辑收藏举报

刷新页面返回顶部

lidong