通过Builder模式创建对象

通过学习Spring源码发现其BeanDefinitionBuilder用来构建BeanDefinition实例，以实现实例化与属性设置的链式调用，所以也尝试着去链式封装
直接上 建造者 工具类

public class Builder<T> {
  // 用来保存实例对象
  private final Supplier<T> instantiator;
  // 用于保存Consumer对象，其 修改器 
  private List<Consumer<T>> modifiers = new ArrayList<>();

  /**
   * 构造器私有化
   */
  private Builder(Supplier<T> instantiator) {
      this.instantiator = instantiator;
  }

   /**
    * 直接通过new来创建对象
    */
   public static <T> Builder<T> of(Supplier<T> instantiator) {
       return new Builder<>(instantiator);
   }

   /**
    * 通过反射创建对象
    */
   public static <T> Builder<T> of(Class<T> clazz) {
       return new Builder<>(() -> BeanUtils.instantiateClass(clazz));
   }

  /**
   * .with(GirlFriend::setAge, 18)
   */
  public <P1> Builder<T> with(Consumer1<T, P1> consumer, P1 p1) {
      Consumer<T> c = instance -> consumer.accept(instance, p1);
      modifiers.add(c);
      return this;
  }

  /**
   * .with(GirlFriend::addGift, "情人节礼物", "LBR 1912女王时代")
   * private Map<String, String> gift;
   * <p>
   * 这里可变长参数只能放两个
   * with(GirlFriend::addHobby, "购物", "购物")
   * public void addHobby(String... hobby) {
   * 若需要放置更多，只能通过如下方法：
   * .with(GirlFriend::addHobby, new String[]{"购物", "购物", "买东西"})
   */
  public <P1, P2> Builder<T> with(Consumer2<T, P1, P2> consumer, P1 p1, P2 p2) {
      Consumer<T> c = instance -> consumer.accept(instance, p1, p2);
      modifiers.add(c);
      return this;
  }

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

  /**
   * 1 参数 Consumer
   */
  @FunctionalInterface
  public interface Consumer1<T, P1> {
      void accept(T t, P1 p1);
  }

  /**
   * 2 参数 Consumer
   */
  @FunctionalInterface
  public interface Consumer2<T, P1, P2> {
      void accept(T t, P1 p1, P2 p2);
  }
}

工具类最多支持二个参数设置属性方法。如果要扩展也很容易，依葫芦画瓢，添加多个参数的Consumer即可

使用示例

public class GirlFriend {
   private String name;
   private int age;
   private List<String> hobby;
   private String birthday;
   private String address;
   private String mobile;
   private String email;
   private String hairColor;
   private Map<String, String> gift;

   public void addHobby(String... hobby) {
       this.hobby = Optional.ofNullable(this.hobby).orElse(new ArrayList<>());
       for (String s : hobby) {
           Optional.ofNullable(s).ifPresent(this.hobby::add);
       }
   }

   public void addGift(String day, String gift) {
       this.gift = Optional.ofNullable(this.gift).orElse(new HashMap<>());
       this.gift.put(day, gift);
   }
}

GirlFriend girlFriend = Builder.of(GirlFriend::new)
  .with(GirlFriend::setName, "小美")
  .with(GirlFriend::setAge, 18)
  .with(GirlFriend::setBirthday, "2001-10-26")
  .with(GirlFriend::setAddress, "上海浦东")
  .with(GirlFriend::setMobile, "18688888888")
  .with(GirlFriend::setEmail, "pretty-xiaomei@qq.com")
  .with(GirlFriend::setHairColor, "浅棕色带点微卷")
  .with(GirlFriend::addHobby, "买东西")
  .with(GirlFriend::addHobby, "购物", "购物")
  // 由于Consumer只提供了支持两个参数的形式，所以需要将可变长参数封装成一个参数的形式
  .with(GirlFriend::addHobby, new String[]{"购物", "购物", "买东西"})
  .with(GirlFriend::addGift, "情人节礼物", "LBR 1912女王时代")
  .with(GirlFriend::addGift, "生日礼物", "迪奥烈焰蓝金")
  .with(GirlFriend::addGift, "纪念日礼物", "阿玛尼红管唇釉")
  .build();