【设计模式】工厂模式

news2024/10/2 16:20:30

工厂模式

所谓工厂，顾名思义，就是创建出一类相似的产品的，工厂模式可以帮我们创建各个复杂/简单对象。属于创建型模式。

工厂模式分为三类:

简单工厂
工厂方法
抽象工厂

简单工厂

比方说我们需要根据配置文件去解析配置，不同后缀名的文件需要使用不同的解析器去解析，我们当然可以将所有的代码写在一个方法里
也可以使用简单工厂，将根据文件后缀名选择解析器的逻辑封装在工厂类中

定义一个IConfigParser接口，然后定义三个不同的解析器
在这里插入图片描述

public interface IConfigParser {
    Config parse(String configText);
}

public class JsonConfigParser implements IConfigParser{

    @Override
    public Config parse(String configText) {
        return new Config("json配置文件");
    }
}

public class PropertiesConfigParser implements IConfigParser{

    @Override
    public Config parse(String configText) {
        return new Config("properties配置文件");
    }
}

public class XmlConfigParser implements IConfigParser{

    @Override
    public Config parse(String configText) {
        return new Config("xml配置文件");
    }
}

public class ConfigParserFactory {

    public static IConfigParser createParser(String configFormat) {
        if ("json".equalsIgnoreCase(configFormat)) {
            return new JsonConfigParser();
        } else  if ("xml".equalsIgnoreCase(configFormat)) {
            return new XmlConfigParser();
        } else  if ("properties".equalsIgnoreCase(configFormat)) {
            return new PropertiesConfigParser();
        }
        return null;
    }
}

public class Config {

    private String name;

    public Config(String name) {
        this.name = name;
    }
}

工厂方法模式

简单工厂适合于创建逻辑比较的场景，如果每个解析器的构建过程都十分复杂，那是不是有一个单独的工厂类去创建各自的解析器会更合适。为了去除上面if … else …的分支判断，我们将工厂对象提前缓存好，其类图如下:
在这里插入图片描述

将上述代码重构后:

public interface IConfigParserFactory {
    IConfigParser createParse();
}

public class JsonConfigParserFactory implements IConfigParserFactory{

    @Override
    public IConfigParser createParse() {
        return new JsonConfigParser();
    }
}

public class XmlConfigParserFactory implements IConfigParserFactory{

    @Override
    public IConfigParser createParse() {
        return new XmlConfigParser();
    }
}

public class Test {

    private static final Map<String, IConfigParserFactory> factoryMap = new HashMap<>();

    static {
        factoryMap.put("json", new JsonConfigParserFactory());
        factoryMap.put("xml", new XmlConfigParserFactory());
    }

    public static void main(String[] args) {
        IConfigParser configParser = factoryMap.get("json").createParse();
        Config config = configParser.parse("{}");
    }
}

抽象工厂

抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。

在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。
所谓产品族，是指位于不同产品等级结构中，功能相关联的产品组成的家族。

以现实生活中的产品为例，我们有洗衣机，电风扇等电器，每种电器有各自的厂商，比方说美的的洗衣机、风扇，小米的洗衣机、风扇。我们认为一个品牌生产的东西是一个产品族的(美的的洗衣机和风扇都属于美的产品族)，不同工厂生产的一类产品认为是一个产品等级结构的。

而所谓的抽象工厂，就是提供一个创建一系列相关或者相互依赖的对象的接口。在抽象工厂中，每一个产品族都有一个具体工厂，而每一个具体工厂负责创建属于同一个产品族，但是属于不同产品等级结构的产品。

回到前面配置解析的例子，不同的文件格式的解析器不一样，但是相同的配置文件(eg,json配置文件)在不同的系统和不同的规则下的解析器也不一样。如果按照工厂方法模式的方式来实现，给每个文件格式和系统，规则都创建Factory接口，那么我们就需要创建N*N个工厂类了，这样代码就太臃肿了。

我们可以让一个工厂来帮忙创建不同的对象(Json工厂可以帮我们创建对应的system解析器和规则解析器)

实现如下：

public interface IConfigParserFactory {

    IRuleConfigParser createRuleParse();

    ISystemConfigParser createSystemParse();

}

public interface IRuleConfigParser {

    Config parse(String configText);
}

public interface ISystemConfigParser {

    Config parse(String configText);
}

public class JsonConfigParserFactory implements IConfigParserFactory {

    @Override
    public IRuleConfigParser createFileParse() {
        return new JsonRuleConfigParser();
    }

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

public class XmlConfigParserFactory implements IConfigParserFactory {

    @Override
    public IRuleConfigParser createFileParse() {
        return new XmlRuleConfigParser();
    }

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

总结:

简单工厂 ：专门定义一个类(Factory)来负责创建其它类的实例，被创建的实例通常都具有共同的父类或实现同一个接口。
工厂（方法）模式：定义一个用于创建对象的接口(工厂接口IConfigParserFactory)，让子类或实现去决定实例化哪个类。
抽象工厂模式 :提供接口给客户端用以创建一系列相关或者相互依赖的对象(往往会有一个可以创建多个产品等级结构的产品的工厂)