瘋狂的類構造器
最近棧長在做 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 帶來了很多便利，不用多說，是真的香，東西是好東西，就是要團隊規範一起使用，避免踩坑。更多工具系列使用文章請關注公眾號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;
}
}
參考：
使用方式：
/**
* @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 基礎教程看這裡：
我們來看它是怎麼做的：
它是新增了一個 XxxBuilder 類：SpringApplicationBuilder，然後在 SpringApplicationBuilder 中新增了個 SpringApplication 的成員變數，然後再新增變數對應的方法。
所以，Spring Boot 只是用 SpringApplicationBuilder 包裝了一下 SpringApplication 而已，寫法有所不同，但中心思想都是一樣的。這裡就不再演示了，大家也可以了借鑑一下。
總結
本文說了同事寫的瘋狂的類構造器，然後再介紹了用 set 方法改良，以及使用 4 種 Builder 模式改良的方式，下面來總結一下吧：
- 常規的 Builder 模式
- Lombok 實現 Builder 模式（推薦）
- Java 8 實現 Builder 模式
- Spring Boot 中的 Builder 模式
如果團隊有使用 Lombok，那麼 Lombok 無疑是最佳推薦的方式，程式碼量少，使用簡單，方便維護。其他三種實現方式都各有利弊，大家都可以參考使用。
總之，別再寫瘋狂的類構造器了……
如果你在公司看到同事寫這樣的優秀程式碼，請把這篇文章發給他。
好了，今天的分享就到這裡了，後面棧長我會更新更多 Java 技術實戰及設計模式系列文章，公眾號Java技術棧第一時間推送。
本節教程所有實戰原始碼已上傳到這個倉庫：
最後，覺得我的文章對你用收穫的話，動動小手，給個在看、轉發，原創不易，棧長需要你的鼓勵。
版權申明：本文系公眾號 "Java技術棧" 原創，原創實屬不易，轉載、引用本文內容請註明出處，禁止抄襲、洗稿，請自重，尊重他人勞動成果和智慧財產權。