工厂方法模式

工厂方法模式

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

1. UML类图

2. 通用代码

//抽象产品类
public abstract class Product{
    //产品类的公共方法
    public void method1(){
        //业务逻辑处理
    }
    //抽象方法
    public abstract void method2();
}
//具体产品类
public class ConcreteProduct1 extend Product{
    public void method2(){
        //业务逻辑处理
    }
}
public class ConcreteProduct2 extend Product{
    public void method2(){
        //业务逻辑处理
    }
}
//抽象工厂类
public abstract class Creator{
    //创建一个产品对象，某输入参数类型可以自行设置
    public abstract <T extends Product> T createProduct(Class<T> c); 
}
//具体工厂类
public class ConcreteCreator extends Creator{
    public <T extends Product> T createProduct(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName()).newInstance();
        }catch(Exception e){
            //异常处理
        }
        return (T)product
    } 
}

3. 工厂方法模式的应用

优点

1. 良好的封装性，代码结构清晰，调用者不需知道创建对象的艰辛过程，降低模块间的耦合
2. 扩展性优秀，在新增产品的情况下，只要适当的修改具体的工厂类或扩展一个工厂类就可以完成“拥抱变化”
3. 屏蔽产品类，产品类的实现如何变化调用者不需要关心，它只需关心产品的接口，只要接口不变，系统中的上层模块就不会发生变化
4. 工厂方法是典型的解耦框架，高层模块只需要知道产品的抽象，其他实现类都不用关心，符合迪米特法则

使用场景

1. 在所有需要生成对象的地方都可以考虑是否增加工厂类
2. 需要灵活的，可拓展的框架时可考虑采用工厂方法模式，例如设计一个连接邮件服务器的框架，有三种网络协议可供选择：POP3，IMAP，HTTP，可以将这三种连接方法作为产品类，定义一个接口如IConnectMail

4. 简单工厂模式

一个模块仅需要一个工厂类，故没有必要把他生产出来，使用静态的方法就可以了
//其他都与上述一样

//具体工厂类
public class ConcreteCreator {
    public static <T extends Product> T createProduct(Class<T> c){
        Product product = null;
        try{
            product = (Product)Class.forName(c.getName()).newInstance();
        }catch(Exception e){
            //异常处理
        }
        return (T)product
    } 
}
//场景类中通过ConcreteCreator.createProduct(Class<T> c)直接调用

调用简单，但是扩展困难，不符合开闭原则

5. 多个工厂模式

符合开闭原则，有更好的拓展性

//抽象工厂类
public abstract class Creator{
    //创建一个产品对象，某输入参数类型可以自行设置
    public abstract Product createProduct(); 
}
//产品1的创建工厂实现
public class ConcreteProduct1Creator extends Creator{
    public Product createProduct(){
        return new ConcreteProduct1();
    }
}
//产品2的创建工厂实现
public class ConcreteProduct2Creator extends Creator{
    public Product createProduct(){
        return new ConcreteProduct2();
    }
}
//场景类中需要通过new不同的工厂类来生产不同的产品

创建类的职责清晰，结构简单，但是增大了扩展和维护的难度

6. 替代单例模式

//单例类
public class Singleton{
    //不允许通过new产生一个对象
    private Singleton(){
    }
    public void doSomething(){
        //业务处理
    }
}
//生成单例的工厂类
public class SingletonFactory{
    private static Singleton singleton;
    static{
        try{
            Class cl = Class.forName(Singleton.class.getName());
            //获得无参构造
            Constructor constructor = c1.getDeclaredConstructor();
            //设置无参构造是可访问的
            constructor.setAccessible(true);
            //产生一个实例对象
            singleton = (Singleton)constructor.newInstance();
        }catch(Exception e){
            //异常处理
        }
    }
    public static Singleton getSingleton(){
        return singleton;
    }
}

7. 延迟初始化

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;
    }
}

可扩展，例如限制某产品的最大实例化数量