工厂方法模式

案例

/*
 * 抽象产品类
 */
public abstract class Water {

    public abstract void createWater();
}

/*
 * 具体产品类：咖啡
 */
public class Coffee extends Water{

    @Override
    public void createWater() {
        System.out.println("生产了一杯咖啡……");
    }
}

/*
 * 具体产品类：农夫山泉
 */
public class NongFuShanQuan extends Water{

    @Override
    public void createWater() {
        System.out.println("生产了一瓶农夫山泉……");
    }
}

/*
 * 抽象工厂类
 */
public abstract class Creator {

    public abstract <T extends Water>T createWater(Class<T> paramWater);
}

/*
 * 具体工厂类
 */
public class ConcreteCreator extends Creator{

    @SuppressWarnings("unchecked")
    @Override
    public <T extends Water> T createWater(Class<T> paramWater) {

        Water water = null;
        try {
            water = (Water) Class.forName(paramWater.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) water;
    }
}

/*
 * 实际场景
 */
public class Scene {

    public static void main(String[] args) {

        Creator creator = new ConcreteCreator();
        //生产一杯咖啡
        Coffee coffee = creator.createWater(Coffee.class);
        coffee.createWater();
        //生产一瓶农夫山泉
        NongFuShanQuan nongFuShanQuan = creator.createWater(NongFuShanQuan.class);
        nongFuShanQuan.createWater();
    }
}

优点

• 封装性良好，代码结构清晰。创建一个对象只需要知道它的类名（或约束字符串）就行，降低模块之间的耦合
• 可扩展性强。增加一个产品时（如：可口可乐），只需适当修改或扩展一个具体的产品类，就可完成“拥抱变化”
• 屏蔽产品类。产品类如何实现，调用者不用关心，只关心产品提供的接口，因为产品类的实例化是由工厂类来负责的
• 工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类，其他的实现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类

使用场景

• 工厂方法模式能巧妙地替代new关键字去创建一个对象，因此使用范围也相同，但是也会增加代码的复杂度
• 需要灵活的、可扩展的框架时，可以考虑采用工厂方法模式。如：设计一个连接邮件服务器的框架，可选取三种协议实现：POP3、IMAP、HTTP，相应的就可将这三种实现方式看作产品类，定义一个接口如 IConnectMail， 然后定义对邮件的操作方法，用不同的方法实现三个具体的产品类（也就是连接方式）再定义一个工厂方法，按照不同的传入条件，选择不同的连接方式。

拓展

• 简单工厂模式（将工厂类的工厂方法声明为static，并去掉其抽象性质，这样做的缺点是工厂类的扩展比较困难）
• 多个工厂类的工厂模式（每个产品都分别对应一个工厂专门去生产它，好处是类的职责清晰，结构简单，但是会影响可扩展性和可维护性）

• 延迟初始化（即：使用完成后的对象资源，不立即被释放，工厂类保持其初始状态，等待再次被使用）

  //基于简单工厂模式的延迟初始化
  public class LazyInitFactory{
  
  private static final Map<String,Water> cacheMap = new HashMap<String,Water>();
  
  public static synchronized Water createWater(String type) {
      Water water = null;
      //校验缓存容器中是否这个对象
      if(cacheMap.containsKey(type)){
          water = cacheMap.get(type);
      }else{
          if("Coffee".equals(type)){
              water = new Coffee();
          }else{
              water = new NongFuShanQuan();
          }
          //将对象放入缓存容器中
          cacheMap.put(type, water);
      }
      return water;
  }