【java设计模式】之 工厂（Factory）模式

1.工厂模式的定义

        工厂模式使用的频率很高。我们在开发中总能见到它们的身影。其定义为：Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.即定义一个用于创建对象的接口，让子类决定实例化哪一个类。

工厂方法使一个类的实例化延迟到其子类。工厂方法模式的通用类图例如以下所看到的：

        如图所看到的，Product抽象类负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象工厂类。详细怎样创建产品类由详细的实现工厂ConcreteCreator来完毕。

我们来看一下通用的模板代码：

public abstract class Product {

  public void method() { //产品类的公共方法，已经实现
    //实现了公共的逻辑
  }

  public abstract void method2(); //非公共方法，须要子类详细实现
}

        详细产品类能够有多个，都继承与抽象类Product，例如以下：

public class ConcreateProduct1 extends Product {

  @Override
  public void method2() {
    //product1的业务逻辑
  }
}
public class ConcreateProduct2 extends Product {

  @Override
  public void method2() {
    //product2的业务逻辑
  }
}

        抽象工厂类负责定义产品对象的产生。代码例如以下：

public abstract class Creator {
  //创建一个产品对象。其输入參数类型能够自行设置
  public abstract <T extends Product> T createProduct(Class<T> clazz);
}

       这里用的是泛型，传入的对象必须是Product抽象类的实现类。详细怎样产生一个产品的对象，是由详细工厂类实现的。详细工厂类继承这个抽象工厂类：

public class ConcreteCreator extends Creator {

  @Override
  public <T extends Product> T createProduct(Class<T> clazz) {
    Product product = null;
    try {
      product = (Product) Class.forName(clazz.getName()).newInstance();
    } catch (Exception e) { //异常处理
      e.printStackTrace();
    }
    return (T) product;
  }
}

        通过这种设计。我们就能够在測试类中任意生产产品了。看以下的測试类：

public class FactoryTest {

  public static void main(String[] args) {
    Creator factory = new ConcreteCreator();
    Product product1 = factory.createProduct(ConcreteProduct1.class); //通过不同的类创建不同的产品
    Product product2 = factory.createProduct(ConcreteProduct2.class);
     /*
      * 以下继续其它业务处理
      */
   }
}

        以下举个女娲造人的样例阐述一下工厂模式的实际应用。

2.用女蜗造人阐述工厂模式

        如今女娲要造人，她要造三种人：白种人、黄种人和黑种人。怎么造呢？她得有个能产生人类的工厂吧（类似于八卦炉的东西）。这个工厂得让她生产出不同的人种。

每一个人都有两个属性：皮肤颜色和说话。

那如今我们開始设计女蜗造人的程序，首先我们看一下造人的类图：

        抽象接口Human是人类，里面有两个方法，getColor获得皮肤颜色，talk交谈。以下三个详细Human的实现类。分别实现三个人种。依据工厂模式，应该有个抽象工厂，AbstractHumanFactory就担当了这个责任，里面有个抽象方法createHuman，那HumanFactory就是实现类了。实现抽象工厂里的方法。以下我们看看详细实现：

public interface Human {  
  public void getColor();//人有不同的颜色  
  public void talk(); //人会说话
}

        接下来对Human接口的不同实现：

public class BlackHuman implements Human {// 黑种人

  @Override
  public void getColor() {
    System.out.println("Black");
  }
  @Override
  public void talk() {
    System.out.println("Black man");
  }
}
public class Human implements Human { //黄种人

  @Override
  public void getColor() {
    System.out.println("Yellow");
  }
  @Override
  public void talk() {
    System.out.println("Yellow man");
  }
}
public class WhiteHuman implements Human {//白种人

  @Override
  public void getColor() {
    System.out.println("White");
  }
  @Override
  public void talk() {
    System.out.println("White man");
  }
}

        好了，人的模子搞好了，如今女娲要開始搭建八卦炉了，于是女娲開始画八卦炉模型了：

public abstract class AbstractHumanFactory{
  public abstract <T extends Human> T createHuman(Class<T> clazz); //注意这里T必须是Human的实现类才行，由于要造Human嘛
}

        然后女娲開始详细实现这个八卦炉了……

public class HumanFactory extends AbstractHumanFactory {

  @Override
  public <T extends Human> T createHuman(Class<T> clazz) {
    Human human = null;
    try {
      human = (Product) Class.forName(clazz.getName()).newInstance();
    } catch (Exception e) { //异常处理
      System.out.println("人种产生错误");
    }
    return (T) human;
  }
}

        好，如今人种也有了。八卦炉也有了，剩下的就是採集黄土，然后命令八卦炉開始生产了：

public class FactoryTest {
  public static void main(String[] args) {
    AbstractHumanFactory bagualu = new HunmanFactory();
    Human blackMan = bagualu.createHuman(BlackHuman.class); //黑人诞生了
    Human yellowMan = bagualu.createHuman(YelloHuman.class); //黄人诞生了
    Human whiteMan = bagualu.createHuman(WhiteHuman.class); //白人诞生了
    }
}

        女娲就是这么把人造出来的……这就是工厂模式。

3.工厂模式的扩展

3.1 静态工厂模式

        我们还用上面女娲造人的样例说明，如今女娲在思考一个问题：我如今仅仅须要一个工厂就能够把人生产出来。我干嘛要详细的工厂对象呢？我仅仅要使用静态方法就好了。这样一想。于是女娲就開始把AbstractHumanFactory抽象类去掉了，仅仅保留了HumanFactory类，同一时候把createHuman方法设置成了static类型，搞定！

public class HumanFactory {

  @Override
  public static <T extends Human> T createHuman(Class<T> clazz) {
    Human human = null;
    try {
      human = (Product) Class.forName(clazz.getName()).newInstance();
    } catch (Exception e) { //异常处理
      System.out.println("人种产生错误");
    }
    return (T) human;
  }
}

        然后女娲造人的时候就不用new什么八卦炉了。直接用HumanFactory类调用即可了：

Human blackMan = HumanFactory.createHuman(BlackHuman.class);

        这就是静态工厂模式，在实际项目中，依据需求能够设置成静态工厂类，可是缺点是扩展比較困难。假设就一个工厂，不须要扩展，能够这么设计，仍然是非经常常使用的。

3.2 多个工厂模式

        我们还以女娲造人为例，后来女娲想了想，，这人不可能就说话吧，还得有不同的属性杀的，假设在一个八卦炉里造。除了new一个人外，还得对不同的人设置不同的属性，这种话，八卦炉有点吃不消阿……又有点乱啊……可是她想到了一个法子。每一个人种弄个八卦炉。不同的八卦炉专门生产不同的人种，这样就结构清晰了。她在造人的时候自己选择与哪个八卦炉相关联即可了。示意图例如以下：

        这种话AbstractHumanFactory抽象类我们就要改写了：

public abstract class AbstractHumanFactory {
  public abstract Human createHuman();
}

        注意抽象方法中已经不须要再传递相关类的參数了，由于每一个详细的工厂都已经很明白自己的职责：创建自己负责的产品类对象。所以不同的工厂实现自己的createHuman方法就可以：

public class BlackHumanFactory extends AbstractHumanFactory {
  public Human createHuman() {
    return new BlackHuman();
  }
}
public class YellowHumanFactory extends AbstractHumanFactory {
  public Human createHuman() {
    return new YellowHuman();
  }
}
public class WhiteHumanFactory extends AbstractHumanFactory {
  public Human createHuman() {
    return new WhiteHuman();
  }
}

        这样三个不同的工厂就产生了。每一个工厂相应仅仅生产自己相应的人种。所以如今女娲造人就能够不用一个八卦炉了。分工协作。各不影响了。

public class FactoryTest {
  public static void main(String[] args) {
    Human blackMan = new BlackHumanFactory().createHuman(); //黑人诞生了
    Human yellowMan = new YellowHumanFactory().createHuman(); //黄人诞生了
    Human whiteMan = new WhiteHumanFactory().createHuman(); //白人诞生了
    }
}

        这样的工厂模式的优点是职责清晰，结构简单。可是给扩扩展性和可维护性带来了一定的影响，由于假设要扩展一个产品类，就须要建立一个对应的工厂类。这样就添加了扩展的难度。

由于工厂类和产品类的数量是同样的，维护时也须要考虑两个对象之间的关系。可是这样的模式还是非经常常使用的。

3.3 替代单例模式

        上一章介绍了单例模式，而且指出了单例和多例的一些缺点，可是我们是不是能够採用工厂模式来实现一个单例模式的功能呢？答案是肯定的。单例模式的核心要求就是在内存中仅仅有一个对象，通过工厂方法模式也能够仅仅在内存中生产一个对象。见以下：

Singleton类定义了一个private的无參构造方法，目的是不同意通过new的方式创建对象。另外，Singleton类也不自定义一个Singleton对象了，由于它要通过工厂来获得。

public class Singleton {
  private Singleton() {

  }
  public void doSomething() {
    //业务处理
  }
}

        既然Singleton不能通过正常的渠道建立一个对象，那SingletonFactory怎样建立一个单例对象呢？答案是通过反射方式创建：

public class SingletonFactory {
  private static Singleton instance;
  static {
    try {   
      Class clazz = Class.forName(Singleton.class.getName());
      //获取无參构造方法
      Constructor constructor = clazz.getDeclaredConstructor();
      //设置无參构造方法可訪问
      constructor.setAccessible(true);
      //产生一个实例对象
      instance = (Singleton) constructor.newInstance();
    } catch (Exception e) {
      //异常处理
    }
  }
  public static Singleton getInstance() {
    return instance;
  }
}

        以上通过工厂方法模式创建了一个单例对象。该框架能够继续扩展，在一个项目中能够产生一个单例构造器，全部须要产生单例的类都遵循一定的规则（构造方法是private），然后通过扩展该框架。仅仅要输入一个类型就能够获得唯一的一个实例。

3.4 延迟初始化

        何为延迟初始化（Lazy initialization）？即一个对象被使用完成后，并不立马释放，工厂类保持其初始状态，等待再次被使用。延迟初始化是工厂模式的一个扩展应用，其通用类表演示样例如以下：

        ProductFactory负责产品类对象的创建工作。而且通过prMap变量产生一个缓存，对须要再次被重用的对象保留：

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容器，容纳全部产生的对象。每次在new一个对象的时候先推断Map中有没有。有就不用再new了，直接取。另外，每次new过一个对象后，也将其放入Map中方便下次调用。

        延迟载入时非常实用的，比方JDBC连接数据库。会要求设置一个MaxConnections最大连接数量，该数量就是内存中最大实例化的数量。

4. 工厂模式的应用

    长处：

        1. 工厂模式具有良好的封装性。代码结构清晰。也有利于扩展。在添加产品类的情况下。仅仅须要适当地改动详细的工厂类或扩展一个工厂类。就能够完毕“拥抱变化”。

        2. 工厂模式能够屏蔽产品类。

这一点很重要，产品类的实现怎样变化，调用者都不用关系。仅仅须要关心产品的接口，仅仅要接口保持不变。系统的上层模块就不须要发生变化。

        3. 工厂模式是典型的解耦框架。高层模块仅仅须要知道产品的抽象类。其它的实现类都不用关心。

​​​​