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

8.3 完整解决方案

Sunny公司开发人员决定使用建造者模式来实现游戏角色的创建，其基本结构如图8-3所示：

复杂对象的组装与创建——建造者模式（二） - 图1

图8-3 游戏角色创建结构图

在图8-3中，ActorController充当指挥者，ActorBuilder充当抽象建造者，HeroBuilder、AngelBuilder和DevilBuilder充当具体建造者，Actor充当复杂产品。完整代码如下所示： //Actor角色类：复杂产品，考虑到代码的可读性，只列出部分成员属性，且成员属性的类型均为String，真实情况下，有些成员属性的类型需自定义

  1. class Actor
  2. {
  3.        private  String type; //角色类型
  4.        private  String sex; //性别
  5.        private  String face; //脸型
  6.        private  String costume; //服装
  7.        private  String hairstyle; //发型
  9.        public  void setType(String type) {
  10.               this.type  = type;
  11.        }
  12.        public  void setSex(String sex) {
  13.               this.sex  = sex;
  14.        }
  15.        public  void setFace(String face) {
  16.               this.face  = face;
  17.        }
  18.        public  void setCostume(String costume) {
  19.               this.costume  = costume;
  20.        }
  21.        public  void setHairstyle(String hairstyle) {
  22.               this.hairstyle  = hairstyle;
  23.        }
  24.        public  String getType() {
  25.               return  (this.type);
  26.        }
  27.        public  String getSex() {
  28.               return  (this.sex);
  29.        }
  30.        public  String getFace() {
  31.               return  (this.face);
  32.        }
  33.        public  String getCostume() {
  34.               return  (this.costume);
  35.        }
  36.        public  String getHairstyle() {
  37.               return  (this.hairstyle);
  38.        }
  39. }
  41. //角色建造器：抽象建造者
  42. abstract class ActorBuilder
  43. {
  44.        protected  Actor actor = new Actor();
  46.        public  abstract void buildType();
  47.        public  abstract void buildSex();
  48.        public  abstract void buildFace();
  49.        public  abstract void buildCostume();
  50.        public  abstract void buildHairstyle();
  52.     //工厂方法，返回一个完整的游戏角色对象
  53.        public Actor createActor()
  54.        {
  55.               return actor;
  56.        }
  57. }
  59. //英雄角色建造器：具体建造者
  60. class HeroBuilder extends ActorBuilder
  61. {
  62.        public  void buildType()
  63.        {
  64.               actor.setType("英雄");
  65.        }
  66.        public  void buildSex()
  67.        {
  68.               actor.setSex("男");
  69.        }
  70.        public  void buildFace()
  71.        {
  72.               actor.setFace("英俊");
  73.        }
  74.        public  void buildCostume()
  75.        {
  76.               actor.setCostume("盔甲");
  77.        }
  78.        public  void buildHairstyle()
  79.        {
  80.               actor.setHairstyle("飘逸");
  81.        }    
  82. }
  84. //天使角色建造器：具体建造者
  85. class AngelBuilder extends ActorBuilder
  86. {
  87.        public  void buildType()
  88.        {
  89.               actor.setType("天使");
  90.        }
  91.        public  void buildSex()
  92.        {
  93.               actor.setSex("女");
  94.        }
  95.        public  void buildFace()
  96.        {
  97.               actor.setFace("漂亮");
  98.        }
  99.        public  void buildCostume()
  100.        {
  101.               actor.setCostume("白裙");
  102.        }
  103.        public  void buildHairstyle()
  104.        {
  105.               actor.setHairstyle("披肩长发");
  106.        }    
  107. }
  109. //恶魔角色建造器：具体建造者
  110. class DevilBuilder extends ActorBuilder
  111. {
  112.        public  void buildType()
  113.        {
  114.               actor.setType("恶魔");
  115.        }
  116.        public  void buildSex()
  117.        {
  118.               actor.setSex("妖");
  119.        }
  120.        public  void buildFace()
  121.        {
  122.               actor.setFace("丑陋");
  123.        }
  124.        public  void buildCostume()
  125.        {
  126.               actor.setCostume("黑衣");
  127.        }
  128.        public  void buildHairstyle()
  129.        {
  130.               actor.setHairstyle("光头");
  131.        }    
  132. }

指挥者类ActorController定义了construct()方法，该方法拥有一个抽象建造者ActorBuilder类型的参数，在该方法内部实现了游戏角色对象的逐步构建，代码如下所示：

  1. //游戏角色创建控制器：指挥者
  2. class ActorController
  3. {
  4.     //逐步构建复杂产品对象
  5.        public Actor construct(ActorBuilder ab)
  6.        {
  7.               Actor actor;
  8.               ab.buildType();
  9.               ab.buildSex();
  10.               ab.buildFace();
  11.               ab.buildCostume();
  12.               ab.buildHairstyle();
  13.               actor=ab.createActor();
  14.               return actor;
  15.        }
  16. }

为了提高系统的灵活性和可扩展性，我们将具体建造者类的类名存储在配置文件中，并通过工具类XMLUtil来读取配置文件并反射生成对象，XMLUtil类的代码如下所示：

  1. import javax.xml.parsers.*;
  2. import org.w3c.dom.*;
  3. import org.xml.sax.SAXException;
  4. import java.io.*;
  5. class XMLUtil
  6. {
  7. //该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
  8.        public  static Object getBean()
  9.        {
  10.               try
  11.               {
  12.                      //创建文档对象
  13.                      DocumentBuilderFactory  dFactory = DocumentBuilderFactory.newInstance();
  14.                      DocumentBuilder  builder = dFactory.newDocumentBuilder();
  15.                      Document  doc;                                                
  16.                      doc  = builder.parse(new File("config.xml"));
  18.                      //获取包含类名的文本节点
  19.                      NodeList  nl = doc.getElementsByTagName("className");
  20.             Node  classNode=nl.item(0).getFirstChild();
  21.             String  cName=classNode.getNodeValue();
  23.             //通过类名生成实例对象并将其返回
  24.             Class c=Class.forName(cName);
  25.                  Object obj=c.newInstance();
  26.             return obj;
  27.          }  
  28.          catch(Exception e)
  29.          {
  30.               e.printStackTrace();
  31.               return null;
  32.           }
  33.        }
  34. }

配置文件config.xml中存储了具体建造者类的类名，代码如下所示：

  1. <?xml version="1.0"?>
  2. <config>
  3.        <className>AngelBuilder</className>
  4. </config>   
  5.         编写如下客户端测试代码：
  6. class Client
  7. {
  8.        public  static void main(String args[])
  9.        {
  10.               ActorBuilder ab; //针对抽象建造者编程
  11.               ab =  (ActorBuilder)XMLUtil.getBean(); //反射生成具体建造者对象
  13.          ActorController ac = new  ActorController();
  14.               Actor actor;
  15.               actor = ac.construct(ab); //通过指挥者创建完整的建造者对象
  17.               String  type = actor.getType();
  18.               System.out.println(type  + "的外观：");
  19.               System.out.println("性别：" + actor.getSex());
  20.               System.out.println("面容：" + actor.getFace());
  21.               System.out.println("服装：" + actor.getCostume());
  22.               System.out.println("发型：" + actor.getHairstyle());
  23.        }
  24. }

编译并运行程序，输出结果如下：

  1. 天使的外观：
  2. 性别：女
  3. 面容：漂亮
  4. 服装：白裙
  5. 发型：披肩长发

在建造者模式中，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。在游戏角色实例中，如果需要更换角色，只需要修改配置文件，更换具体角色建造者类即可；如果需要增加新角色，可以增加一个新的具体角色建造者类作为抽象角色建造者的子类，再修改配置文件即可，原有代码无须修改，完全符合“开闭原则”。