Abstract Factory（抽象工厂）模式

Abstract Factory （抽象工厂）模式

 

GoF ： Abstract Factory 模 式的意图是“提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类”。

 

工厂模式有 : 抽象 工厂 (Abstract Factory) 、工厂方法 (Factory Method) 。依照《设计模式精解》的顺序，这里先学习 Abstract Factory 模式。

 

工厂模式是传说中用的最广的模式了。我们通常用某个类 Class 来生成一个对象，例如： A a = new A();  所谓工厂就是生产某种产品的地方。那么工厂模式就是用来生成一些列产品（对象）的。有时候，几个对 象需要按照相同的样式被实例化。比如说，在处理显示器显示精度的时候，有些机器能显示高清晰图像，而有些机器只能显示低分辨率图像。那么在工作上就要求系 统去适配最合适的功能。 Abstract Factory 模式能确保系统总能根据当前的情况获得合 适的对象。

 

假如我们要开发一个系统，要求提供打印驱动和显示驱动，还要求在不同 配置的机器上要有合适的驱动，例如：在高配置的机器上要求精度高的驱动，在低配置的机器上要求精度低的驱动。

 

开始的解决方法这样：提供一个 DisplayDriver 抽象类（或者接口）然后派生出两个类 Lrdd （提 供低精度显示驱动）和 Hrdd （提供高精度显示驱动）；再提供一个 PrintDriver 抽象类（或者接口）然后派生出两个类 Lrpd （提 供低精度打印驱动） Hrpd （提供高精度打印驱动）。最后在 ApControl 类中分别实例化四个派生类的对象来提供相关的驱动。这样做是很合理的，但是当需求改变了，现在要求提供中等精度的驱动，或者其它要求。我们又 从那两个抽象类中分别派生出若干子类。这样又出现了类爆炸的情况，我们要在 ApControl 类中分别实例化那些类才能提供我们所要的功能。这时我们就应该想一下用 Abstract Factory 模式了。先看一下 Abstract Factory 模式的 UML 图：

( )

Abstract Factory 模式 UML 图

在上图中我们可以看到，用一个工厂（ ResFractory ）来“生产”我们需要的“产品”（类）。我们不管有多少具体类，在 Abstract Factory 模式中 ApControl 类只使用 Abstract Factory 类（ ResFactory 类）和 Abstract Product 类（ DisplayDriver 类和 PrintDriver 类）的接口。通常在运行时刻创建一个具体类的实例。这一具体的工厂创建具有特定实现的产品对象。为 创建不同的产品对象，客户应使用不同的具体工厂。 Abstract Factory 将产品对 象的创建延迟到它的具体子类中。

 

下面给出上图 的简易代码：

先创建产品：

package Factory;

 

public abstract class DisplayDriver

{

       public abstract void dDriver();// 抽 象方法，使派生类能够自由实现所需的显示功能。

      

}//end abstract class DisplayDriver

 

 

package Factory;

 

public class Lrdd extends DisplayDriver

{

 

       public Lrdd()

       {

              System.out.println(" 低分辨率 __ 显示 驱动 ");

       }//end Lrdd()

      

       public void dDriver() // 实现基类抽象方法

       {

              System.out.println(" 显示出 __ 低分辨率图像 ");

       }//end dDrover()

      

}//end class Lrdd

 

 

package Factory;

 

public class Hrdd extends DisplayDriver

{

       public Hrdd()

       {

              System.out.println(" 高分辨率 -- 显示 驱动 ");

       }//end Hrdd()

 

       public void dDriver()

       {

              System.out.println(" 显示出 -- 高分辨率图像 ");

       }//end dDriver()

 

}//end class Hrdd

 

 

package Factory;

 

public abstract class PrintDriver

{

       public abstract void pDriver();// 抽 象方法，使派生类能够自由实现所需的打印功能。

      

}//end abstract class PrintDriver

 

 

package Factory;

 

public class Lrpd extends PrintDriver

{

 

       public Lrpd()

       {

              System.out.println(" 低分辨率 __ 打印 驱动 ");

       }//end Lrpd()

 

       public void pDriver()

       {

              System.out.println(" 打印 __ 低分辨率图像 ");

       }//end pDriver()

      

}//end class Lrpd

 

 

package Factory;

 

public class Hrpd extends PrintDriver

{

 

       public Hrpd()

       {

              System.out.println(" 高分辨率 -- 打印 驱动 ");

       }//end Hrpd()

 

       public void pDriver()

       {

              System.out.println(" 打印 -- 高分辨率图像 ");

       }//end pDriver()

 

}//end class Hrpd

 

再创建工厂：

package Factory;

 

public abstract class ResFactory

{

       // 抽象方法，使派生类自由实现显示功能

       abstract public DisplayDriver getDispDrvr();

      

       // 抽象方法，使派生类自由实现打印功能

       abstract public PrintDriver getPrtDrvr();

}//end abstract class ResFactory

 

 

package Factory;

 

public class LowResFact extends ResFactory {

 

       public LowResFact()

       {

              System.out.println(" 低分辨率 ----> 驱动 ");

       }//end LowResFact()

 

       public DisplayDriver getDispDrvr()

       {

              return new Lrdd();

       }//end getDispDrvr()

 

       public PrintDriver getPrtDrvr()

       {

              return new Lrpd();

       }//end getPrtDrvr()

 

}//end class LowResFact

 

 

package Factory;

 

public class HighResFact extends ResFactory

{

 

       public HighResFact()

       {

              System.out.println(" 高分辨率 ----> 驱动 ");

       }//end HighResFact()

 

       public DisplayDriver getDispDrvr()

       {

              return new Hrdd();

       }//end getDispDrvr()

 

       public PrintDriver getPrtDrvr()

       {

              return new Hrpd();

       }//end getPrtDrvr()

 

}//end class HighResFact

 

 

利用工厂产生不同的产品：

package Factory;

 

public class ApControl

{

       private DisplayDriver lowDisplayDriver; // 需要 -- 低 -- 分辨率 -- 显示 -- 驱动

       private PrintDriver highPrintDriver; // 需要 -- 高 -- 分辨率 -- 打印 -- 驱动

      

       //     生产出低分 辨率驱动（注：没有说明是低显示驱动还是低打印驱动）

       private ResFactory lowDriver;

      

       //     生产出高分 辨率驱动（注：没有说明是高显示驱动还是高打印驱动）

       private ResFactory highDriver;

 

       public ApControl()

       {

              lowDriver = new LowResFact();// 实例化低分 辨率驱动对象

              highDriver = new HighResFact();// 实例化高 分辨率驱动对象

       }//end ApControl()

 

       public void displayDriver()

       {

              lowDisplayDriver = lowDriver.getDispDrvr();// 得到低分辨率驱动

              lowDisplayDriver.dDriver();// 低分辨率显示驱动

             

              highPrintDriver = highDriver.getPrtDrvr();// 得到低分辨率驱动

              highPrintDriver.pDriver();// 高分辨率显示驱动

       }//end displayDriver()

      

       public static void main(String[] args)

       {

              System.out.println("Abstract Factory");

              ApControl ac = new ApControl();

              ac.displayDriver();

       }//end main(...)

 

}//end class ApControl

 

输出结果如下：

Abstract Factory

低分辨率 ----> 驱动

高分辨率 ----> 驱动

低分辨率 __ 显示驱动

显示出 __ 低分辨率图像

高分辨率 -- 打印驱动

打印 -- 高分辨率图像

 

Abstract Factory 模式适用性：

l         在以下情况可以使用 Abstract Factory 模式：

l         一个系统 要独立于他的产品的创建、组合和表示时；

l         一个系统 要由多个产品系列中的一个来配置时；

l         当你要强 调一系列相关的产品对象的设计以便进行联合使用时；

l         当你提供 一个产品类库，而只想显示他们的接口而不是实现时。

 

在 Abstract Factory 模式中 ApControl 的责 任是知道如何与合适的对象协同工作； ResFactory 的责 任是提供合适的对象。

 

Abstract Factory 模式：关键特征

l          意图：你需要为 特定的客户（或情况）提供特定系列的对象。

l          问题：一系列相 关的对象需要被实例化。

l          解决方案：协调 不同系列对象的创建过程。提供一种方法保持“如何在客户对象外部执行兑现实例化”的规则，客户对象将使用这些实例化出来的对象。

l          参与者 与协作者： Abstract Factory 为 “如何创建需要的每一个系列的对象”定义接口。典型的情况下，每个系列都独立拥有自己的 ConcreteFactory ，通过它被实例化。

l          效果：这个模式 将“使用哪些对象”的规则与“如何使用这些对象”的逻辑相隔离。

l          实现： 定义一个抽象类来指定那些对象将被创建。然后为每个系列实现一个具体类。表或文件也可以被用于达到同样的目的 。

 

下面是 Abstract Factory 模式涉及的 3 个 关键策略：

1 . 发现 并封装变化点

       “使用哪个驱动对象”的选择食变化的。所以，将它封装在 ResFactory 类中。

2 . 优先 使用对象组合，而不是类继承

       将变化点放在一个独立的对象—— ResFactory 对象——中并让 ApControl 对象使用 ResFactory 对象，而不是拥有两类不同的 ApControl 对象。

3 . 针对 接口设计，而不是针对实现设计

       ApControl 知道 怎样想 ResFactory 请求实 例化驱动对象——它不知道（或不关心） ResFactory 对象 实际如何响应这一请求。