工厂方法模式

# 2、工厂方法模式（Factory Method Pattern） #
## 2.1工厂方法模式的定义 ##
**定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法模式使一个类的实例化延迟到其子类。**<br/>
工厂方法模式的通用类图如下：<br>
! [](http://img7.ph.126.net/30_6VOACUjXg79ihasasFQ==/2751136422387534377.gif)<br/>
其中接口Product负责定义产品的共性，实现对事物最抽象的定义；Creator为抽象创建类，也就是抽象工厂，具体如何创建产品类是有具体实现工厂ConcreteCreator完成的。
工厂方法模式的代码如下：<br/>
抽象产品接口<br/>
    public interface Product {
    //定义产品的共性
    public abstract void method();
}<br/>
具体的产品类（可以有多个）：<br/>
    public class ConcreteProduct1 implements Product {

    @Override
    public void method() {
        
    }
}<br/>
    public class ConcreteProduct2 implements Product {

    @Override
    public void method() {
        
    }
}<br/>
抽象工厂类负责定义产品的产生：<br/>
    public abstract class Creator {

    //创建一个产品对象，输入参数类型可以自行设置
    public abstract <T extends Product> T factoryethod(Class<T> c);
}<br/>
具体的工厂类（具体如何产生一个对象）：<br/>
    public class ConcreteCreator extends Creator {

    @SuppressWarnings("unchecked")
    public <T extends Product> T factoryethod(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            //异常处理
        }
        return (T) product;
    }
}<br/>
场景类：<br/>
    public class Client {

    public static void main(String[] args) {

        Creator creator = new ConcreteCreator();
        Product product1 = ((Creator) creator).factoryethod(ConcreteProduct1.class);
        Product product2 = ((Creator) creator).factoryethod(ConcreteProduct2.class);
        //业务处理代码
    }
}
## 2.2工厂方法模式的应用 ##
### 2.2.1工厂方法模式的优点 ###
1. 良好的封装性，代码结构清晰。调用者若要创建一个具体的对象，只需要知道这个类的名字就可以了，不需要知道创建的过程，而且降低了代码的耦合性。
2. 工厂方法模式的扩展性非常良好。
3. 屏蔽产品类，只要接口不变，系统中的上层模块就不用变化。
4. 工厂方法模式是典型的解耦框架。
### 2.2.2工厂方法模式的使用场景 ###
1. 工厂方法模式是new一个对象的替代品，在所有需要生成对象的地方都可以使用，但要考虑是否需要增加工厂类来增加代码的复杂性。
2. 需要灵活的、可扩展的框架时，可以考虑工厂方法模式。
3. 工厂方法模式可以用在异构项目中。
4. 工厂方法模式可以用在测试驱动开发的框架下。
## 2.3工厂方法模式的扩展##
### 2.3.1工厂方法模式的简化（简单工厂模式） ###
如果一个模块仅需要一个工厂类，则没有必要对工厂进行抽象，使用静态工厂就可以了。<br/>
public class ConcreteCreator{

    @SuppressWarnings("unchecked")
    public static <T extends Product> T factoryethod(Class<T> c) {
        Product product = null;
        try {
            product = (Product) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            //异常处理
        }
        return (T) product;
    }
}<br/>
### 2.3.2升级为多个工厂类 ###
当遇到一个比较复杂的项目时，所有的产品都放到一个类中进行初始化会使代码不清晰，因此我们为每一个产品定义一个创造者，由调用者决定与哪一个工厂方法相关联。<br/>
    public abstract class Creator {

    public abstract Product factoryethod();
}<br/>
    public class ConcreteCreator1 extends Creator {

    public ConcreteProduct1 factoryethod() {
        return new ConcreteProduct1();
    }
}<br/>
    public class ConcreteCreator2 extends Creator {

    public ConcreteProduct2 factoryethod() {
        return new ConcreteProduct1();
    }
}
### 2.3.3替代单例模式 ###
通过获得类构造器，然后获得访问权限，生成对象，提供对外访问的方法。该框架可以继续扩展。<br/>
单例类：<br/>
    public class Singleton {
    private volatile static Singleton singleton = null;
    //限制产生多个对象
    private Singleton(){
        
    }
    //类中其他方法尽量是静态方法
    public static void doSomething(){
    }
}<br/>
单例工厂类：<br/>
    import java.lang.reflect.Constructor;

public class SingletonFactory {

    private static Singleton singleton;
    static{
        try {
            Class c = Class.forName(Singleton.class.getName());
            //获得无参构造器
            Constructor constructor = c.getDeclaredConstructor();
            //设置无参构造器是可以访问的
            constructor.setAccessible(true);
            //产生一个对象
            singleton = (Singleton) constructor.newInstance();
        } catch (Exception e) {
            //异常处理
        }
    }
    public static Singleton getInstance(){
        return singleton;
    }
}<br/>
### 2.3.4延迟初始化 ###
对象消耗完毕后，不立即释放，工厂类保持其初始状态，等待着再次被使用。<br/>
    import java.util.HashMap;<br/>
import java.util.Map;

public class ProductFactory {

    private static final Map<String,Product> map = new HashMap<String,Product>();
    public static synchronized Product createProduct(String type){
        Product product = null;
        //如果map中已经有这个对象
        if(map.containsKey(type)){
            product = map.get(type);
        }else{
            if(type.equals("product1")){
                product = new ConcreteProduct1();
            }else{
                product = new ConcreteProduct2();
            }
            //将对象放到缓存中
            map.put(type, product);
        }
        return product;
    }
}<br/>
**参考文献：**<br/>
《设计模式之禅》，秦小波