前言
本文主要給大家介紹了關于如何實現Builder模式，大家在構建大對象時，對象的屬性比較多，我們可以采用一個構造器或者使用空的構造器構造，然后使用setter方法去設置。在使用者使用這些方法時，會很多冗長的構造器參數列表或者setter方法。我們可以使用Builder模式來簡化大對象的構造，提高代碼的簡潔性，同時提高使用者的編碼體驗。
下面我們將介紹在Java8之前、使用極簡代碼利器Lombok、Java8之后的Builder模式。
Pre Java8
我們先來看下在Java8之前的Builder模式
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
public class Order { private String code; private List<String> offers; private Map<String, Object> features; public static Order.Builder builder(){ return new Builder(); } //省略getter setter public static class Builder { private OrderState orderState = new OrderState(); private static final BeanCopier orderCopier = BeanCopier.create(OrderState.class, Order1.class, false); private class OrderState { private String code; private Map<String, Object> features; private List<String> offers; //省略getter setter } public Builder code(String code) { orderState.code = code; return this; } public Builder features(Map<String, Object> features) { orderState.features = features; return this; } public <T> Builder feature(String key, T obj) { if (orderState.features == null) { orderState.features = new HashMap<>(); } orderState.features.put(key, obj); return this; } public Builder offers(List<String> offers) { orderState.offers = offers; return this; } public Builder offer(String offer) { if (orderState.offers == null) { orderState.offers = new ArrayList<>(); } orderState.offers.add(offer); return this; } public Order build() { Order order = new Order(); orderCopier.copy(orderState, order1, null); orderState = null; return order; } }} |
以上代碼看上去很冗長，而且IDE沒有提供自動的生成工具，這也是我們目前在工程代碼里看到這種模式的比較少的原因之一。但是對于這個類的使用者來說，提高了很高的代碼體驗。在使用者，使用這個類時如下：
|
1
2
3
4
|
Order order = Order.builder().code("1235") .offer("滿100減5") .feature("category", "shoe") .build(); |
一個類的定義通常只會有一個地方，而使用這個類的地方會有很多，在定義類時為使用者多考慮一些，就能為使用這個類的開發者提高很多效率，同時讓整個團隊的代碼變的更加簡潔。
我一直認為一個類的設計和一個產品的設計者理念相同，產品經理設計一個功能首先能解決用戶的痛點，同時還要提高用戶體驗，讓用戶用著爽。同樣設計一個基礎類，需要解決一個業務問題，同時需要從使用者的角度考慮，讓使用者用著爽。一個優秀的基礎類的設計者需要一點產品思維，代碼就是你的產品。
Lombok
以上代碼對于類的使用者來說，用著很爽，但是對于類的開發者來說，不夠友好，而且會有很多看似重復的代碼。對于類的開發者來說，這個類難以維護。對于開發者來說，永遠不要去做重復的事情，既然這件事情是有規律的、重復的。對于這樣的事情，程序更加擅長。
Lombok是一個可以讓Java代碼變的更加簡潔、讓你的開發更加高效的利器。使用了Lombok之后，我們不需要寫Getter&Setter、ToString等方法，這些都可以通過注解來代替，在編譯期間，Lombok會幫助你生成相應的字節碼。所以也不用擔心性能損失。
Lombok也支持了Builder模式，你可以用幾個注解來代替以上冗余的代碼。
|
1
2
3
4
5
6
7
8
|
@Builderpublic class Order { private String code; @Singular private List<String> offers; @Singular private Map<String, Object> features;} |
我們使用時
|
1
2
3
4
|
Order order = Order.builder().code("1234") .offer("滿100減5") .feature("category", "category") .build(); |
以上我們就是用了@Builder、@Singular實現了以上冗長的代碼。是不是很簡潔？在編譯階段，會幫助我們生成類似上面冗長代碼相同的字節碼。
在開發時，Lombok需要IDE插件的支持，所以你如果在工程代碼中使用，需要團隊達成共識，并安裝插件。
Java8
使用Java8之后，對于Builder模式我們有了新的方法，我們可以利用Supplier、Consumer來構造一個通用的Builder模式，具體代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public class GenericBuilder<T> { private final Supplier<T> instantiator; private List<Consumer<T>> instantiatorModifiers = new ArrayList<>(); private List<Consumer<T>> keyValueModifiers = 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); instantiatorModifiers.add(c); return this; } public <K, V> GenericBuilder<T> with(KeyValueConsumer<T, K, V> consumer, K key, V value) { Consumer<T> c = instance -> consumer.accept(instance, key, value); keyValueModifiers.add(c); return this; } public T build() { T value = instantiator.get(); instantiatorModifiers.forEach(modifier -> modifier.accept(value)); keyValueModifiers.forEach(keyValueModifier -> keyValueModifier.accept(value)); instantiatorModifiers.clear(); keyValueModifiers.clear(); return value; }} |
Order類定義
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Order { private String code; private List<String> offers; private Map<String, Object> features; public void addOffer(String offer) { offers = Optional.ofNullable(offers) .orElseGet(ArrayList::new); offers.add(offer); } public <T> void addFeature(String key, T value) { features = Optional.ofNullable(features) .orElseGet(HashMap::new); features.put(key, value); } //省略getter setter} |
在使用時如下：
|
1
2
3
4
5
|
Order order = GenericBuilder.of(Order::new) .with(Order::setCode, "123232") .with(Order::addOffer, "滿100減5") .with(Order::addFeature, "category", "shoe") .build(); |
在Java8中，使用通用Builder的方法，簡化了代碼開發，和Pre Java8相比要簡潔很多。相對于Lombok來說，由于仍然要生成getter&setter方法，還是沒有使用Lombok簡潔。但是它利用Java8的特性，不需要提供額外第三包的支持。
總結
以上就是這篇文章的全部內容了，希望本文的內容對大家的學習或者工作能帶來一定的幫助，如果有疑問大家可以留言交流，謝謝大家對服務器之家的支持。
原文鏈接：http://yywang.info/2017/05/06/java-builder/
