建造者模式

建造者模式

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

介绍

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

应用实例： 1、去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。 2、JAVA 中的 StringBuilder。

优点： 1、建造者独立，易扩展。 2、便于控制细节风险。

缺点： 1、产品必须有共同点，范围有限制。 2、如内部变化复杂，会有很多的建造类。

使用场景： 1、需要生成的对象具有复杂的内部结构。 2、需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

建造者模式通常包括以下这几个角色：
    1、Builder：给出一个抽象接口，规范建造者对于生产的产品的各个组成部分的建造。这个接口只是定一个规范，不涉及具体的建造，具体的建造让继承于它的子类（ConcreteBuilder）去实现。
    2、ConcreteBuilder：实现builder接口，针对不同的商业逻辑，具体化各对象部分的建造，最后返回一个建造好的产品。
    3、Director：导演，顾名思义，负责规范流程之用。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。
    4、Product：复杂对象。
    按照惯例，给出建造者模式的UML图（这个先记下来，非常有用，学一个设计模式，先把这个图记下来！）
    

 2、一个建造者的实例。
    在此，以这篇文章作为参考http://blog.csdn.net/lovelion/article/details/7426015，我们来做一个游戏的案例。
    游戏开发中，游戏角色是一个复杂的产品，它包括性别、脸型、身材等多个组成部分，不同的角色组成部分有所差异。如这张图：
    
    无论是何种类型的游戏的游戏角色，它的创建步骤都大同小异，都需要逐步创建其组成部分，再将各组成部分装配成一个完整的游戏角色。

    一个典型的复杂类对象代码示例如下：
    class Productor {
            private Part partA;
            private Part partB;
            private Part partC;

            // 这些是各个部件的set和get的方法，在此省略。。。
    }
    这是抽象的Builder：
    abstract class Builder {
            public abstract void buildPartA();
            public abstract void buildPartB();
            public abstract void buildPartC();
    }
    继承Builder的具体的建造者：
    class ConcreteBuilder extends Builder {
            private Product product;
            // 创建partA
            public void buildPartA() {
                    // 在此创建出部件
                    Part partA = new PartA();
                    // ......

                    // 把partA传递给product
                    product.setPartA(partA);
            }
            // 创建partB
            public void buildPartB() {
                    // 在此创建出部件
                    Part partB = new PartB();
                    // ......

                    // 把partB传递给product
                    product.setPartA(partB);
            }
            // 创建partC
            public void buildPartC() {
                    // 在此创建出部件
                    Part partC = new PartC();
                    // ......

                    // 把partC传递给product
                    product.setPartA(partC);
            }  
            // 返回复杂产品对象
            public void getProduct() {
                return this.product;
            }     
    }
    这是导演，负责流程规范，在导演类中可以注入建造者对象。
    class Director {
            private Builder concretebuilder;
            // 构造方法中也可以传递builder
            public Director(Builder builder) {
                    this.concretebuilder = builder;
            }
            // 传递builder
            public void setBuilder(Builder builder) {
                    this.concretebuilder = builder;
            }
            // 这个方法用来规范流程，产品构建和组装方法
            public void construct() {
                    builder.buildPartA();
                    builder.buildPartB();
                    builder.buildPartC();
            }
    }
    // 客户端使用：
    class Main {
            public static void main(String[] args) {
                    // 对于客户端而言，只需要关心具体的建造者，无需关心产品内部构建流程。我如果需要其他的复杂产品对象，只需要选择其他的建造者，如果需要扩展，则只需要写一个新的builder就行。如果可以，这个建造者甚至可以用配置文件做，增加更多的扩展性。
                    Builder builder = new ConcreteBuilder();
                    // 把建造者注入导演
                    Director director = new Director(builder);
                    // 指挥者负责流程把控
                    director.construct();
                    // 建造者返回一个组合好的复杂产品对象
                    Productor productor = builder.getProductor();
            }
    }
    不知道大家在此有否发现，上面的例子，通过使用建造者模式，建造过程通过Director的construct的方法固定下来了。建造过程不会变，但具体的部位，头，身体，脚的表现方式，让具体的builder去实现了。这样不仅使得小人的建造过程不变，而且有利于功能的扩展。