设计模式详解：建造者模式

今天来看一下创建新模式中的第五种模式：建造者模式。仍然是先看两张图，复习模式类型，加深记忆。

 

定义：

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

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

结构：

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

Builder（抽象建造者）

ConcreteBuilder（具体建造者）

Product（产品）

Director（指挥者）

分析：

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

类图：

适用性：

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

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

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

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

优点：

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

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

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

缺点：

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

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

---

案例1：（.NET代码）

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

代码功能清单：

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

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

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

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

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

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

(7) 配置文件App.config

(8) Program：客户端测试类

Actor.cs

namespace BuilderSample
{
    class Actor
    {
        private string type; //角色类型
        private string sex; //性别
        private string face; //面容
        private string costume; //服装
        private string hairstyle; //发型

        public string Type
        {
            get { return type; }
            set { type = value; }
        }

        public string Sex
        {
            get { return sex; }
            set { sex = value; }
        }

        public string Face
        {
            get { return face; }
            set { face = value; }
        }

        public string Costume
        {
            get { return costume; }
            set { costume = value; }
        }

        public string Hairstyle
        {
            get { return hairstyle; }
            set { hairstyle = value; }
        }
    }
}

ActorBuilder.cs

namespace BuilderSample
{
    //角色建造者：抽象建造者
    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 CreateActor()
        {
            return actor;
        }
    }
}

HeroBuilder.cs

namespace BuilderSample
{
    class HeroBuilder : 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 = "飘逸";
        }	
    }
}

AngelBuilder.cs

namespace BuilderSample
{
    class AngelBuilder : 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 = "披肩长发";
        }	
    }
}

DevilBuilder.cs

namespace BuilderSample
{
    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 = "光头";
        }	
    }
}

ActorController.cs

namespace BuilderSample
{
    class ActorController
    {
        //逐步构建复杂产品对象
        public Actor Construct(ActorBuilder ab)
        {
            Actor actor;
            ab.BuildType();
            ab.BuildSex();
            ab.BuildFace();
            ab.BuildCostume();
            ab.BuildHairstyle();
            actor = ab.CreateActor();
            return actor;
        }
    }
}

App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <appSettings>
    <add key="builder" value="BuilderSample.HeroBuilder"/>
  </appSettings>
</configuration>

Program.cs

using System;
using System.Configuration;
using System.Reflection;

namespace BuilderSample
{
    class Program
    {
        static void Main(string[] args)
        {

		    ActorBuilder ab; //针对抽象建造者编程
            //读取配置文件
            string builderType = ConfigurationManager.AppSettings["builder"]; 
            //反射生成对象
            ab = (ActorBuilder)Assembly.Load("BuilderSample").CreateInstance(builderType); 

            ActorController ac = new ActorController();
		    Actor actor;
		    actor = ac.Construct(ab); //通过指挥者创建完整的建造者对象
            
            Console.WriteLine("{0}的外观：",actor.Type);
            Console.WriteLine("性别：{0}",actor.Sex);
            Console.WriteLine("面容：{0}",actor.Face);
            Console.WriteLine("服装：{0}",actor.Costume);
            Console.WriteLine("发型：{0}",actor.Hairstyle);
            Console.Read();
        }
    }
}

案例2：（JAVA代码）

Builder

public interface PersonBuilder {

    void buildHead();
    
    void buildBody();
    
    void buildFoot();

    Person buildPerson();
}

ConcreteBuilder

public class ManBuilder implements PersonBuilder {

    Person person;
    
    public ManBuilder() {
        person = new Man();
    }
    
    public void buildbody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        return person;
    }
}

Director

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

Product

public class Person {

    private String head;
    
    private String body;
    
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

Man

public class Man extends Person {

}

Test

public class Test{
    
    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

输出结果：

建造男人的身体

建造男人的脚

建造男人的头