设计模式之：建造者模式

目录

• 建造者模式概述
• 建造者模式的结构与实现
• 建造者模式的应用实例
• 指挥者类的深入讨论
• 建造者模式的优缺点与适用环境

建造者模式概述

复杂对象：如何将汽车的各个复杂部件组装成一辆完整的汽车并返回给用户？

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

建造者模式定义

• 建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
• Builder Pattern: Separate the construction of a complex object from its representation so that the same construction process can create different representations.
• 对象创建型模式

注：将客户端与包含多个部件的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。注如何逐步创建一个复杂的对象，不同的建造者定义了不同的创建过程。

建造者模式的结构与实现

建造者模式的结构

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

• Builder（抽象建造者）

抽象建造者为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件。另一类方法是getResult()，它们用于返回复杂对象。它既可以是抽象类也可以是接口。

• ConcreteBuilder（具体建造者）

具体建造者实现Builder接口，实现各个部件的构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。

• Product（产品）

产品角色是被创建的复杂对象，包含多个组成部件，具体建造者创建产品的内部表示并定义它的装配过程。

• Director（指挥者）

指挥者又叫导演类，他负责安排复杂对象的建造次序，指挥着与抽象建造者之间存在关联关系，可以在其construct建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件或反射机制），然后通过指挥者类的构造函数或者set方法将该对象传入指挥者类中。

经典建造者模式的实现

复杂对象类Product：

/**
 * Created by yitian.z on 2016/4/13.
 *
 * 复杂产品类
 */
public class Product {

    /**
     * 复杂对象组成A
     */
    private String partA;

    /**
     * 复杂对象组成B
     */
    private String partB;

    /**
     * 复杂对象组成C
     */
    private String partC;

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public String getPartC() {
        return partC;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }
}

抽象建造者类Builder：

/**
 * Created by yitian.z on 2016/4/13.
 *
 * 抽象建造者，可以为抽象类也可以是接口
 */
public abstract class Builder {

    /**
     * 抽象建造者，所要创建的product对象
     */
    protected Product product = new Product();

    /**
     * 抽象建造方法
     */
    public abstract void buildPartA();

    public abstract void buildPartB();

    public abstract void buildPartC();

    /**
     * 工厂方法，用于返回一个创建好的完整对象
     * @return
     */
    public Product getResult() {
        return product;
    }

}

具体建造者类ConcreteBuilder：

/**
 * Created by yitian.z on 2016/4/13.
 *
 * 具体建造者类
 */
public class ConcreteBuilder extends Builder {

    @Override
    public void buildPartA() {
        System.out.println("Building Part A...");
    }

    @Override
    public void buildPartB() {
        System.out.println("Building Part B...");
    }

    @Override
    public void buildPartC() {
        System.out.println("Building Part C...");
    }

//    public Product getResult() {
//        return product;
//    }
}

指挥者类Director：

/**
 * Created by yitian.z on 2016/4/13.
 *
 * 指挥者类
 */
public class Director {

    private Builder builder;

    /**
     * 构造函数
     * @param builder
     */
    public Director(Builder builder) {
        this.builder = builder;
    }

    /**
     * ???
     * @param builder
     */
    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public Product construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

客户端类Client：

public class Client {
    public static void main(String[] args) throws SAXException, IllegalAccessException, IOException, InstantiationException, ParserConfigurationException, ClassNotFoundException {
        Builder builder = (Builder) XMLUtil.getBean();
        Director director = new Director(builder);
        Product product = director.construct();
    }
}

建造者模式的应用实例

某游戏软件公司决定开发一款基于角色扮演的多人在线网络游戏，玩家可以在游戏中扮演虚拟世界中的一个特定角色，角色根据不同的游戏情节和统计数据（例如力量、魔法、技能等）具有不同的能力，角色也会随着不断升级而拥有更加强大的能力。

作为该游戏的一个重要组成部分，需要对游戏角色进行设计，而且随着该游戏的升级将不断增加新的角色。通过分析发现，游戏角色是一个复杂对象，它包含性别、面容等多个组成部分，不同类型的游戏角色，其性别、面容、服装、发型等外部特性都有所差异，例如“天使”拥有美丽的面容和披肩的长发，并身穿一袭白裙；而“恶魔”极其丑陋，留着光头并穿一件刺眼的黑衣。

无论是何种造型的游戏角色，它的创建步骤都大同小异，都需要逐步创建其组成部分，再将各组成部分装配成一个完整的游戏角色。现使用建造者模式来实现游戏角色的创建。

实例类图：

实例代码：

• (1) Actor：游戏角色类，充当复杂产品对象
• (2) ActorBuilder：游戏角色建造者，充当抽象建造者
• (3) HeroBuilder：英雄角色建造者，充当具体建造者
• (4) AngelBuilder：天使角色建造者，充当具体建造者
• (5) DevilBuilder：恶魔角色建造者，充当具体建造者
• (6) ActorController：角色控制器，充当指挥者
• (7) 配置文件App.config
• (8) Program：客户端测试类

结果及分析：

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

指挥者类的深入讨论

省略Director

1. 将Director和抽象建造者Builder合并：

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;
    string builderType = ConfigurationManager.AppSettings["builder"];
    ab = (ActorBuilder)Assembly.Load("BuilderExtend").CreateInstance(builderType);		
    Actor actor;
    actor = ActorBuilder.Construct(ab);
……

2. 将Construct()方法中的参数去掉，直接在Construct()方法中调用BuildPartX()方法：

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 Actor Construct() 
                {
		this.BuildType();
		this.BuildSex();
		this.BuildFace();
		this.BuildCostume();
		this.BuildHairstyle();
		return actor;
	}
}

钩子方法的引入

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

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();
	
       //钩子方法，需要使用virtual关键字
         public virtual bool IsBareheaded()
       {
             return false;
       }
	
	public Actor CreateActor() 
       {
	     return actor;
	}
}

class DevilBuilder : ActorBuilder
{
    public override void BuildType()
    {
        actor.Type = "恶魔";
    }
    public override void BuildSex()
    {
        actor.Sex = "妖";
    }
    public override void BuildFace()
    {
        actor.Face = "丑陋";
    }
    public override void BuildCostume()
    {
        actor.Costume = "黑衣";
    }
    public override void BuildHairstyle()
    {
        actor.Hairstyle = "光头";
    }
    //覆盖钩子方法
     public override bool IsBareheaded()
    {
        return true;
    }	
}

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;
	}
}

建造者模式的优缺点与适用环境

模式优点：

• 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
• 每一个具体建造者都相对独立，与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，扩展方便，符合开闭原则
• 可以更加精细地控制产品的创建过程

模式缺点：

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，不适合使用建造者模式，因此其使用范围受到一定的限制
• 如果产品的内部变化复杂，可能会需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大，增加了系统的理解难度和运行成本

模式适用环境：

• 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员变量
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序
• 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品