工厂模式

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

工厂模式分为三类:

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

简单工厂

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

定义一个IConfigParser接口，然后定义三个不同的解析器

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

public class JsonConfigParser implements IConfigParser{@Overridepublic Config parse(String configText) {return new Config("json配置文件");}
}

public class PropertiesConfigParser implements IConfigParser{@Overridepublic Config parse(String configText) {return new Config("properties配置文件");}
}

public class XmlConfigParser implements IConfigParser{@Overridepublic 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{@Overridepublic IConfigParser createParse() {return new JsonConfigParser();}
}

public class XmlConfigParserFactory implements IConfigParserFactory{@Overridepublic IConfigParser createParse() {return new XmlConfigParser();}
}

public class Test {private static final Map 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 {@Overridepublic IRuleConfigParser createFileParse() {return new JsonRuleConfigParser();}@Overridepublic ISystemConfigParser createSystemParse() {return new JsonSystemConfigParser();}
}

public class XmlConfigParserFactory implements IConfigParserFactory {@Overridepublic IRuleConfigParser createFileParse() {return new XmlRuleConfigParser();}@Overridepublic ISystemConfigParser createSystemParse() {return new XmlSystemConfigParser();}
}

总结:

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

使用场景:

1. 如果代码中存在大量 if-else 分⽀判断，需要动态地根据不同的类型创建不同的对象。这种情形我们就可以考虑使用工厂模式，将创建的逻辑抽离出来，放到工厂类中

2. 不需要根据不同类型创建不同的对象，但是如果对象的创建过程十分复杂，那么我们也可以将其 创建过程封装到工厂类中

如果创建逻辑比较简单，那么直接使用简单工厂就可以了；如果创建逻辑比较复杂，那么就建议使用工厂方法模式

工厂模式的作⽤⽆外乎下⾯四个。这也是判断要不要使⽤⼯⼚模式的最本质的参考标准。

1. 封装变化：创建逻辑有可能变化，封装成⼯⼚类之后，创建逻辑的变更对调⽤者透明。
2. 代码复⽤：创建代码抽离到独⽴的⼯⼚类之后可以复⽤。
3. 隔离复杂性：封装复杂的创建逻辑，调⽤者⽆需了解如何创建对象。
4. 控制复杂度：将创建代码抽离出来，让原本的函数或类职责更单⼀，代码更简洁。

实际使用的时候不必太在意使用的究竟是简单工厂还是工厂方法或者抽象工厂，只要通过工厂模式可以使我们的代码易于扩展和维护就好了，没必要过度设计。