为什么大厂面试官喜欢问工厂模式

我们在写一些业务时，免不了new对象，如果不停地写到业务代码里，那会逐渐变成屎山。今天我们就用工厂模式来优化创建对象。

简单工厂模式

首先，我们来看一个解析配置文件的案例，下面这段代码中我们根据配置文件的后缀（json、xml、yaml）选择不同的解析器，解析完内容后返回配置类RuleConfig，代码风格比较粗放。

public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) throws InvalidRuleConfigException {
        String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
        IRuleConfigParser parser = null;
        if ("json".equalsIgnoreCase(ruleConfigFileExtension)) {
            parser = new JsonRuleConfigParser();
        } else if ("xml".equalsIgnoreCase(ruleConfigFileExtension)) {
            parser = new XmlRuleConfigParser();
        } else if ("yaml".equalsIgnoreCase(ruleConfigFileExtension)) {
            parser = new YamlRuleConfigParser();
        } else {
            throw new InvalidRuleConfigException();
        }
        String configText = "";
        // 从ruleConfigFilePath文件中读取配置文本到configText中
        var ruleConfig = parser.parse(configText);
        return ruleConfig;
    }

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

为了提升代码的复用性，我们把它改造成简单工厂模式，将创建parser 的逻辑放到RuleConfigParserFactory工厂类中。

public class RuleConfigSource {
    public RuleConfig load(String ruleConfigFilePath) throws InvalidRuleConfigException {
        String ruleConfigFileExtension = getFileExtension(ruleConfigFilePath);
        IRuleConfigParser parser = RuleConfigParserFactory.createParser(ruleConfigFileExtension);
        String configText = "";
        // 从ruleConfigFilePath文件中读取配置文本到configText中
        var 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) throws InvalidRuleConfigException{
        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 {
            throw new InvalidRuleConfigException();
        }
        return parser;
    }
}

实际上，这个工厂类还能进一步优化。我们去掉if-else的判断，直接用一个HashMap提前加载好各个parser，代码如下。

import java.util.HashMap;
import java.util.Map;

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

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

    public static IRuleConfigParser createParser(String configFormat) {
        IRuleConfigParser parser = cachedParsers.get(configFormat.toLowerCase());
        return parser;
    }
}

工厂模式

如果parser初始化的过程较为复杂，那就必须用工厂模式来抽离逻辑。为了减少大家的审美疲劳，我们换个例子来讲工厂模式。

下面这个例子实现了创建浏览器驱动的功能，如果用简单工厂模式实现，那么会把所有浏览器的繁杂初始化流程集中到create()中，代码复用性很差。

我们用工厂模式把各家浏览器创建驱动的流程抽离到各自的工厂中去，职责清晰。

public class Demo {

    interface Driver {}

    interface AbstractFactory {
        public Driver create();
    }

    // 具体工厂 负责Chrome浏览器驱动的创建
    static class ChromeDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new ChromeDriver(initParams);
        }
    }

    // 具体工厂 负责Firefox浏览器驱动的创建
    static class FirefoxDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new FirefoxDriver(initParams);
        }
    }

    // 具体工厂 负责Safari浏览器驱动的创建
    static class SafariDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new SafariDriver(initParams);
        }
    }

    public static void main(String[] args) {
        // 创建 Chrome 驱动
        ChromeDriverFactory chromeDriverFactory = new ChromeDriverFactory();
        Driver chromeDriver = chromeDriverFactory.create();

        // 创建 Firefox 驱动
        FirefoxDriverFactory firefoxDriverFactory = new FirefoxDriverFactory();
        Driver firefoxDriver = firefoxDriverFactory.create();

        // ...
    }
}

抽象工厂模式

随着需求的变更，我们在上述的案例中加了一个新的功能，需要产出不同版本的Driver，显然写新的Factory会徒增3个类。我们用抽象工厂模式来实现，其中AbstractFactory定义接口，具体工厂实现接口，如此一来拓展了工厂的产品线。

public class Demo {
    // 抽象工厂 所有工厂的公共接口
    public interface AbstractFactory {
        Driver create();
        NewDriver createNewDriver();
    }

    // 具体工厂 负责Chrome浏览器驱动的创建
    static class ChromeDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new ChromeDriver(initParams);
        }
        
        @Override
        public Driver createNewDriver() {
            var initParams = ...
            return new ChromeDriver(initParams);
        }
    }

    // 具体工厂 负责Firefox浏览器驱动的创建
    static class FirefoxDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new FirefoxDriver(initParams);
        }
        
        @Override
        public Driver createNewDriver() {
            var initParams = ...
            return new ChromeDriver(initParams);
        }
    }

    // 具体工厂 负责Safari浏览器驱动的创建
    static class SafariDriverFactory implements AbstractFactory {
        @Override
        public Driver create() {
            var initParams = ...
            return new SafariDriver(initParams);
        }
        
        @Override
        public Driver createNewDriver() {
            var initParams = ...
            return new ChromeDriver(initParams);
        }
    }
    
     public static void main(String[] args) {
        // 创建 Chrome 驱动，如果需 FireFox 驱动，直接替换即可。
        DriverFactory driverFactory = new ChromeDriverFactory();
        Driver driver = driverFactory.create();
    }
}

总结

总的来说，简单工厂模式抽离了集中new对象的逻辑，工厂模式抽离了new对象中初始化的逻辑，而抽象工厂抽离了创建工厂的逻辑。工程中最实用的还是抽象工厂模式，比如Spring中的BeanFactory。