设计模式Builder（建造者）模式

1、出现原因

 在软件系统中，有时候会面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂的对象的各个部分可能面临着剧烈的变化，但是把他们组合在一起的算法很稳定。

 提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的“稳定构建算法”不随着需求的改变而改变

 2、意图：

 将复杂对象的构建与其表示相分离（客户不关心这个复杂对象产品内部是怎么创建的），使得同样的构建工程可以创建不同的表示。

3、结构图

 

4、现实的简易的例子

1、客户找到包工头,要求建一个房子,

2、包工头找到不同的建筑队(Builder)来建筑房子的每个部分,建好房子后,交付给客户

3、客户不关心房子的建造细节,由包工头负责管理房子建造的细节 

 

5、代码演示

1》第一种：含有指导者（对象的各个部分的创建顺序有main函数决定）

    //字部分A
    public class A
    {
    }
    //字部分B
    public class B
    {
    }
    //要创建的复杂的对象产品
    public class Product
    {
        public A partA { set; get; }

        public B partB { set; get; }
    }
    //创建者
    public class Builder
    {
        private Product p = new Product();

        //将创建的方法公开给 外面，这样创建的顺序就可以由指导者决定
        public void CreatA()
        {
            p.partA = new A();
        }

        public void creatB()
        {
            p.partB = new B();
        }
        //最后得到创建的产品
        public Product GetResult()
        {
            return p;
        }
    }

    public class Directer
    {
        private Builder builder = new Builder();

        //具体的创建过程（子对象的创建顺序）由 指导者 来决定
        public void Contract()
        {
            builder.creatB();
            builder.CreatA();
        }
        public Product GetResult()
        {
            return builder.GetResult();
        }
    }

主函数调用：

            Product p = null;//定义一个产品对象用来接收导者创建出来的产品
            Directer directer = new Directer();
            directer.Contract();//创建产品
            p = directer.GetResult();

2》第二种：不含指导者（将对象的创建过程在创建者内部就已经决定好了） 

    public class Product
    {
        public PartA partA { set; get; }
        public PartB partB { set; get; }
    }

    //部分对象怎么改变，已经封装起来，不进行考虑了
    public class PartA
    {
    }
    public class PartB
    {
    }

    public class Builder
    {
        private Product product = new Product();

        //创建 部分对象    如果 在增加 部分，那么就 进行扩展一个创建他的方法就可以了
        private void BuildPartA()
        {
            product.partA = new PartA();
        }

        private void BuildPartB()
        {
            product.partB = new PartB();
        }

        public void Contract()
        {
            BuildPartA();
            BuildPartB();
        }

        public Product GetResult()
        {
            return product;
        }
    }

 总结：Builder模式是将复杂对象的各个字部分的创建封装了起来，不管这个子对象怎么变化，都不会影响到那个复杂的对象，因为Builder已经将创建和表示隔离开了。

6、创建者角色和产品角色合并

1、具体建造者角色和产品角色合并，从而使得产品自己就是自己的建造者。（在Product 内部含有对每个 子部分对象的创建方法）

 

2、这样做混淆了对象的建造者和对象本身，但是有时候一个产品对象有着固定的几个零件，而且永远只有这几个零件，此时将产品类和建造类合并，可以使系统简单易读。

下面是“创建者角色和产品角色合并”的最好诠释

 7、.Net中简化的Builder模式（StringBuilder）

 System.Text.StringBuilder sb = new StringBuilder();

 sb.Append("aa");//添加的子对象部分(这就是创建 子对象的部分)

 sb.Append("bb");(这个就对应 GetResult())

 string str=  sb.ToString();//最终 都演变成 最后一种形式

8、效果

1、建造者模式的使用使得产品的内部表象可以独立的变化。使用建造者模式可以使客户端不必知道产品内部组成的细节。 

2、每一个Builder都相对独立，而与其它的Builder无关。 （一个产品有一个Builder相对应）

3、可使对构造过程更加精细控制。（可以对产品对象的创建过程进行控制）

4、将构建代码和表示代码分开。 

5、建造者模式的缺点在于难于应付“分步骤构建算法”的需求变动。（如果子对象创建的顺序总是改变的话，这个模式就不适用了）

9、适用性

1、需要生成的产品对象有复杂的内部结构。 

2、需要生成的产品对象的属性相互依赖(可以通过Builder进行控制)，建造者模式可以强迫生成顺序。 （生成顺序可以通过Builder进行控制）

3、 在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。

10、总结

1、Builder 模式主要用于“分步骤构建一个复杂的对象”。在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。

2、变化点在哪里，封装哪里—— Builder模式主要在于应对“复杂对象各个部分”的频繁需求变动。其缺点在于难以应对“分步骤构建算法”的需求变动。（如果创建算法总是变化就不适用了）

3、Abstract Factory模式解决“系列对象”的需求变化，Builder模式解决“对象部分”的需求变化。

4、Builder模式通常和Composite模式组合使用。（后面会对这个设计模式做介绍的）