【设计模式】之抽象工厂模式

创造性设计模式

创造型模式主要是为了实例化类所用。进一步又分为类创建、对象创建模式。

类创建模式

类创建模式主要基于继承方式进行实例化

对象创建模式

对象创建模式主要基于委托机制进行实例化

Abstract Factory 抽象工厂模式

抽象工厂常常 基于 几个类似的类中，创建指定的实例。

目标

• 提供一个接口，创建相似的或关联的对象，而不需要指定它们
• 封装了很多可能的“平台”，可以创建一系列“产品”
• new 操作被认为是不友好的

问题

如果应用是可移植的，则需要封装平台依赖关系。
将创建相似的或依赖的对象抽象出来而不是直接指定它们的创建类。
"factory" 对象负责提供创建对象的服务，Client不需要直接创建对象。它们访问factory获取对象。

这种机制保证了交换“产品”变得容易，因为指定的类只需要出现一次---在初始化的时候。
应用可以通过实例化一个不同的工厂来批量的替换大量的产品。

由于工厂对象对象的行为是非常普遍的，所以一般使用单例实现。

结构模式

一个抽象工厂 AbstractFactory 定义了一个工厂方法。
每个工厂方法封装了 new 操作。

抽象工厂的目的是为创建相关对象的系列提供一个接口。
这种模式是在日本汽车制造中的钣金冲压设备中发现的。
冲压设备是一家生产汽车车身零件的抽象工厂。同样的机械用于冲压右门，左手门，右前挡泥板，左前挡泥板，风帽等。

Builder、Prototype、AbstractFactory 模式

Builder 模式侧重于一步一步地构建复杂对象。
抽象工厂则强调一组或一类产品对象（简单或复杂的）。
Builder 在最后一步返回产品对象。
抽象工厂则会立即返回产品对象。
Prototype 通过copy产生对象。

示例场景描述

芯片制造商B可以制造CPU、MMU，且分别适用于的架构模式。亦即是说：
制造商可以制造 基于 EMBER 架构的CPU、MMU 、和基于 ENGINOLA 架构的CPU、MMU。
制造商拥有基于 EMBER 架构 的工具、 基于 ENGINOLA 架构 的工具，都能生产CPU、MMU。

于是对于用户A而言，只需要告知厂商B，选择需要制造 架构 EMBER 。

此时，根据选择的架构通过抽象工厂得到相应的工具。
客户A再根据工具选择生产CPU还是MMU均可。

代码示例如下：

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public abstract class AbstractCpu {
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public abstract class AbstractMmu {
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public enum Architecture {
   /**
   *
   *   this field
   */
    ENGINOLA,

    /**
    *
    *   this field
    */
    EMBER
}

package creational.absfactory;
/**
*
*   @author Byron
*   @date
*/
public class EmberToolkit extends AbstractFactory {
    @Override
    public AbstractCpu createCPU() {
        return new EmberCpu();
    }

    @Override
    public AbstractMmu createMMU() {
        return new EmberMmu();
    }
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public abstract class AbstractFactory {
    private static final EmberToolkit EMBER_TOOLKIT = new EmberToolkit();
    private static final EnginolaToolkit ENGINOLA_TOOLKIT = new EnginolaToolkit();

    /**
     *  Returns a concrete factory object that is an instance of the
     *  concrete factory class appropriate for the given architecture.
     */
    static AbstractFactory getFactory(Architecture architecture) {
        AbstractFactory factory = null;
        switch (architecture) {
            case ENGINOLA:
                factory = ENGINOLA_TOOLKIT;
                break;
            case EMBER:
                factory = EMBER_TOOLKIT;
                break;
            default: System.err.println("ERROR"); break;
        }
        return factory;
    }

   /**
   *   to do
   *   @param
   *   @return
   */
    public abstract AbstractCpu createCPU();

    /**
     * 创建一个MMU
     * @return
     */
    public abstract AbstractMmu createMMU();
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class EnginolaToolkit extends AbstractFactory {
    @Override
    public AbstractCpu createCPU() {
        return new EnginolaCpu();
    }

    @Override
    public AbstractMmu createMMU() {
        return new EnginolaMmu();
    }
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class EnginolaCpu extends AbstractCpu {
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class EnginolaMmu extends AbstractMmu{
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class EmberCpu extends AbstractCpu {
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class EmberMmu  extends AbstractMmu{
}

package creational.absfactory;

/**
*
*   @author Byron
*   @date
*/
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory = AbstractFactory.getFactory(Architecture.EMBER);
        AbstractCpu cpu = factory.createCPU();
    }
}