同事寫了一個瘋狂的類構造器，我要瘋了，Builder 模式都不會么？！！-有解無憂

瘋狂的類構造器

最近堆疊長在做 Code Review 時，發現一段創建物件的方法：

Task task = new Task(112, "緊急任務", "處理一下這個任務", 90, 3, 1, 36, "劉主管", 18, "客服1", "11, 12, 13", "客服3, 客服4, 客服5", true, new Date(), new Date(), new Date(), new Date(), new Date(), 0, "需要盡快完成", ...);

真實代碼敏感性，上面的代碼僅為模仿，實際要比這個更長、更復雜……

當我看到那段代碼時，我簡直要瘋了！！

拖了半天才看完，到處充滿著魔法值不說，把一個類所有引數都放在一個構造器里面，這個構造器也太瘋狂了……這種寫法也實在太 low 了！

在實際開發程序中，堆疊長經常看到同事們這樣的寫法，比上面的更長的構造器你見過沒？我反正見過！

一方面，也許他們真不知道怎么寫才更好，畢竟經驗有限，這個可以原諒，但另一方面，也許他們就是為了偷懶，或者為了趕時間，反正這都是對自己和同事不負責的表現，

如果你在公司看到同事寫這樣的優秀代碼，請把這篇文章發給他，

看看大量引數構造器的缺點：

引數過多時，代碼太長，極不優雅，維護極難；
不能判斷出哪些是必須引數，哪些是可選引數，可選引數也得給個默認值；
分不清變數值對應哪個變數，如順序對應錯，很容易造成錯誤；
構造器引數增減時，會影響所有創建該物件的地方，影響擴展性；

構造器正確的用法是只給出幾個必選、重要引數的構造器，而不是把所有引數放在一個構造器中，

比如我們看下 JDK 執行緒池的構造器用法：

執行緒池就把幾個重要的引數封裝成了幾個構造器，這樣用戶就可以根據實際需要呼叫具體的某個構造器，

基本 SET 方法改良

再回到同事寫的那個代碼，寫出那樣長的構造器，我真的服了，

最基本也得寫成這樣吧：

Task task = new Task();
task.setId(112);
task.setName("緊急任務");
task.setContent("處理一下這個任務");
task.setParentId(90);
task.setType(3);
task.setLevel(1);
task.setAssignFromId(36);
task.setAssignFromName("劉主管");
task.setAssignTo(18);
task.setAssignTo("客服1");
task.setCandidateId("11, 12, 13");
task.setCandidateName("客服3, 客服4, 客服5");
task.isSendEmail(true);
task.setCreateTime(new Date());
task.setBeginTime(new Date());
task.setEndTime(new Date());
task.setFinishTime(new Date());
task.setUpdateTime(new Date());
task.setStatus(0);
task.setMemo("需要盡快完成");
// ...

這個創建物件的方式是最普通不過了，也是用的最多的了，

這種寫法雖然看起來很直觀，但是有以下幾個缺點：

引數多的情況下 setter 非常多，代碼非常長，不是很優雅；
不能判斷出哪些是必須引數，哪些是可選引數；
容易漏掉一些引數，并且很難檢查出來；
容易搞錯物件名，造成潛在錯誤，很難排查（如：同時有 user 和 user2，在 user 賦值程序中錯誤的復制了 user2 物件）；

Builder 模式改良

下面堆疊長教大家用 Builder 模式改良下，下面是改良后的代碼：

package cn.javastack.test.designpattern.builder;

import java.util.Date;

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
public class Task {

    private long id;
    private String name;
    private String content;
    private int type;
    private int status;
    private Date finishDate;

    private Task(TaskBuilder taskBuilder) {
        this.id = taskBuilder.id;
        this.name = taskBuilder.name;
        this.content = taskBuilder.content;
        this.type = taskBuilder.type;
        this.status = taskBuilder.status;
        this.finishDate = taskBuilder.finishDate;
    }

    /**
     * @author: 堆疊長
     * @from: 公眾號Java技術堆疊
     */
    public static class TaskBuilder {

        private long id;
        private String name;
        private String content;
        private int type;
        private int status;
        private Date finishDate;

        public TaskBuilder(long id, String name) {
            this.id = id;
            this.name = name;
        }

        public TaskBuilder content(String content) {
            this.content = content;
            return this;
        }

        public TaskBuilder type(int type) {
            this.type = type;
            return this;
        }

        public TaskBuilder status(int status) {
            this.status = status;
            return this;
        }

        public TaskBuilder finishDate(Date finishDate) {
            this.finishDate = finishDate;
            return this;
        }

        public Task build(){
            return new Task(this);
        }

    }

    public long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getContent() {
        return content;
    }

    public int getType() {
        return type;
    }

    public int getStatus() {
        return status;
    }

    public Date getFinishDate() {
        return finishDate;
    }

    @Override
    public String toString() {
        return "Task{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", content='" + content + '\'' +
                ", type=" + type +
                ", status=" + status +
                ", finishDate=" + finishDate +
                '}';
    }

}

說下簡單思路：

1）在 Bean 類里面新建一個靜態內部類：XxxBuilder；

2）把 Bean 類所有引數復制到 XxxBuilder，然后在 XxxBuilder 新建必須引數的構造器，其他引數使用變數名作為方法然后回傳自身（this）以便形成鏈式呼叫；

3）在 Bean 類里面新建一個接收 XxxBuilder 引數的私有構造器，避免使用 new 創建物件；

4）在 XxxBuilder 類新建一個 build 方法開始構建 Bean 類，也是作為鏈式呼叫的結束；

使用方法：

使用方式如下，先創建構造器，然后在每個方法后使用 . 帶出所有方法，一目了然，最后呼叫 build 方法以結束鏈式呼叫創建 bean，

參考代碼如下：

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
private static void testBuilder() {
    Task task = new Task.TaskBuilder(99, "緊急任務")
            .type(1)
            .content("處理一下這個任務")
            .status(0)
            .finishDate(new Date())
            .build();
    System.out.println(task);
}

結果輸出：

Task{id=99, name='緊急任務', content='處理一下這個任務', type=1, status=0, finishDate=...

Builder 模式的優點：

鏈式呼叫，優雅、清晰、一目了然；
一行代碼完成物件創建，避免了多行代碼賦值程序出錯；
省去了大量冗余變數，避免變數復制出錯；

Builder 模式的缺點：

需要冗余的 Builder 類，以及大量相等重復的成員變數，大大增加了代碼量，維護難度相對較大；
只適合一次賦值創建物件，多次賦值的場景還需要新增 set 方法配合，不是很靈活；

Lombok 實作 Builder 模式

常規的 Builder 模式需要新增大量的代碼，維護難度比較大，這里堆疊長再介紹一下 Lombok 中的 Builder 模式，一個 @Builder 注解搞定所有，輕松維護，

用 Lombok 改良后的代碼如下：

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
@Builder
public class LombokTask {

    private long id;
    private String name;
    private String content;
    private int type;
    private int status;
    private Date finishDate;

}

我還能說什么？兩個字：真香！

再來看下怎么使用：

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
private static void testLombokBuilder() {
    LombokTask lombokTask = new LombokTask.LombokTaskBuilder()
            .id(99)
            .name("緊急任務")
            .type(1)
            .content("處理一下這個任務")
            .status(0)
            .finishDate(new Date())
            .build();
    System.out.println(lombokTask);
}

或者 new 都不要了，直接呼叫靜態方法：

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
private static void testLombokBuilder2() {
    LombokTask lombokTask = LombokTask.builder()
            .id(99)
            .name("緊急任務")
            .type(1)
            .content("處理一下這個任務")
            .status(0)
            .finishDate(new Date())
            .build();
    System.out.println(lombokTask);
}

接下來我們來看下這個 @Builder 注解到底做了什么：

public class LombokTask {
    private long id;
    private String name;
    private String content;
    private int type;
    private int status;
    private Date finishDate;

    LombokTask(final long id, final String name, final String content, final int type, final int status, final Date finishDate) {
        this.id = id;
        this.name = name;
        this.content = content;
        this.type = type;
        this.status = status;
        this.finishDate = finishDate;
    }

    public static LombokTask.LombokTaskBuilder builder() {
        return new LombokTask.LombokTaskBuilder();
    }

    public static class LombokTaskBuilder {
        private long id;
        private String name;
        private String content;
        private int type;
        private int status;
        private Date finishDate;

        LombokTaskBuilder() {
        }

        public LombokTask.LombokTaskBuilder id(final long id) {
            this.id = id;
            return this;
        }

        public LombokTask.LombokTaskBuilder name(final String name) {
            this.name = name;
            return this;
        }

        public LombokTask.LombokTaskBuilder content(final String content) {
            this.content = content;
            return this;
        }

        public LombokTask.LombokTaskBuilder type(final int type) {
            this.type = type;
            return this;
        }

        public LombokTask.LombokTaskBuilder status(final int status) {
            this.status = status;
            return this;
        }

        public LombokTask.LombokTaskBuilder finishDate(final Date finishDate) {
            this.finishDate = finishDate;
            return this;
        }

        public LombokTask build() {
            return new LombokTask(this.id, this.name, this.content, this.type, this.status, this.finishDate);
        }

        public String toString() {
            return "LombokTask.LombokTaskBuilder(id=" + this.id + ", name=" + this.name + ", content=" + this.content + ", type=" + this.type + ", status=" + this.status + ", finishDate=" + this.finishDate + ")";
        }
    }
}

這是反編譯后的代碼，可以看出來邏輯都是一樣的，

Lombok 還可以添加各種類構造器、toString 等系列注解，幾個注解完全可以達到想要的效果，但代碼量和可維護性是天壤之別，

很多人不建議使用 Lombok，仁者見仁，智者見智，這里不再討論，相關話題可以閱讀我之前寫的文章：

推薦一款代碼神器，代碼量至少省一半！
公司來了個新同事不會用 Lombok，還說我代碼有問題！

使用 Lombok 帶來了很多便利，不用多說，是真的香，東西是好東西，就是要團隊規范一起使用，避免踩坑，更多工具系列使用文章請關注公眾號Java技術堆疊，在選單中閱讀，

Java 8 實作 Builder 模式

Java 8 帶來了函式式介面編程，所以在 Java 8 中可以一個實作通用的 Builder：

public class GenericBuilder<T> {

    private final Supplier<T> instantiator;

    private List<Consumer<T>> instanceModifiers = new ArrayList<>();

    public GenericBuilder(Supplier<T> instantiator) {
        this.instantiator = instantiator;
    }

    public static <T> GenericBuilder<T> of(Supplier<T> instantiator) {
        return new GenericBuilder<T>(instantiator);
    }

    public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) {
        Consumer<T> c = instance -> consumer.accept(instance, value);
        instanceModifiers.add(c);
        return this;
    }

    public T build() {
        T value = instantiator.get();
        instanceModifiers.forEach(modifier -> modifier.accept(value));
        instanceModifiers.clear();
        return value;
    }
}

參考：

http://www.ciphermagic.cn/java8-builder.html

使用方式：

/**
 * @author: 堆疊長
 * @from: 公眾號Java技術堆疊
 */
private static void testJava8Builder() {
    Java8Task java8Task = GenericBuilder.of(Java8Task::new)
            .with(Java8Task::setId, 99L)
            .with(Java8Task::setName, "緊急任務")
            .with(Java8Task::setType, 1)
            .with(Java8Task::setContent, "處理一下這個任務")
            .with(Java8Task::setStatus, 0)
            .with(Java8Task::setFinishDate, new Date())
            .build();
    System.out.println(java8Task);
}

這樣一來，任何帶有默認構造器和 set 方法的類都可以使用這個通用的 Builder 模式了，

雖然利用 Java 8 是實作了通用有 Builder 模式，但還是有很多冗余的代碼，而且本質還是呼叫的 set 方法，所以和 set 比起來只是多了一個鏈式呼叫而已，

Spring Boot 中的 Builder 模式

Spring Boot 是現在主流的應用框架，其中也用到了 Builder 模式，可見 Builder 模式的常見性，

下面再來看下 Spring Boot 是怎么應用 Builder 模式的：

new SpringApplicationBuilder()
        .sources(Parent.class)
        .child(Application.class)
        .bannerMode(Banner.Mode.OFF)
        .run(args);

如上代碼所示，這是 Spring Boot 的鏈式啟動方式，

Spring Boot 基礎教程看這里：