设计模式整理(3) Builder 模式

学习《Android 源码设计模式解析与实践》系列笔记

介绍

Builder 模式是一步一步创建一个复杂对象的创建型模式。用户不需要知道构建过程中的实现细节，便可构建出复杂的对象模型。该模式将构建复杂对象的过程和它的部件解耦，使得构建过程和部件表示隔离开来。

定义

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

使用场景

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

结构

• Product 产品类：产品的抽象类
• Builder ：抽象 Builder 类，规范产品的组建
• ConcreteBuilder ： 具体的 Builder 类
• Director ： 统一组装过程

使用

这里通过构建一个学生举例。

/**
 * 人抽象类，即 Product 角色
 */
public abstract class Person {
    protected String name;
    protected int sex;
    protected int age;
    protected String job;

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void setJob();
}

/**
 * 具体的 Person 类，Student
 */
public class Student extends Person {

    public void setJob() {
        job = "student";
    }

}

/**
 * 抽象的 Builder 类
 */
public abstract class Builder {
    public abstract void buildName(String name);
    public abstract void buildAge(int age);
    public abstract void buildSex(int sex);
    public abstract void buildJob();
    public abstract Person create();
}

/**
 * 具体的 Builder 类
 */
public class StudentBuilder extends Builder {

    private Person mPerson = new Student();

    @Override
    public void buildName(String name) {
        mPerson.setName(name);
    }

    @Override
    public void buildAge(int age) {
        mPerson.setAge(age);
    }

    @Override
    public void buildSex(int sex) {
        mPerson.setSex(sex);
    }

    @Override
    public void buildJob() {
        mPerson.setJob();
    }

    @Override
    public Person create() {
        return mPerson;
    }
}

/**
 * Director 类，负责构造 Person
 */
public class Director {

    private Builder mBuilder;

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

    public void construct(String name, int age, int sex) {
        mBuilder.buildJob();
        mBuilder.buildName(name);
        mBuilder.buildAge(age);
        mBuilder.buildSex(sex);
    }

}

public class User {

    public static void main(String [] args) {
        Builder builder = new StudentBuilder();
        Director director = new Director(builder);
        director.construct("Lynn", 18, 1);
        // 拿到构建的 Student 对象
        Person studentLynn = builder.create();
    }

}

上面的例子中，通过具体的 StudentBuilder 来构建 Student 对象，Director 封装了构建产品对象的过程，对外隐藏了细节。Builder 和 Director 将对象的构建与它的表示分离，使得同样的构建过程可以构建不同的对象。

但是，前面说到的都是传统的 Builder 模式，实际开发中，经常会省略掉 Director 对象，直接使用一个内部类 Builder 来处理对象的组装，这个 Builder 通常为链式调用的，它的每个 setter 方法都会返回自己。没有 Director 的角色会使结构更加的简洁。

简化的 Builder

还是用的上面的例子，不过上面的代码只沿用了 Person 类。

/**
 * 人抽象类，即 Product 角色
 */
public abstract class Person {
    protected String name;
    protected int sex;
    protected int age;
    protected String job;

    public void setName(String name) {
        this.name = name;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void setJob();
}

public class Student2  extends Person {

    public Student2(Builder builder) {
        name = builder.name;
        sex = builder.sex;
        age = builder.age;
        setJob();
    }

    @Override
    public void setJob() {
        job = "student";
    }

    public static class Builder {

        private String name;
        private int sex;
        private int age;

        public Builder(String name) {
            this.name = name;
        }

        public Builder setSex(int sex) {
            this.sex = sex;
            return this;
        }

        public Builder setAge(int age) {
            this.age = age;
            return this;
        }

        public Student2 create() {
            return new Student2(this);
        }
    }
}

public class User {

    public static void main(String [] args) {
        Student2.Builder builder = new Student2.Builder("Lynn");
        builder.setAge(20).setSex(1);
        // 拿到构建的 Student 对象
        Person studentLynn = builder.create();
    }

}

可以看到，去掉了 Director 后，结构变得更加简单明了了。

更多的例子，可以参考 Android 源码中的 AlertDialog 类，这个应该是最常见的一个应用了。

AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this);
        alertDialogBuilder.setIcon(R.mipmap.ic_launcher)
                .setTitle("Title")
                .setMessage("Message");
        Dialog dialog = alertDialogBuilder.create();
        dialog.show();

总结

Builder 模式在开发中较为常用，可以使构建和表示分离。

优缺点

1. 优点
   （1）良好的封装性，使用构造者模式可以使客户端不必知道产品内部组成的细节。
   （2）构造者独立，容易扩展。
2. 缺点
   （1）会产生对于的 Builder 对象，消耗内存。
   （2）Builder 类可能会复制一遍 Product 的属性，代码量会增多。

注意：

1. 必需的参数，应该放在 Builder 的构造方法中；
2. create 之后拿到的对象，其属性应不再改变。

相关文章：

设计模式整理(1) 代理模式
设计模式整理(2) 单例模式
设计模式整理(3) Builder 模式
设计模式整理(4) 原型模式
设计模式整理(5) 工厂模式
设计模式整理(6) 策略模式
设计模式整理(7) 状态模式
设计模式整理(8) 责任链模式
设计模式整理(9) 观察者模式
设计模式整理(10) 适配器模式
设计模式整理(11) 装饰模式
设计模式整理(12) 中介者模式