概要

• 类型：创建型

• 目的：创建对象时，提升属性设置的灵活性。

  灵活性

  类中定义了大量属性时，通常为了创建对象时属性初始设置的便利随之定义大量的构造方法。
  为了既不定义过多的构造方法，又保证属性设置的便利性。

接下来我们看一个需要改进的案例。

对象创建的优化

现在有个Employee类，如下。

最初版

public class Employee {
    private String name;
    private String sex;
    private int age;
    private String address; // 住址
    private String post; // 邮编
    private String company; // 公司
    private String department; // 部门

    public Employee(String name, String sex, int age,
                    String address, String post, String company,
                    String department) {
        this.name = name;
        this.sex = sex;
        if (!("男".equals(sex) || "女".equals(sex))) {
            throw new RuntimeException("输入错误的性别：" + sex);
        }
        this.age = age;
        if (age <= 1 || age >= 150) {
            throw new RuntimeException("输入错误的年龄：" + age);
        }
        this.address = address;
        this.post = post;
        if (!postCheck()) { // post对于address存在依赖
            throw new RuntimeException("地址(" + address + ")与邮编(" + post + ")不一致");
        }
        this.company = company;
        this.department = department;
    }

    private boolean postCheck() {
        if (address == null/* || ... */) { // 非空check，以及其它的check(省略)，address的post与设置的post是否一致等
            return false;
        }
        return true;
    }
}

实际上在业务上并没有过多的问题，最重要的问题就是这个类的使用非常的麻烦。
首先，构造函数只有一个，如果不增加新的构造函数的话无法灵活的传入不同数量的参数。并且为了让其参数的设置变得灵活，我们必须重载非常多种不一样的构造函数，工程量巨大，且枯燥乏味。

为此，我们有了一个新的改进方案。

修改版v1

public class Employee {
    private String name;
    private String sex;
    private int age;
    private String address; // 住址
    private String post; // 邮编
    private String company; // 公司
    private String department; // 部门
    public Employee() {}

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

    public void setSex(String sex) {
        this.sex = sex;
        if (!("男".equals(sex) || "女".equals(sex))) {
            throw new RuntimeException("输入错误的性别：" + sex);
        }
    }

    public void setAge(int age) {
        this.age = age;
        if (age <= 1 || age >= 150) {
            throw new RuntimeException("输入错误的年龄：" + age);
        }
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void setPost(String post) {
        this.post = post;
        if (!postCheck()) {
            throw new RuntimeException("地址(" + address + ")与邮编(" + post + ")不一致");
        }
    }

    public void setCompany(String company) {
        this.company = company;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    private boolean postCheck() {
        if (address == null/* || ... */) { // 非空check，以及其它的check(省略)，address的post与设置的post是否一致等
            return false;
        }
        return true;
    }
}

改成了上述方式后确实使用起来方便不少，不想传入的参数不调用对应的set方法就好了，并且也省去了大量构造方法的定义。但是，依旧有一个问题，我们来看看使用样例。

public Client {
    public static void main(String[] args) {
        Employee e = new Employee();
        e.setPost("121-1245-1231"); // 地址(null)与邮编(121-1245-1231)不一致，报错
    }
}

由于设置post的时候对于address属性做了非空判断，所以代码书写时address的设置一定要在post之前，否则就会报错。这无疑增加了项目开发的难度。

既然构造函数麻烦，set也存在一些问题。那我们如何优化Employee对象的创建呢？看下面的样例。

修改版v2

public class Employee {
    private String name;
    private String sex;
    private int age;
    private String address; // 住址
    private String post; // 邮编
    private String company; // 公司
    private String department; // 部门

    private Employee(Builder builder) {
        this.name = builder.name;
        this.sex = builder.sex;
        this.age = builder.age;
        this.address = builder.address;
        this.post = builder.post;
        this.company = builder.company;
        this.department = builder.department;
    }

    public static Builder Builder() {
        return new Builder();
    }

    public static class Builder {
        private String name;
        private String sex;
        private int age;
        private String address; // 住址
        private String post; // 邮编
        private String company; // 公司
        private String department; // 部门

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

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

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

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public Builder post(String post) {
            this.post = post;
            return this;
        }

        public Builder company(String company) {
            this.company = company;
            return this;
        }

        public Builder department(String department) {
            this.department = department;
            return this;
        }

        public Employee build() {
            if (!("男".equals(sex) || "女".equals(sex))) {
                throw new RuntimeException("输入错误的性别：" + sex);
            }
            if (age <= 1 || age >= 150) {
                throw new RuntimeException("输入错误的年龄：" + age);
            }
            if (!postCheck()) {
                throw new RuntimeException("地址(" + address + ")与邮编(" + post + ")不一致");
            }
            return new Employee(this);
        }

        private boolean postCheck() {
            if (address == null/* || ... */) { // 非空check，以及其它的check(省略)，address的post与设置的post是否一致等
                return false;
            }
            return true;
        }
    }
}

使用建造者模式优化对象的创建。客户端中对象的创建不再使用new关键字，不需要定义数量繁多的构造函数以应对复杂多变的属性设置，并且也有着set的灵活性又不存在属性设置顺序的依赖。以下是使用样例。

public Client {
    public static void main(String[] args) {
        Employee e = Employee.Builder().name("张三").sex("男").age(35)
            .post("124-1241-1352").address("江西省南昌市").build(); // 执行成功
    }
}

流式编程的风格使得代码清晰舒爽。

总结

优点

1. 无需定义大量的构造方法。
2. 既有set方法的灵活性，又消除了set可能出现的属性固定顺序设置的问题。
3. 流式编程的风格，代码清晰简洁。

缺点

1. 由于定义了静态内部类Builder，可能会使得系统的类数量激增，影响性能。
2. 代码的理解难度增加。

适用场景

1. 适用于属性很多的类的创建。
2. 适用于对属性设置判断条件复杂的类的创建。尤其是属性设置对于其他属性有依赖的情况。