第四节：组合模式和建筑者模式详解

一. 组合模式

1. 背景

　在现实生活中，存在很多“部分-整体”的关系，例如，大学中的部门与学院、总公司中的部门与分公司、学习用品中的书与书包、生活用品中的衣月艮与衣柜以及厨房中的锅碗瓢盆等。在软件开发中也是这样，例如，文件系统中的文件与文件夹、窗体程序中的简单控件与容器控件等。对这些简单对象与复合对象的处理，如果用组合模式来实现会很方便。

2. 定义和特点

(1). 定义：有时又叫作部分-整体模式，它是一种将对象组合成树状的层次结构的模式，用来表示“部分-整体”的关系，使用户对单个对象和组合对象具有一致的访问性。

(2). 优点：

　　A. 组合模式使得客户端代码可以一致地处理单个对象和组合对象，无须关心自己处理的是单个对象，还是组合对象，这简化了客户端代码；

　　B. 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”；

(3). 缺点

　　A. 设计较复杂，客户端需要花更多时间理清类之间的层次关系；

　　B. 不容易限制容器中的构件；

　　C. 不容易用继承的方法来增加构件的新功能；

3. 具体实现

(1). 模式结构

 　  可以自身嵌套结构。

(2). 使用场景

 　 存储上下级关系，CEO→技术主管→员工；CEO→销售主管→员工。

(3). 代码实操

上下级自身嵌套代码：

     /// <summary>
    /// 员工类
    /// </summary>
    public class Employee
    {
        private string name;
        private string dept;
        private int salary;
        //代表下级子类
        private List<Employee> subordinates;

        //构造函数
        public Employee(string name, string dept, int sal)
        {
            this.name = name;
            this.dept = dept;
            this.salary = sal;
            subordinates = new List<Employee>();
        }

        public void add(Employee e)
        {
            subordinates.Add(e);
        }

        public void remove(Employee e)
        {
            subordinates.Remove(e);
        }

        public List<Employee> getSubordinates()
        {
            return subordinates;
        }

        public string toString()
        {
            return ("Employee :[ Name : " + name
            + ", dept : " + dept + ", salary :"
            + salary + " ]");
        }
    }

测试代码：

            {
                // 1、树形机构的场景，使用组合模式
                Employee CEO = new Employee("张三", "CEO", 30000);

                Employee headMarketing = new Employee("李四", "技术经理", 20000);
                Employee headSales = new Employee("王五", "销售经理", 20000);

                Employee clerk1 = new Employee("赵六", "销售", 10000);
                Employee clerk2 = new Employee("钱七", "销售", 10000);

                Employee salesExecutive1 = new Employee("Tony", "技术", 10000);
                Employee salesExecutive2 = new Employee("Mark", "技术", 10000);

                CEO.add(headSales);
                CEO.add(headMarketing);

                headSales.add(clerk1);
                headSales.add(clerk2);

                headMarketing.add(salesExecutive1);
                headMarketing.add(salesExecutive2);

                //打印该组织的所有员工
                Console.WriteLine(CEO.toString());
                foreach (Employee headEmployee in CEO.getSubordinates())
                {
                    Console.WriteLine(headEmployee.toString());
                    foreach (Employee employee in headEmployee.getSubordinates())
                    {
                        Console.WriteLine(employee.toString());
                    }
                }
            }

运行结果：

 

4. 适用场景分析 

　A. 在需要表示一个对象整体与部分的层次结构的场合。

　B. 要求对用户隐藏组合对象与单个对象的不同，用户可以用统一的接口使用组合结构中的所有对象的场合。

二. 建筑者模式

1. 背景

　在软件开发过程中有时需要创建一个复杂的对象，这个复杂对象通常由多个子部件按一定的步骤组合而成。例如，计算机是由 OPU、主板、内存、硬盘、显卡、机箱、显示器、键盘、鼠标等部件组装而成的，采购员不可能自己去组装计算机，而是将计算机的配置要求告诉计算机销售公司，计算机销售公司安排技术人员去组装计算机，然后再交给要买计算机的采购员。

　生活中这样的例子很多，如游戏中的不同角色，其性别、个性、能力、脸型、体型、服装、发型等特性都有所差异；还有汽车中的方向盘、发动机、车架、轮胎等部件也多种多样；每封电子邮件的发件人、收件人、主题、内容、附件等内容也各不相同。

　以上所有这些产品都是由多个部件构成的，各个部件可以灵活选择，但其创建步骤都大同小异。这类产品的创建无法用前面介绍的工厂模式描述，只有建造者模式可以很好地描述该类产品的创建。

2. 定义和特点

(1). 定义

　　指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象，然后一步一步构建而成。它将变与不变相分离，即产品的组成部分是不变的，但每一部分是可以灵活选择的。

(2). 优点

　A. 各个具体的建造者相互独立，有利于系统的扩展。

　B. 客户端不必知道产品内部组成的细节，便于控制细节风险。

(3). 缺点

　A. 产品的组成部分必须相同，这限制了其使用范围。

　B. 如果产品的内部变化复杂，该模式会增加很多的建造者类。

(4). 与工厂方法模式的区别

　建造者模式注重零部件的组装过程，而工厂方模式更注重零部件的创建过程，但两者可以结合使用。

3. 具体实现

(1). 模式结构

　建造者（Builder）模式由产品、抽象建造者、具体建造者、指挥者等 4 个要素构成。 　

　A. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个零部件。

　B. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。

　C. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。

　D. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

PS：如果创建的产品种类只有一种，只需要一个具体建造者，这时可以省略掉抽象建造者，甚至可以省略掉指挥者角色。

结构图如下：

(2). 使用场景

 　现在要构建自行车，包括核心组件frame、seat、tire，而每个组件可选的材料有多种，自行车的构建顺序是固定的，比如按照这个顺序：BuidFrame、BuildSeat、BuildTire。这个场景就可以使用建筑者模式。

(3). 代码实操

各种自行车材料代码：

    /// <summary>
    /// 自行车框架
    /// </summary>
    public interface IFrame
    {
        void show();
    }
    /// <summary>
    /// 自行车座椅
    /// </summary>
    public interface ISeat
    {
        void show();
    }
     /// <summary>
    /// 自行车轮胎
    /// </summary>
    public interface ITire
    {
        void show();
    }
    /// <summary>
    /// 合金自行车框架1
    /// </summary>
    public class AlloyFrame1 : IFrame
    {
        public void show()
        {
            Console.WriteLine("我是合金自行车框架1");
        }
    }
    /// <summary>
    /// 合金自行车框架2
    /// </summary>
    public class AlloyFrame2 : IFrame
    {
        public void show()
        {
            Console.WriteLine("我是合金自行车框架2");
        }
    }
    /// <summary>
    /// 真皮座椅1
    /// </summary>
    public class DermisSeat1 : ISeat
    {
        public void show()
        {
            Console.WriteLine("我是真皮座椅1");
        }
    }
    /// <summary>
    /// 真皮座椅2
    /// </summary>
    public class DermisSeat2 : ISeat
    {
        public void show()
        {
            Console.WriteLine("我是真皮座椅2");
        }
    }
     /// <summary>
    /// 结实的轮胎1
    /// </summary>
    public class SolidTire1 : ITire
    {
        public void show()
        {
            Console.WriteLine("我是结实的轮胎1");
        }
    }
    /// <summary>
    /// 结实的轮胎2
    /// </summary>
    public class SolidTire2 : ITire
    {
        public void show()
        {
            Console.WriteLine("我是结实的轮胎2");
        }
    }

自行车代码：

 /// <summary>
    /// 自行车类
    /// </summary>
    public class Bike
    {
        /// <summary>
        /// 自行车框架
        /// </summary>
        public IFrame frame { set; get; }
        /// <summary>
        /// 自行车座椅
        /// </summary>
        public ISeat seat { set; get; }
        /// <summary>
        /// 自行车 轮胎
        /// </summary>
        public ITire tire { set; get; }

        /// <summary>
        /// 获取自行车的详情信息
        /// </summary>
        public void GetDetils()
        {
            Console.WriteLine("自行车的详细信息如下：");
            frame.show();
            seat.show();
            tire.show();
        }
    }

抽象建筑者和具体建筑者：

 /// <summary>
    /// 抽象建筑者类
    /// 如果只有一个具体的建筑者类，则可以省略该抽象建筑者类的
    /// </summary>
    public abstract class AbstractBuilder
    {
        public Bike mBike = new Bike();

        public abstract void BuildFrame();

        public abstract void BuildSeat();

        public abstract void BuildTire();

        /// <summary>
        /// 返回自行车对象
        /// </summary>
        /// <returns></returns>
        public abstract Bike Build();
       

    }
 /// <summary>
    /// 自行车建筑者类1
    /// </summary>
    public class BikeBuilder1: AbstractBuilder
    {
        /// <summary>
        /// 构建frame
        /// </summary>
        public override void BuildFrame()
        {
            mBike.frame = new AlloyFrame1();
        }

        /// <summary>
        /// 构建seat
        /// </summary>
        public override void BuildSeat()
        {
            mBike.seat = new DermisSeat1();
        }

        /// <summary>
        /// 构建tire
        /// </summary>
        public override void BuildTire()
        {
            mBike.tire = new SolidTire1();
        }

        /// <summary>
        /// 返回直行车对象
        /// </summary>
        /// <returns></returns>
        public override Bike Build()
        {
            return mBike;
        }
    }
  /// <summary>
    /// 自行车建筑者类2
    /// </summary>
    public class BikeBuilder2 : AbstractBuilder
    {
        /// <summary>
        /// 构建frame
        /// </summary>
        public override void BuildFrame()
        {
            mBike.frame = new AlloyFrame2();
        }

        /// <summary>
        /// 构建seat
        /// </summary>
        public override void BuildSeat()
        {
            mBike.seat = new DermisSeat2();
        }

        /// <summary>
        /// 构建tire
        /// </summary>
        public override void BuildTire()
        {
            mBike.tire = new SolidTire2();
        }

        /// <summary>
        /// 返回直行车对象
        /// </summary>
        /// <returns></returns>
        public override Bike Build()
        {
            return mBike;
        }
    }

指挥者：

  /// <summary>
    /// 指挥者
    /// 调用建造者中的方法完成复杂对象的创建
    /// 如果只有一个建筑者的话,可以省略该指挥者的角色
    /// </summary>
    public class BikeDirector
    {
        private AbstractBuilder _builder;
        public BikeDirector(AbstractBuilder builder)
        {
            this._builder = builder;
        }
        /// <summary>
        /// Bike的构建和组装
        /// </summary>
        /// <returns></returns>
        public Bike CreateBike()
        {
            _builder.BuildFrame();
            _builder.BuildSeat();
            _builder.BuildTire();

            return _builder.Build();
        }
    }

测试代码：

                //1.普通模式
                {
                    Console.WriteLine("-------------------下面是普通模式构建自行车-------------------------");
                    //1. 构建自行车
                    Bike b = new Bike();
                    b.frame = new AlloyFrame1();
                    b.seat = new DermisSeat2();
                    b.tire = new SolidTire1();

                    //2. 输出自行车信息
                    b.GetDetils();
                }

                //2. 使用建筑者模式
                {
                    Console.WriteLine("-------------------下面是使用建筑者模式构建自行车-------------------------");
                    //1. 构建建筑者
                    BikeBuilder1 builder = new BikeBuilder1();
                    builder.BuildFrame();
                    builder.BuildSeat();
                    builder.BuildTire();
                    //2. 构建自行车
                    Bike bike = builder.Build();
                    //3. 输出自行车的信息
                    bike.GetDetils();
                }

                //3. 引入抽象建筑者父类
                {
                    Console.WriteLine("-------------------下面是 引入抽象建筑者父类 构建自行车-------------------------");
                    //1. 构建建筑者1
                    AbstractBuilder builder = new BikeBuilder1();
                    builder.BuildFrame();
                    builder.BuildSeat();
                    builder.BuildTire();
                    //2. 构建自行车
                    Bike bike = builder.Build();
                    //3. 输出自行车的信息
                    bike.GetDetils();

                    //1. 构建建筑者2
                    AbstractBuilder builder2 = new BikeBuilder2();
                    builder2.BuildFrame();
                    builder2.BuildSeat();
                    builder2.BuildTire();
                    //2. 构建自行车
                    Bike bike2 = builder2.Build();
                    //3. 输出自行车的信息
                    bike2.GetDetils();
                }

                //4. 引入指挥者
                {
                    Console.WriteLine("-------------------下面是 引入指挥者 构建自行车-------------------------");
                    //指挥者1
                    BikeDirector dirctor1 = new BikeDirector(new BikeBuilder1());
                    Bike bike1 = dirctor1.CreateBike();
                    bike1.GetDetils();

                    //指挥者2
                    BikeDirector dirctor2 = new BikeDirector(new BikeBuilder2());
                    Bike bike2 = dirctor2.CreateBike();
                    bike2.GetDetils();
                }

运行效果：

 

4. 适用场景分析

　建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

　A. 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。

　B. 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

 

!

• 作       者 : Yaopengfei(姚鹏飞)
• 博客地址 : http://www.cnblogs.com/yaopengfei/
• 声     明1 : 如有错误，欢迎讨论，请勿谩骂^_^。
• 声     明2 : 原创博客请在转载时保留原文链接或在文章开头加上本人博客地址，否则保留追究法律责任的权利。