工厂模式
定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法是一个类的实例化延迟到子类。
工厂方法可以解耦，降低代码的重复性。
工厂模式分类
- 简单工厂：静态工厂方法，一个模块仅需要一个工厂类， 没有必要把它产生出来。
- 工厂方法：多个工厂
- 抽象工厂：为创建一组相关或相互依赖的对象提供一个接口， 而且无须指定它们 的具体类。
代码：GitHub
简单工厂方法
一个模块仅需要一个工厂类， 没有必要把它产生出来， 使用静态的方法就可以了。在需要创建对象较少，调用者也比较简单时候使用。
缺点是工厂类的扩展比 较困难， 不符合开闭原则（可以通过反射方法创建实例）
定义一个动物类：
public class Animal {
public void howl() {}
}
定义一个猫类继承动物类：
public class Cat extends Animal{
@Override
public void howl() {
System.out.println("猫在喵喵叫");
}
}
定义一个狗继承动物类：
public class Dog extends Animal{
@Override
public void howl() {
System.out.println("狗在汪汪叫");
}
}
创建一个动物工厂：
public class AnimalFactory {
public static Object createAnimal(Class<? extends Animal> clazz){
Object obj = null;
try {
obj = Class.forName(clazz.getName()).newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}
}
工厂类通过反射方法创建实例。
工厂方法
不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说每个对象都有一个与之对应的工厂 。
优点：
- 调用者不需要知道具体产品类的类名，只需要知道它的工厂即可。
- 抽象工厂类只需要提供接口，由子类负责创建具体的对象。
缺点：
- 可扩展性和维护性不友好。如果要扩展一个产品类， 就需要建立一个相应的工厂类， 这样就增加了扩展的难度。 因为工厂类和产品类的数量相同， 维护时需要考虑两个对象之间的关系。
定义一个动物的抽象类：
public abstract class AbstractAnimal {
/**
* 所有动物都会叫，叫声不同
*/
public abstract void howl();
}
一个生产动物的工厂：
public interface AnimalFactory {
/**
* 获取一个动物
* @return
*/
AbstractAnimal createAnimal();
}
猫和狗的工厂：
public class CatFactory implements AnimalFactory {
@Override
public AbstractAnimal createAnimal() {
return new Cat();
}
}
public class DogFactory implements AnimalFactory {
@Override
public AbstractAnimal createAnimal() {
return new Dog();
}
}
抽象工厂方法
有多个业务类型和分类时候，可以用抽象工厂模式生产需要的对象。
抽象工厂和工厂方法的区别：
抽象工厂是生产对产品有结构划分的产品，工厂方法只生成单一产品。以猫和狗为例，现在要区分公母。也就是说有公猫和母猫，以及公狗和母狗。每个产品多了一层约束。
优点：
- 封装性。不关系对象如何创建。
- 产品族内约束为非公开状态，具体产品族内约束在工厂内实现。
缺点：
- 产品族扩展难。增加一个产品，抽象类就要多一个方法。但是产品等级扩展相对容易。例如动物工厂在增加一种性别类型，就要在多一个抽象工厂和实现类。如果要增加一种动物只需要增加一个子类就可以了。
工厂方法的扩展
1、代替单例模式，可以用简单工厂方法通过反射创建单例。该框架可以继续扩展， 在一个项目中可以 产生一个单例构造器， 所有需要产生单例的类都遵循一定的规则（构造方法是private） ， 然 后通过扩展该框架， 只要输入一个类型就可以获得唯一的一个实例。
public class Singleton {
private Singleton(){}
public void doSomething(){
System.out.println("工厂方法创建的单例模式");
}
}
通过简单工厂方法创建单例
public class SingletonFactory {
private static Singleton singleton;
static{
try {
Class cl= Class.forName(Singleton.class.getName());
//获得无参构造
Constructor constructor=cl.getDeclaredConstructor();
//设置无参构造是可访问的
constructor.setAccessible(true);
//产生一个实例对象
singleton = (Singleton)constructor.newInstance();
} catch (Exception e) {
//异常处理
System.out.println("异常");
}
}
public static Singleton getSingleton(){
return singleton;
}
}
2、延迟初始化：一个对象被消费完毕后， 并不立刻释放， 工厂类 保持其初始状态， 等待再次被使用。 延迟初始化是工厂方法模式的一个扩展应用。
public class ProductFactory {
private static final Map<String,Product> prMap = new HashMap<>();
public static synchronized Product createProduct(String type) throws Exception{
Product product =null;
//如果Map中已经有这个对象
if(prMap.containsKey(type)){
product = prMap.get(type);
}else{
if(type.equals("Product1")){
product = new ConcreteProduct1();
}else{
product = new ConcreteProduct2();}
//同时把对象放到缓存容器中
prMap.put(type,product);
}
return product;
}
}
延迟加载框架是可以扩展的， 例如限制某一个产品类的最大实例化数量， 可以通过判断 Map中已有的对象数量来实现， 这样的处理是非常有意义的， 例如JDBC连接数据库， 都会 要求设置一个MaxConnections最大连接数量， 该数量就是内存中最大实例化的数量。
延迟加载还可以用在对象初始化比较复杂的情况下， 例如硬件访问， 涉及多方面的交 互， 则可以通过延迟加载降低对象的产生和销毁带来的复杂性。
总结
工厂方法模式是new一个对象的替代品， 所以在所有需要生成对象的地方都可以使用， 但是需要慎重地考虑是否要增加一个工厂类进行管理， 增加代码的复杂度。
需要灵活的、 可扩展的框架时， 可以考虑采用工厂方法模式。 万物皆对象， 那万物也就皆产品类， 例如需要设计一个连接邮件服务器的框架， 有三种网络协议可供选择： POP3、 IMAP、 HTTP， 我们就可以把这三种连接方法作为产品类， 定义一个接口如 IConnectMail， 然后定义对邮件的操作方法， 用不同的方法实现三个具体的产品类（也就是 连接方式） 再定义一个工厂方法， 按照不同的传入条件， 选择不同的连接方式。
欢迎关注公众号：
