工厂模式

设计模式

本系列文章均是博主原创，意在记录学习上的知识，同时一起分享学习心得。

24种设计模式

---

前言

本节介绍简单工厂模式。

---

一、概念

当创建逻辑/创建对象比较复杂时，是一个“大工程”，我们就考虑使用工厂模式，封装对象的创建过程，将对象的创建和使用相分离。

二、实现方式

工厂模式大致有三种实现方式：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

2.1 简单工厂模式

当每个对象创建逻辑都比较简单时，推荐使用简单工厂模式，将多个对象的创建逻辑放到一个工厂类中。

代码如下（示例）：

public class SimpleFactory {

    public static IParser createParser(String flag) {
        IParser parser = null;
        if ("json".equals(flag)) {
            parser = new JsonParser();
        } else if ("xml".equals(flag)){
            parser = new XmlParser();
        } else if ("properties".equals(flag)){
            parser = new PropertiesParser();
        } else if ("yml".equals(flag)){
            parser = new YmlParser();
        }
        return parser;
    }
}

@Test
public void simpleFactoryTest() {
    IParser parser = SimpleFactory.createParser("yml");
    String str = parser.parse();
    System.out.println(str);
}

2.2 工厂方法模式

当每个对象创建逻辑都比较复杂时，推荐使用工厂方法模式。
代码如下（示例）：

public class FunctionFactory {

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

    static {
        factoryMap.put("json", new JsonParserFactory());
        factoryMap.put("xml", new XmlParserFactory());
        factoryMap.put("properties", new PropertiesParserFactory());
        factoryMap.put("yml", new YmlParserFactory());
    }

    public static IParserFactory getParserFactory(String type) {
        if (type == null || type.isEmpty()) {
            return null;
        }
        IParserFactory parserFactory = factoryMap.get(type);
        return parserFactory;
    }
}

@Test
public void functionFactoryTest() {
    IParserFactory parserFactory = FunctionFactory.getParserFactory("xml");
    IParser parser = parserFactory.createParser();
    System.out.println(parser.parse());

}

2.3 抽象工厂模式

如果一个类有多种分类方式，就会过多的类，让系统难以维护。抽象工厂模式就是为了解决这种情况，让一个工厂负责创建多个不同类型的对象，而不是只创建一种对象，这样就有效地减少了工厂类的个数。

示例代码：

public interface IParserFactory {

    IRuleParser createRuleParser();

    ISysParser createSysParser();
}

public class JsonParserFactory implements IParserFactory {
    @Override
    public IRuleParser createRuleParser() {
        return new JsonRuleParser();
    }

    @Override
    public ISysParser createSysParser() {
        return new JsonSysParser();
    }
}

public class AbstFactory {

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

    static {
        factoryMap.put("json", new JsonParserFactory());
    }

    public static IParserFactory getParserFactory(String type) {
        if (type == null || type.isEmpty()) {
            return null;
        }
        IParserFactory parserFactory = factoryMap.get(type);
        return parserFactory;
    }
}

@Test
public void abstFactoryTest() {
    com.create.factory.abst.IParserFactory iParserFactory = AbstFactory.getParserFactory("json");
    IRuleParser ruleParser = iParserFactory.createRuleParser();
    ISysParser sysParser = iParserFactory.createSysParser();

    System.out.println(ruleParser.parse());
    System.out.println(sysParser.parse());
}

---

总结

本章仅仅简单的介绍了工厂模式的使用场景，已经实现方式。