4. 创造者模式

文章目录

• 4. 创造者模式(使用频率：★★)
• • 1. 建造者模式的定义
  • 2. 建造者模式的结构
  • 3. 建造者模式包含以下4个角色：
  • 4. 建造者模式的实现
  • 5. 例子
  • 6. 省略Director
  • 7. 钩子方法的引入
  • 8. 优缺点
  • 9. 模式适用环境

4. 创造者模式(使用频率：★★)

1. 建造者模式的定义

建造者模式可以将部件本身和它们的组装过程分开，关注如何一步步创建一个包含多个组成部分的复杂对象，用户只需要指定复杂对象的类型即可得到该对象，而无须知道其内部的具体构造细节。

• 建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

建造者模式的定义

将客户端与包含多个部件的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可

关注如何逐步创建一个复杂的对象，不同的建造者定义了不同的创建过程

2. 建造者模式的结构

3. 建造者模式包含以下4个角色：

• Builder（抽象建造者)

• ConcreteBuilder（具体建造者）

• Product（产品）

• Director（指挥者）：指挥要创建哪个产品

4. 建造者模式的实现

• 典型的复杂对象类代码：

  public class Product {
  	private String partA; //定义部件，部件可以是任意类型，包括值类型和引用类型
  	private String partB;
  	private String partC;
   
  	//partA的Getter方法和Setter方法省略
  	//partB的Getter方法和Setter方法省略
  	//partC的Getter方法和Setter方法省略
  }

• 典型的抽象建造者类代码：

  public abstract class Builder {
      //创建产品对象
     protected Product product=new Product();
      public abstract void buildPartA();
      public abstract void buildPartB();
      public abstract void buildPartC();
  	
      //返回产品对象
      public Product getResult() {
          return product;
      }
  }

• 典型的具体建造者类代码：

  public class ConcreteBuilder1 extends Builder{
      public void buildPartA() {
          product.setPartA("A1");
      }
   
      public void buildPartB() {
          product.setPartB("B1");
      }
   
      public void buildPartC() {
          product.setPartC("C1");
      }
  }

• 典型的指挥者类代码：

  public class Director {
      private Builder builder;
  	
      public Director(Builder builder) {
          this.builder=builder;
      }
  	
      public void setBuilder(Builder builder) {
          this.builder=builer;
      }
  	
      //产品构建与组装方法
      public Product construct() {
          builder.buildPartA();
          builder.buildPartB();
          builder.buildPartC();
          return builder.getResult();
      }
  }

• 客户类代码片段：

  ……
  Builder builder = new ConcreteBuilder1(); //可通过配置文件实现
  Director director = new Director(builder);
  Product product = director.construct();
  ……

5. 例子

某游戏软件公司决定开发一款基于角色扮演的多人在线网络游戏，玩家可以在游戏中扮演虚拟世界中的一个特定角色，角色根据不同的游戏情节和统计数据（例如力量、魔法、技能等）具有不同的能力，角色也会随着不断升级而拥有更加强大的能力。 作为该游戏的一个重要组成部分，需要对游戏角色进行设计，而且随着该游戏的升级将不断增加新的角色。通过分析发现，游戏角色是一个复杂对象，它包含性别、面容等多个组成部分，不同类型的游戏角色，其性别、面容、服装、发型等外部特性都有所差异，例如“天使”拥有美丽的面容和披肩的长发，并身穿一袭白裙；而“恶魔”极其丑陋，留着光头并穿一件刺眼的黑衣。 无论是何种造型的游戏角色，它的创建步骤都大同小异，都需要逐步创建其组成部分，再将各组成部分装配成一个完整的游戏角色。现使用建造者模式来实现游戏角色的创建。

实例代码

(1) Actor：游戏角色类，充当复杂产品对象

(2) ActorBuilder：游戏角色建造者，充当抽象建造者

(3) HeroBuilder：英雄角色建造者，充当具体建造者

(4) AngelBuilder：天使角色建造者，充当具体建造者

(5) DevilBuilder：恶魔角色建造者，充当具体建造者

(6) ActorController：角色控制器，充当指挥者

(7) Client：客户端测试类

结果及分析

如果需要更换具体角色建造者，只需要修改配置文件

当需要增加新的具体角色建造者时，只需将新增具体角色建造者作为抽象角色建造者的子类，然后修改配置文件即可，原有代码无须修改，完全符合开闭原则

<?xml version="1.0"?>
<config>
    <className>designpatterns.builder.AngelBuilder</className>
</config>

6. 省略Director

省略掉Director类(把复杂产品和创建产品的过程(静态方法)嵌入到抽象创造者中，)

• 抽象创造者

public abstract class ActorBuilder {
    protected static Actor actor = new Actor();
	
    public abstract void buildType();
    public abstract void buildSex();
    public abstract void buildFace();
    public abstract void buildCostume();
    public abstract void buildHairstyle();
 
    public static Actor construct(ActorBuilder ab) {
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        ab.buildHairstyle();
        return actor;
    }
}

将指挥者嵌入到抽象工厂中

• 使用方法

……
ActorBuilder ab;
ab = (ActorBuilder)XMLUtil.getBean();
		
Actor actor;
actor = ab.construct();
……

7. 钩子方法的引入

钩子方法(Hook Method)：返回类型通常为boolean类型，方法名一般为isXXX()

public abstract class ActorBuilder {
    protected Actor actor = new Actor();
	
    public abstract void buildType();
    public abstract void buildSex();
    public abstract void buildFace();
    public abstract void buildCostume();
    public abstract void buildHairstyle();
	
    //钩子方法
public boolean isBareheaded() {
        return false;
    }
	
    public Actor createActor() {
        return actor;
    }
}

public class DevilBuilder extends ActorBuilder {
	public void buildType() {
		actor.setType("恶魔");
	}
 
	public void buildSex() {
		actor.setSex("妖");
	}
 
	public void buildFace() {
		actor.setFace("丑陋");
	}
 
	public void buildCostume() {
		actor.setCostume("黑衣");
	}
 
	public void buildHairstyle() {
		actor.setHairstyle("光头");
	}
 
                  //覆盖钩子方法
	public boolean isBareheaded() {
		return true;
	}	
}

public class ActorController {
    public Actor construct(ActorBuilder ab) {
        Actor actor;
        ab.buildType();
        ab.buildSex();
        ab.buildFace();
        ab.buildCostume();
        //通过钩子方法来控制产品的构建
        if(!ab.isBareheaded()) {
            ab.buildHairstyle();
        }
        actor=ab.createActor();
        return actor;
    }
}

8. 优缺点

• 优点

客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象

每一个具体建造者都相对独立，与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，扩展方便，符合开闭原则

可以更加精细地控制产品的创建过程

• 缺点

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

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

9. 模式适用环境

1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员变量

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

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

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