Java中Builder模式的实现详解

http://www.jb51.net/article/113131.htm

在设计模式中对Builder模式的定义是用于构建复杂对象的一种模式，所构建的对象往往需要多步初始化或赋值才能完成。下面这篇文章主要给大家介绍了在Java各个版本中Builder模式实现的相关资料，文中介绍的非常详细，需要的朋友可以参考学习。

前言

本文主要给大家介绍了关于如何实现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

@Builder public 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/