设计模式-建造者模式

设计模式-建造者模式

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

建造者模式将一个复杂对象的构造分解为多个简单的步骤，然后一步一步的构建，产品的组成部分是不变的，但是每一个部件是灵活选择的。

依然以汽车为例，汽车是一个复杂的对象，它由，底盘、车架、轮胎、发动机、内饰、等组装而成，4S点的采购员去采购一批小轿车，不能让汽车采购员去购买汽车组件然后组装小轿车，我们采用建造者模式来解决这个问题。

我们把汽车的组装过程封装到一个建造者类中，建造者负责根据需求组装产品，然后交付给采购员，然而现实中采购员不会直接指示建造者如何组装产品，而是采购员直接告诉汽车公司的老板自己要采购什么样的轿车，汽车公司老板把组装好的轿车交付给采购员。

结构：
Director(建造指挥者)
负责指挥建造者按照一定的步骤去构建产品

Product (抽象、接口 产品)
建造者所创建对象对应类的父类或接口

Concrete Product (具体产品)
建造的目标

Builder(抽象、接口 建造者)
定义创建产品的每个步骤方法接口

Concrete Builder(具体建造者)
真正负责构建产品的角色

实现如下

汽车的代码
ICar 是上边结构中的 Product(产品)
BenzSaloonCar 、BMWSaloonCar 是上边结构中的 Concrete Product (具体产品)

    // 汽车接口
    public interface ICar
    {
        // 保存安装的部件
        List<string> unitList { get; set; }

        // 安装组件
        void AddUnit(string chassis);

        void Print();
    }

    // 奔驰小轿车
    public class BenzSaloonCar : ICar
    {
        public List<string> unitList { get; set; }

        public void AddUnit(string unit)
        {
            if (null == unitList)
            {
                unitList = new List<string>();
            }
            unitList.Add(unit);
        }

        public void Print()
        {
            Console.WriteLine("这是奔驰小轿车,安装了下面这些部件");
            for (int i = 0; i < unitList.Count; ++i)
            {
                Console.WriteLine(unitList[i]);
            }
            Console.WriteLine();
        }
    }

    // 宝马小轿车
    public class BMWSaloonCar : ICar
    {
        public List<string> unitList { get; set; }

        public void AddUnit(string unit)
        {
            if (null == unitList)
            {
                unitList = new List<string>();
            }
            unitList.Add(unit);
        }

        public void Print()
        {
            Console.WriteLine("这是宝马小轿车,安装了下面这些部件");
            for (int i = 0; i < unitList.Count; ++i)
            {
                Console.WriteLine(unitList[i]);
            }
            Console.WriteLine();
        }
    }

建造的代码如下
IBuilder 是上边结构中的 Builder(抽象、接口 建造者)
BenzBuilder、BMWBuilder 是上边结构中的 Concrete Builder(具体建造者)

    public interface IBuilder
    {
        // 开始创建
        void StartBuild();

        // 安装底盘
        void AddChassis();

        // 安装轮胎
        void AddTyre();

        // 安装车架
        void AddShelf();

        // 安装发动机
        void AddEngine();

        // 安装内饰
        void AddTrim();

        ICar GetCar();
    }

    // 奔驰建造者
    public class BenzBuilder : IBuilder
    {
        private ICar car;

        // 开始创建
        public void StartBuild()
        {
            car = new BenzSaloonCar();
        }

        // 安装底盘
        public void AddChassis()
        {
            car.AddUnit("奔驰轿车底盘");
        }

        // 安装轮胎
        public void AddTyre()
        {
            car.AddUnit("奔驰轮胎");
        }

        // 安装车架
        public void AddShelf()
        {
            car.AddUnit("奔驰车架");
        }

        // 安装发动机
        public void AddEngine()
        {
            car.AddUnit("奔驰发动机");
        }

        // 安装内饰
        public void AddTrim()
        {
            car.AddUnit("奔驰内饰");
        }

        public ICar GetCar()
        {
            return car;
        }
    }

    // 宝马建造者
    public class BMWBuilder : IBuilder
    {
        private ICar car;

        // 开始创建
        public void StartBuild()
        {
            car = new BMWSaloonCar();
        }

        // 安装底盘
        public void AddChassis()
        {
            car.AddUnit("宝马轿车底盘");
        }

        // 安装轮胎
        public void AddTyre()
        {
            car.AddUnit("宝马奔驰轮胎");
        }

        // 安装车架
        public void AddShelf()
        {
            car.AddUnit("宝马奔驰车架");
        }

        // 安装发动机
        public void AddEngine()
        {
            car.AddUnit("宝马奔驰发动机");
        }

        // 安装内饰
        public void AddTrim()
        {
            car.AddUnit("宝马奔驰内饰");
        }

        public ICar GetCar()
        {
            return car;
        }
    }

指挥者代码如下
Director 是上边结构中的 Director(建造指挥者)

        // 建造过程，安装步骤是固定的
        public void Construct(IBuilder builder)
        {
            // 开始建造
            builder.StartBuild();

            // 安装底盘
            builder.AddChassis();

            // 安装轮胎
            builder.AddTyre();

            // 安装车架
            builder.AddShelf();

            // 安装发动机
            builder.AddEngine();

            // 安装内饰
            builder.AddTrim();
        }

调用如下

    class Customer
    {
        public Customer()
        {
            // 创建指挥者
            Director director = new Director();

            // 奔驰建造者
            BenzBuilder benzBuilder = new BenzBuilder();
            // 指挥建造
            director.Construct(benzBuilder);
            // 返回建造好的轿车
            ICar benzSaloonCar = benzBuilder.GetCar();
            benzSaloonCar.Print();


            // 宝马建造者
            BMWBuilder bMWBuilder = new BMWBuilder();
            // 指挥建造
            director.Construct(bMWBuilder);
            ICar bMWSaloonCar = bMWBuilder.GetCar();
            // 返回建造好的轿车
            bMWSaloonCar.Print();
        }
    }

优点：
(1)封装性好，建造者模式使客户不必知道产品内部组成的细节，降低了客户与产品类的耦合
(2)建造者独立，容易扩展，当有新产品时，只需要添加一个建造者即可，不影响现有系统
(3)控制细节风险，由于具体的建造是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响

缺点：
(1)产品的组成部分必须相同，限制了使用范围
(2)如果产品的内部变化复杂，如果产品内部发生变化，建造者也要同步修改，维护成本较大