工厂模式

定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法是一个类的实例化延迟到子类。

工厂方法可以解耦，降低代码的重复性。

工厂模式分类

简单工厂：静态工厂方法，一个模块仅需要一个工厂类，没有必要把它产生出来。
工厂方法：多个工厂
抽象工厂：为创建一组相关或相互依赖的对象提供一个接口，而且无须指定它们的具体类。

代码：GitHub

简单工厂方法

一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态的方法就可以了。在需要创建对象较少，调用者也比较简单时候使用。

缺点是工厂类的扩展比较困难，不符合开闭原则（可以通过反射方法创建实例）

定义一个动物类：

1
2
3

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，然后定义对邮件的操作方法，用不同的方法实现三个具体的产品类（也就是连接方式）再定义一个工厂方法，按照不同的传入条件，选择不同的连接方式。