Java中Builder模式的实现详解

前言

本文主要给大家介绍了关于如何实现builder模式，大家在构建大对象时，对象的属性比较多，我们可以采用一个构造器或者使用空的构造器构造，然后使用setter方法去设置。在使用者使用这些方法时，会很多冗长的构造器参数列表或者setter方法。我们可以使用builder模式来简化大对象的构造，提高代码的简洁性，同时提高使用者的编码体验。

下面我们将介绍在java8之前、使用极简代码利器lombok、java8之后的builder模式。

pre java8

我们先来看下在java8之前的builder模式

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没有提供自动的生成工具，这也是我们目前在工程代码里看到这种模式的比较少的原因之一。但是对于这个类的使用者来说，提高了很高的代码体验。在使用者，使用这个类时如下：

order order = order.builder().code("1235")
  .offer("满100减5")
  .feature("category", "shoe")
  .build();

一个类的定义通常只会有一个地方，而使用这个类的地方会有很多，在定义类时为使用者多考虑一些，就能为使用这个类的开发者提高很多效率，同时让整个团队的代码变的更加简洁。

我一直认为一个类的设计和一个产品的设计者理念相同，产品经理设计一个功能首先能解决用户的痛点，同时还要提高用户体验，让用户用着爽。同样设计一个基础类，需要解决一个业务问题，同时需要从使用者的角度考虑，让使用者用着爽。一个优秀的基础类的设计者需要一点产品思维，代码就是你的产品。

lombok

以上代码对于类的使用者来说，用着很爽，但是对于类的开发者来说，不够友好，而且会有很多看似重复的代码。对于类的开发者来说，这个类难以维护。对于开发者来说，永远不要去做重复的事情，既然这件事情是有规律的、重复的。对于这样的事情，程序更加擅长。

lombok是一个可以让java代码变的更加简洁、让你的开发更加高效的利器。使用了lombok之后，我们不需要写getter&setter、tostring等方法，这些都可以通过注解来代替，在编译期间，lombok会帮助你生成相应的字节码。所以也不用担心性能损失。

lombok也支持了builder模式，你可以用几个注解来代替以上冗余的代码。

@builder
public class order {
 private string code;
 @singular
 private list<string> offers;
 @singular
 private map<string, object> features;
}

我们使用时

order order = order.builder().code("1234")
   .offer("满100减5")
   .feature("category", "category")
   .build();

以上我们就是用了@builder、@singular实现了以上冗长的代码。是不是很简洁？在编译阶段，会帮助我们生成类似上面冗长代码相同的字节码。

在开发时，lombok需要ide插件的支持，所以你如果在工程代码中使用，需要团队达成共识，并安装插件。

java8

使用java8之后，对于builder模式我们有了新的方法，我们可以利用supplier、consumer来构造一个通用的builder模式，具体代码如下：

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类定义

 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
}

在使用时如下：

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的特性，不需要提供额外第三包的支持。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作能带来一定的帮助，如果有疑问大家可以留言交流，谢谢大家对的支持。