《Android源码设计模式解析与实战》读书笔记（三）——建造者模式

在使用别人的框架的时候，总觉得那些链式调用的写法看起来很厉害很优雅，一直以为挺难的呢，在书上看到之后才发现也是一种基本设计模式。

第三章 自由扩展你的项目——Builder模式

Builder模式是一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细地控制对象的构造流程。

1.定义

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

2.使用场景

1）.相同的方法，不同的执行顺序，产生不同的事件结果时。
2）.多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
3）.产品类非常复杂或者产品类中的调用顺序不同产生了不同的作用时。
4）.初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。

3.简单实现

以构建一个Computer实例为例。

public abstract class Computer {
    protected int cpu;
    protected int ram;
    protected String os;

    protected Computer() {
    }

    // 设置CPU核心数
    public abstract void setCpu(int cpu);

    // 设置内存
    public abstract void setRam(int ram);

    // 设置操作系统
    public abstract void setOs(String os);

    @Override
    public String toString() {
        return "Computer{" +
                "cpu=" + cpu +
                ", ram=" + ram +
                ", os='" + os + '\'' +
                '}';
    }
}

public abstract class Builder {
    // 设置CPU核心数
    public abstract Builder buildCpu(int cpu);

    // 设置内存
    public abstract Builder buildRam(int ram);

    // 设置操作系统
    public abstract Builder buildOs(String os);

    // 创建Computer
    public abstract Computer create();
}

public class Macbook extends Computer {
    @Override
    public void setCpu(int cpu) {
        this.cpu = cpu;
    }

    @Override
    public void setRam(int ram) {
        this.ram = ram;
    }

    @Override
    public void setOs(String os) {
        this.os = os;
    }
}

public class MacBookBuilder extends Builder {
    private Computer computer = new Macbook();

    @Override
    public Builder buildCpu(int cpu) {
        computer.setCpu(cpu);
        return this;
    }

    @Override
    public Builder buildRam(int ram) {
        computer.setRam(ram);
        return this;
    }

    @Override
    public Builder buildOs(String os) {
        computer.setOs(os);
        return this;
    }

    @Override
    public Computer create() {
        return computer;
    }
}

public class Director {
    Builder mBuilder = null;

    public Director(Builder builder) {
        mBuilder = builder;
    }

    public void construct(int cpu, int ram, String os) {
        mBuilder.buildCpu(cpu);
        mBuilder.buildRam(ram);
        mBuilder.buildOs(os);
    }
}

        //经典实现,较为繁琐
        // 构建器
        Builder builder = new MacBookBuilder();
        // Director
        Director director = new Director(builder);
        // 封装构建过程, 4核, 内存2GB, Mac系统
        director.construct(4, 2, "Mac OS X 10.9.1");
        // 构建电脑, 输出相关信息
        Computer computer = builder.create();
        System.out.println("computer : " + computer.toString());

相比于经典实现，下面的链式实现才是我需要的。

        //链式调用,实际开发中通常省略Director
        Computer computer = new MacBookBuilder().buildCpu(4).buildRam(2).buildOs("Mac OS X 10.9.1").create();
        System.out.println("computer : " + computer.toString());

这样既体现了Builder模式的优点，还省略了Director，实在妙哉。

4.总结

Builder模式在Android开发中也较为常用，若要实现同样的效果，一是在目标类中重载多个构造方法，但是这样一来，如果目标类属性过多，重载方法相应也会增多，而且参数的顺序不能弄错。二是调用每一个需要配置的属性的set方法，但是这样在构造实例的时候会调用过多set方法，代码显得冗余。Builder模式通常作为配置类的构建器将配置的构建和表示分离开来，同时也是将配置从目标类中隔离出来，配置属性的顺序可以是任意顺序，还能避免过多的set方法。Builder模式常用的实现形式是链式调用，这样可以使代码更简洁。
优点：
1）.良好的封装性，使用建造者模式可以使客户端不必知道产品内部组成的细节。
2）.建造者独立，容易扩展。
缺点：
1）.会产生多余的Builder对象以及Director对象，消耗内存。

Demo下载