设计模式之工厂方法模式

工厂方法模式

定义：工厂方法模式，又称工厂模式、多态工厂模式和虚拟构造器模式，通过定义工厂父类负责定义创建对象的公共接口，而子类则负责生成具体的对象。
这种类型的设计模式属于创建型模式，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂方法模式的优缺点

优点

• 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程
• 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则
• 屏蔽产品的具体实现，调用者只关心产品的接口
  缺点
• 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度

工厂方法模式的应用场景

• 当一个类不知道它所需要的对象的类时
• 当一个类希望通过其子类来指定创建对象时
• 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

工厂方法模式的实现

实现步骤：

• 步骤1： 创建抽象工厂类，定义具体工厂的公共接口；
• 步骤2： 创建抽象产品类 ，定义具体产品的公共接口；
• 步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品；
• 步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法；
• 步骤5：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

步骤一：创建抽象工厂类，定义具体工厂的公共接口

public interface Factory {
    Product showProduct();
}

步骤2： 创建抽象产品类 ，定义具体产品的公共接口；

public interface Product {
    void show();
}

步骤3： 创建具体产品类（继承抽象产品类）， 定义生产的具体产品

public class ProductA implements Product {
    @Override
    public void show() {
        System.out.println("这是产品A------------");
    }
}

public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("这是产品B-----------------");
    }
}

步骤4：创建具体工厂类（继承抽象工厂类），定义创建对应具体产品实例的方法

public class FactoryA implements Factory{
    @Override
    public Product showProduct() {
        return new ProductA();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product showProduct() {
        return new ProductB();
    }
}

步骤五：外界通过调用具体工厂类的方法，从而创建不同具体产品类的实例

public class Main {

    public static void main(String[] args) {
        FactoryA mFactoryA = new FactoryA();
        mFactoryA.showProduct().show();

        FactoryB mFactoryB = new FactoryB();
        mFactoryB.showProduct().show();
    }
}

输出结果

这是产品A------------
这是产品B-----------------

Spring中的工厂模式

Spring源码中有非常多的地方用到了工厂模式，几乎是无处不见，决定拿大家最为常用的Bean来说，因为Spring很多程度上是依赖它的对象管理，也就是IoC容器对于Bean的管理。
接下来我们就一起查看一下Spring中非常重要的一个类AbstractFactoryBean是如何利用工厂模式的。

// AbstractFactoryBean.java
// 继承了FactoryBean，工厂Bean的主要作用是为了实现getObject()返回Bean实例
  public abstract class AbstractFactoryBean<T> implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {

// 定义了获取对象的前置判断工作，创建对象的工作则交给了一个抽象方法
// 这里判断了Bean是不是单例并且是否已经被加载过了（未初始化但加载过了，这个问题涉及到Spring处理循环依赖，以后会讨论到）
  public final T getObject() throws Exception {
        return this.isSingleton()?(this.initialized?this.singletonInstance:this.getEarlySingletonInstance()):this.createInstance();
    }
// 由子类负责具体创建对象
protected abstract T createInstance() throws Exception;
}

之所以这么写是因为这种写法带来了两个好处:

• 保证了创建Bean的方式的多样性
  Bean工厂有很多种，它们负责创建各种各样不同的Bean，比如Map类型的Bean，List类型的Bean，Web服务Bean，子类们不需要关心单例或非单例情况下是否需要额外操作，只需要关心如何创建Bean，并且创建出来的Bean是多种多样的。
• 严格规定了Bean创建前后的其它动作
  虽然子类可以自由的去创建Bean，但是创建Bean之前的准备工作以及创建Bean之后对Bean的处理工作是AbstractFactoryBean设定好了的，子类不需要关心，也没权力关心，在这个例子中父类只负责一些前置判断工作。