23种设计模式-建造者模式

一.建造者模式介绍
创建者模式又叫建造者模式，是将一个复杂的对象的构建与它的表示分离，使
得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

二.建造者模式运用
某一天午休时间，经理突然跑过来笑嘻嘻的说

经理：小石头，有个任务要交给你，比较紧急的那种，你接不接？
我：  你先和我说给我多长时间吧。
经理：时间不是问题,我先和你说做的是啥,我们不是要生成报告吗?报告生成那边呢。。。讲了30分钟。
我：  (心想:好像我没事一样，好像我很闲一样，好像我工作不饱和一样，但是呢，啥也不敢问，啥也不敢说。。。)好的，没问题，我明天看下代码评估下时间。
经理：等下我和你说下这边东西还是比较重要的，我和你说下哪里需要注意。。。。又讲了30分钟。
然后我开始了看代码的节奏。。。。过了半小时(程序员日常心里活动：这哪个写的代码，真的是shi,shi到家了。。。心里活动30分钟)
看了下，有N种报告，报告都有计分的逻辑，都有报告内部显示内容段顺序的逻辑，都有报告模板。。。有点多等等等。
这个要想下。。。
第二天，老大老大，方案想好了，把这部分东西我用建造者模式+策略模式+模板模式等结合起来，生成前只要调用建造者就行。。。嘟嘟嘟
老大：你去干活吧和我说那么多我也不知道你做成什么样子，我只是个管理。。。快去干活，我还有事呢。
我八字大码走了回来，一个飘逸加甩头坐在了椅子上。。。运起了我的抓键龙抓手。。（此章只讲解建造者其它后面讲）
下面是代码：
模板抽象类

public abstract class Template {

    private List<String> sequence = new ArrayList<String>();

    /**
     * 头部
     */
    public abstract void head();

    /**
     * 说明部分
     */
    public abstract void explain();

    /**
     * 报表部分
     */
    public abstract void report();

    /**
     * 尾部
     */
    public abstract void rump();

    final public void build() {
        for(int i=0;i<this.sequence.size();i++)
        {
            String actionName = this.sequence.get(i);
            if (actionName.equalsIgnoreCase("head")) {
                this.head();
            } else if (actionName.equalsIgnoreCase("explain")) {
                this.explain();
            } else if (actionName.equalsIgnoreCase("report")) {
                this.report();
            } else if (actionName.equalsIgnoreCase("rump")) {
                this.rump();
            }
        }
    }

    public void setSequence(List<String> sequence) {
        this.sequence = sequence;
    }
}

建造者基类

public abstract class Builder {
    public abstract void setSequence(List<String> sequence);

    public abstract Template getTemplate();
}

  A模板类

public class ATemplate extends Template {

    public void head()
    {
        System.out.println("我是A模板头部");
    }

    public void explain()
    {
        System.out.println("我是A模板说明部分");
    }

    public void report()
    {
        System.out.println("我是A模板报告");
    }

    public void rump()
    {
        System.out.println("我是A模板尾部");
    }
}

 A建造者类

public class ATemplateBuilder extends Builder {

    ATemplate mdoModel = new ATemplate();

    @Override
    public void setSequence(List<String> sequence)
    {
        mdoModel.setSequence(sequence);
    }

    @Override
    public Template getTemplate()
    {
        return mdoModel;
    }

}

B模板类

public class BTemplate extends Template {

    public void head()
    {
        System.out.println("我是B模板头部");
    }

    public void explain()
    {
        System.out.println("我是B模板说明部分");
    }

    public void report()
    {
        System.out.println("我是B模板报告");
    }

    public void rump()
    {
        System.out.println("我是B模板尾部");
    }

}

 B建造者类

public class BTemplateBuilder extends Builder {
    BTemplate bTemplate = new BTemplate();

    @Override
    public void setSequence(List<String> sequence)
    {
        bTemplate.setSequence(sequence);
    }

    @Override
    public Template getTemplate()
    {
        return bTemplate;
    }
}

调用测试代码

        List<String> sequence = new ArrayList<String>();
        sequence.add("head");
        sequence.add("explain");
        sequence.add("report");
        sequence.add("rump");

        BTemplateBuilder bBuilder = new BTemplateBuilder();
        bBuilder.setSequence(sequence);
        bBuilder.getTemplate().build();

        ATemplateBuilder aBuilder = new ATemplateBuilder();
        aBuilder.setSequence(sequence);
        aBuilder.getTemplate().build();

运行结果如下：

我是B模板头部
我是B模板说明部分
我是B模板报告
我是B模板尾部
我是A模板头部
我是A模板说明部分
我是A模板报告
我是A模板尾部

如果想改变顺序和显示只要改变sequence的顺序，现在有个问题客户有很多，但是有些客户会定制模板，不要说明，只要报告等。

下面我们加上导演类

public class Director {

    private ArrayList<String> sequence = new ArrayList();
    ATemplateBuilder aBuilder = new ATemplateBuilder();
    BTemplateBuilder bBuilder = new BTemplateBuilder();

    public void getAATemplate()
    {
        this.sequence.clear();
        sequence.add("head");
        sequence.add("rump");
        aBuilder.setSequence(this.sequence);
        aBuilder.getTemplate().build();
    }
    public void getABTemplate()
    {
        this.sequence.clear();
        sequence.add("head");
        sequence.add("explain");
        sequence.add("report");
        aBuilder.setSequence(this.sequence);
        aBuilder.getTemplate().build();
    }
    public void getBATemplate()
    {
        this.sequence.clear();
        sequence.add("head");
        sequence.add("report");
        bBuilder.setSequence(this.sequence);
        bBuilder.getTemplate().build();
    }
}

调用测试代码

     Director director = new Director();
        director.getAATemplate();
        director.getABTemplate();
        director.getBATemplate();

运行结果如下：

我是A模板头部
我是A模板尾部
我是A模板头部
我是A模板说明部分
我是A模板报告
我是B模板头部
我是B模板报告

这样就可以适应不同报告部分的组合了。

 

三.总结

建造者模式也是创建型模式其中一种,他将复杂对象的构建放到构建对象中，让调用者看不到构建的过程。

优点

建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

使用建造者模式可以使客户端不必知道产品内部组成的细节

缺点

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

如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

建造者与工厂模式的区别

从代码中我们可以看到，建造者模式比工厂模式多了个导演者，如果把导演者去掉，其实差不多。但是相对来说，工厂模式适合内部结构比较简单的构建，建造者模式

时候内部结构比较复杂的。工厂模式，将内部放在了工厂中，由工厂和调用方碰头。而建造者因其结构比较复杂，所以衍生出了导演类，建造类将结构建造好，导演类

将建造类中的各个部分安装特定规则或顺序组合，再由导演类和调用方打交道。