复杂对象的组装与创建——建造者模式（三）

8.4 关于Director的进一步讨论

指挥者类Director在建造者模式中扮演非常重要的作用，简单的Director类用于指导具体建造者如何构建产品，它按一定次序调用Builder的buildPartX()方法，控制调用的先后次序，并向客户端返回一个完整的产品对象。下面我们讨论几种Director的高级应用方式：

1.省略Director

在有些情况下，为了简化系统结构，可以将Director和抽象建造者Builder进行合并，在Builder中提供逐步构建复杂产品对象的construct()方法。由于Builder类通常为抽象类，因此可以将construct()方法定义为静态(static)方法。如果将游戏角色设计中的指挥者类ActorController省略，ActorBuilder类的代码修改如下：

  1. abstract class ActorBuilder
  2. {
  3.        protected static Actor actor = new  Actor();
  5.        public  abstract void buildType();
  6.        public  abstract void buildSex();
  7.        public  abstract void buildFace();
  8.        public  abstract void buildCostume();
  9.        public  abstract void buildHairstyle();
  11.        public static Actor  construct(ActorBuilder ab)
  12.        {
  13.               ab.buildType();
  14.               ab.buildSex();
  15.               ab.buildFace();
  16.               ab.buildCostume();
  17.               ab.buildHairstyle();
  18.               return actor;
  19.        }
  20. }

对应的客户端代码也将发生修改，其代码片段如下所示：

  1.               ……
  2.               ActorBuilder  ab;
  3.               ab  = (ActorBuilder)XMLUtil.getBean();
  5.               Actor  actor;
  6.               actor =  ActorBuilder.construct(ab);
  7.                 ……

除此之外，还有一种更简单的处理方法，可以将construct()方法的参数去掉，直接在construct()方法中调用buildPartX()方法，代码如下所示：

  1. abstract class ActorBuilder
  2. {
  3.        protected  Actor actor = new Actor();
  5.        public  abstract void buildType();
  6.        public  abstract void buildSex();
  7.        public  abstract void buildFace();
  8.        public  abstract void buildCostume();
  9.        public  abstract void buildHairstyle();
  11.        public Actor construct()
  12.        {
  13.               this.buildType();
  14.               this.buildSex();
  15.               this.buildFace();
  16.               this.buildCostume();
  17.               this.buildHairstyle();
  18.               return actor;
  19.        }
  20. }

客户端代码代码片段如下所示：

  1. ……
  2.               ActorBuilder  ab;
  3.               ab  = (ActorBuilder)XMLUtil.getBean();
  5.               Actor  actor;
  6.               actor = ab.construct();
  7. ……

此时，construct()方法定义了其他buildPartX()方法调用的次序，为其他方法的执行提供了一个流程模板，这与我们在后面要学习的模板方法模式非常类似。

以上两种对Director类的省略方式都不影响系统的灵活性和可扩展性，同时还简化了系统结构，但加重了抽象建造者类的职责，如果construct()方法较为复杂，待构建产品的组成部分较多，建议还是将construct()方法单独封装在Director中，这样做更符合“单一职责原则”。

2.钩子方法的引入

建造者模式除了逐步构建一个复杂产品对象外，还可以通过Director类来更加精细地控制产品的创建过程，例如增加一类称之为钩子方法(HookMethod)的特殊方法来控制是否对某个buildPartX()的调用。

钩子方法的返回类型通常为boolean类型，方法名一般为isXXX()，钩子方法定义在抽象建造者类中。例如我们可以在游戏角色的抽象建造者类ActorBuilder中定义一个方法isBareheaded()，用于判断某个角色是否为“光头(Bareheaded)”，在ActorBuilder为之提供一个默认实现，其返回值为false，代码如下所示：

  1. abstract class ActorBuilder
  2. {
  3.        protected  Actor actor = new Actor();
  5.        public  abstract void buildType();
  6.        public  abstract void buildSex();
  7.        public  abstract void buildFace();
  8.        public  abstract void buildCostume();
  9.        public  abstract void buildHairstyle();
  11.        //钩子方法
  12. public boolean isBareheaded()
  13.        {
  14.               return false;
  15.        }
  17.        public  Actor createActor()
  18.        {
  19.               return  actor;
  20.        }
  21. }

如果某个角色无须构建头发部件，例如“恶魔(Devil)”，则对应的具体建造器DevilBuilder将覆盖isBareheaded()方法，并将返回值改为true，代码如下所示：

  1. class DevilBuilder extends ActorBuilder
  2. {
  3.        public  void buildType()
  4.        {
  5.               actor.setType("恶魔");
  6.        }
  7.        public  void buildSex()
  8.        {
  9.               actor.setSex("妖");
  10.        }
  11.        public  void buildFace()
  12.        {
  13.               actor.setFace("丑陋");
  14.        }
  15.        public  void buildCostume()
  16.        {
  17.               actor.setCostume("黑衣");
  18.        }
  19.        public  void buildHairstyle()
  20.        {
  21.               actor.setHairstyle("光头");
  22.        }
  23.      //覆盖钩子方法
  24.        public boolean isBareheaded()
  25.        {
  26.               return true;
  27.        }     
  28. }

此时，指挥者类ActorController的代码修改如下：

  1. class ActorController
  2. {
  3.        public  Actor construct(ActorBuilder ab)
  4.        {
  5.               Actor  actor;
  6.               ab.buildType();
  7.               ab.buildSex();
  8.               ab.buildFace();
  9.               ab.buildCostume();
  10.          //通过钩子方法来控制产品的构建
  11.               if(!ab.isBareheaded())
  12.               {
  13.                      ab. buildHairstyle();
  14.               }
  15.               actor=ab.createActor();
  16.               return  actor;
  17.        }
  18. }

当在客户端代码中指定具体建造者类型并通过指挥者来实现产品的逐步构建时，将调用钩子方法isBareheaded()来判断游戏角色是否有头发，如果isBareheaded()方法返回true，即没有头发，则跳过构建发型的方法buildHairstyle()；否则将执行buildHairstyle()方法。通过引入钩子方法，我们可以在Director中对复杂产品的构建进行精细的控制，不仅指定buildPartX()方法的执行顺序，还可以控制是否需要执行某个buildPartX()方法。

8.5 建造者模式总结

建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品，在软件开发中，如果我们需要创建复杂对象并希望系统具备很好的灵活性和可扩展性可以考虑使用建造者模式。

1.主要优点

建造者模式的主要优点如下：

(1) 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

(2) 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”

(3) 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

2.主要缺点

建造者模式的主要缺点如下：

(1) 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，例如很多组成部分都不相同，不适合使用建造者模式，因此其使用范围受到一定的限制。

(2) 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加系统的理解难度和运行成本。

3.适用场景

在以下情况下可以考虑使用建造者模式：

(1) 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

(2) 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

(3) 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。

(4) 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

练习

Sunny软件公司欲开发一个视频播放软件，为了给用户使用提供方便，该播放软件提供多种界面显示模式，如完整模式、精简模式、记忆模式、网络模式等。在不同的显示模式下主界面的组成元素有所差异，如在完整模式下将显示菜单、播放列表、主窗口、控制条等，在精简模式下只显示主窗口和控制条，而在记忆模式下将显示主窗口、控制条、收藏列表等。尝试使用建造者模式设计该软件。