工厂方法模式

1.定义

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

基本工厂方法模式

抽象产品类

public abstract class AbstractProduct {
    // 公共方法
    public void methodOne() {
      // 业务逻辑
    }
  
    // 抽象方法
    public abstract void methodTwo();
}

具体产品类，都继承自抽象产品类

public class ConcreteProductOne extends AbstractProduct {
    public void methodTwo() {
        // 业务逻辑
    }
}

public class ConcreteProductTwo extends AbstractProduct {
    public void methodTwo() {
        // 业务逻辑
    }
}

抽象工厂类，负责定义产品对象的产生

public abstract class AbstractProductFactory {
    // 创建一个产品对象，参数类型通常为 String, Enum, Class
    public abstract <T extends AbstractProduct> T createProduct(Class<T> c);
}

具体工厂类，继承抽象工厂类

public class ProductFactory extends AbstractProductFactory {
    // 创建一个产品对象，参数类型通常为 String, Enum, Class
    public <T extends AbstractProduct> T createProduct(Class<T> c) {
        AbstractProduct abstractProduct = null;
        
        try {
            abstractProduct = (AbstractProduct) Class.forName(c.getName()).newInstance();
        } catch (Exception exception) {
            // 异常处理
        }
      
        return abstractProduct;
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        AbstractProductFactory productFactory = new ProductFactory();
        
        AbstractProduct productOne = productFactory.createProduct(ConcreteProductOne.class);
        AbstractProduct productTwo = productFactory.createProduct(ConcreteProductTwo.class);
        
        // TODO
    }
}

2.应用

2.1 优点

• 良好的封装性，代码结构清晰，一个对象的创建具有条件的约束
• 扩展性非常优秀，在增加产品的情况下，只适当修改工厂类或扩展一个工厂类
• 屏蔽产品类，调用者不需要关心产品类如何变化，只需要关注产品接口保持不变
• 工厂方法模式是典型的解耦框架。高层模块只需要知道产品抽象类，不用关心其它实现类

2.2 使用场景

• 工厂方法模式是new一个对象的替代品，在所有需要生成对象的地方都可以使用，，但需要谨慎考虑是否需要增加一个工厂类进行管理，增加代码的复杂度
• 需要灵活可扩展的框架时，可以考虑采用工厂方法模式。万物皆对象，万物也皆产品类。如需要设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3，IMPA，HTTP，可以将这三种连接方法作为产品类，定义一个连接接口，使用不同的方法实现具体的产品类，再定义一个工厂方法，根据不同的条件选择不同的连接方式。若增加新的连接方式，只需要增加新的产品类即可。

3.扩展

工厂方法模式有多种扩展，而且与其它模式结合使用使用威力更大

3.1 简单工厂模式（静态工厂模式）

假如一个模块仅需要一个工厂类，没有必要把它产生出来，使用静态方法即可

去掉抽象工厂类，将工厂方法设置为静态方法

public class ProductFactory {
    // 创建一个产品对象，参数类型通常为 String, Enum, Class
    public static <T extends AbstractProduct> T createProduct(Class<T> c) {
        AbstractProduct abstractProduct = null;
        
        try {
            abstractProduct = (AbstractProduct) Class.forName(c.getName()).newInstance();
        } catch (Exception exception) {
            // 异常处理
        }
      
        return abstractProduct;
    }
}

3.2 多工厂模式

一个产品类有多个实现类，且每一个实现类的初始化还需要为对象设置一定的初始值，如果将所有的产品类放到一个工厂方法中进行初始化，必定会导致该工厂方法巨大无比，且代码结构不清晰。因此，需要为每一个产品定义一个工厂类。

多工厂模式抽象工厂类

public abstract class AbstractProductFactory {
    // 不需要为工厂方法传递参数，每一个具体的工厂方法职责明确
    public abstract AbstractProduct createProduct();
}

不同产品的工厂类，继承抽象工厂类

public class ProductOneFactory extends AbstractProductFactory {
    public AbstractProduct createProduct() {
        return new ConcreteProductOne();
    }
}

public class ProductTwoFactory extends AbstractProductFactory {
    public AbstractProduct createProduct() {
        return new ConcreteProductTwo();
    }
}

优点：创建类的职责清晰，结构简单

缺点：可扩展性及可维护性差。扩展产品类需要建立相应的工厂类，增加扩展难度及维护成本

3.3 替代单例模式

使用工厂方法模式实现单例模式

单例类

public class Singleton {
    private Singleton() {}
  
    public void doSomething() {
        // TODO
    }
}

负责生成单例的工厂类，使用反射方式生成单例对象

public class SingletonFactory {
    private static Singleton singleton;
  
    static {
        try {
            Class clazz = Class.forName(Singleton.class.getName());
            // 获取无参构造器
            Constructor constructor = clazz.getDeclaredConstructor();
            // 设置无参构造器可访问
            constructor.setAccessible(true);
            // 产生一个实例对象
            singleton = (Singleton) constructor.newInstance();
        } catch (Exception exception) {
            // 异常处理
        }
    }
  
    public static Singleton getSingletonInstance() {
        return singleton;
    }
}

通过获得类构造器，设置访问权限，生成一个对象，然后提供外部访问，保证内存中的对象唯一。通过工厂方法模式创建一个单例对象，该框架可以继续扩展，在一个项目中产生一个单例构造器，所有需要产生单例的类遵循一定的规则（构造器私有化），只需要输入一个类型可获得唯一的一个实例。

3.4 延迟初始化

一个对象被消费完毕后，并不立即释放，工厂类保持其初始状态。

延迟加载的工厂类

public class ProductFactory {
    private static final Map<String, AbstractProduct> prMap = new HashMap();
  
    public static synchronized AbstractProduct createProduct(String type) throws Exception {
        AbstractProduct product = null;
        
        if (prMap.containsKey(type)) {
            product = prMap.get(type);
        } else {
            if (type.equals("one")) {
                product = new ConcreteProductOne();
            } else {
                product = new ConcreteProductTwo();
            }
          
            prMap.put(type, product);
        }
      
        return product;
    }
}

通过定义一个Map容器，容纳所有产生的对象，若在Map容器中已经有的对象直接取出返回，如果没有，根据需要的类型产生一个对象，并放入到Map容器中，方便下次调用。

延迟加载框架可扩展为限制某一产品类的最大实例化数量，通过判断Map容器中已有的对象数量来实现。如JDBC连接数据库，都会要求设置一个maxConnections最大连接数量，该数量就是内存中的最大实例化数量。