Guava 风格之 Builder

    喜欢用guava的原因之一就是喜欢guava的编码风格，guava的fluent风格的api使用起来非常清爽，其中内部实现就使用了Builder模式

 

    1 在使用不可变集合ImmutableList时，可以直接初始化：

   

ImmutableList<String> strings = ImmutableList.of("1", "2");

    因为ImmutableList是一个不可变集合，初始化后就不能改变；但是当你一下子无法确定集合的值时，你需要多次添加才能确定，这时我们就可以使用Builder模式，guava的ImmutableList提供了一个内部类，

 

    ImmutableList.Builder<T>来实现上述场景：

   

ImmutableList.Builder<String> builder = new ImmutableList.Builder<String>();
        builder.add("hi");
        builder.add("name");
        ImmutableList<String> immutableList = builder.build();

    ImmutableList提供了一个内部类Builder<T>，该类继承自ImmutableCollection的内部类ArrayBasedBuilder

 

   

public static final class Builder<E> extends ImmutableCollection.ArrayBasedBuilder<E> {

    @Override public ImmutableList<E> build() {
      return asImmutableList(contents, size);
    }
}

abstract static class ArrayBasedBuilder<E> extends ImmutableCollection.Builder<E> {
    Object[] contents;
    int size;
    
    ArrayBasedBuilder(int initialCapacity) {
      checkNonnegative(initialCapacity, "initialCapacity");
      this.contents = new Object[initialCapacity];
      this.size = 0;
    }

}

    由上面可以看出，Builder<T>持有一个数组的引用，提供了Fluent风格的api，比如add（）， addAll（），可以对Builder进行多次添加，最后调用builder()方法把Builder转成Immutablist；

 

   这种代码的好处：清爽的Fluent风格的api，可以进行多次构造，代码极易阅读

 

 

 

2 下面可以举一个例子，用来说明Builder模式非常不错，贴合实际：

假如有一个User类，有四个属性attr1, attr2, attr3, attr4，当你想提供支持不同参数的构造函数时， 你可能要写类似如下的代码：

User (String attr1, String attr2, String attr3, String attr4) {
  //do something..
}

User (String attr1) {
  //do something..
} 

User (String attr1, String attr2) {
  //do something..
}

User (String attr1, String attr2, String attr3) {
  //do something..
}

 当别人调用你的构造方法时，就会很困惑，我的参数究竟对应哪几个属性， 你可能要去看一下代码的具体实现才能搞清楚；

现在用Builder模式就很容易解决上面的困惑，我们在上面的User类中定义一个内部类Builder，代码如下:

public static class Builder {
        private String attr1 = "";

        private String attr2 = "";

        private String attr3 = "";

        private String attr4 = "";

        public Builder attr1 (String attr1) {
            this.attr1 = attr1;
            return this;
        }

        public Builder attr2 (String attr2) {
            this.attr2 = attr2;
            return this;
        }

        public Builder attr3 (String attr3) {
            this.attr3 = attr3;
            return this;
        }

        public Builder attr4 (String attr4) {
            this.attr4 = attr4;
            return this;
        }

        public User build () {
            return new User(this.attr1, this.attr2, this.attr3, this.attr4);
        }
    }

 内部类Builder持有的属性和User类相同，不同时，Builder提供了Fluent风格的结构，让api调用起来更加方面，如下：

User user = new User.Builder().attr1("attr1").attr2("attr2").attr3("attr3").attr4("attr4").build();

 这样再构造User对象时，你可以清楚的知道自己对哪个属性指定了属性值

 

 

3  google 代码中大量使用了Builder模式，有兴趣的可以研究一下Gson，Gson对象的创建就提供了Builder模式的创建，GsonBuilder，提供gson对象的创建，支持创建过程中大量的自定义操作：

使用Gson的时候可以直接创建一个Gson对象：

 

Gson gson = new Gson();

 当用gson时，很多操作比如日期格式化都是按照默认的方式，Gson支持很多自定义的操作，构建Gson对象的时候可以使用一个Builder，可以添加很多自定义的操作，google提供了GsonBuilder，原理与上面的代码一样：

 

GsonBuilder中持有大量Gson对象可以设置的属性的引用，通过GsonBuilder的方法来设置这些属性，最后调用create（）方法，把这些属性放入到Gson对象中：

 

public final class GsonBuilder {
  //GsonBuilder持有大量的Gson对象可设置的属性
  private Excluder excluder = Excluder.DEFAULT;
  private LongSerializationPolicy longSerializationPolicy = LongSerializationPolicy.DEFAULT;
  private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY;
  private final Map<Type, InstanceCreator<?>> instanceCreators
      = new HashMap<Type, InstanceCreator<?>>();
  private final List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();
  /** tree-style hierarchy factories. These come after factories for backwards compatibility. */
  private final List<TypeAdapterFactory> hierarchyFactories = new ArrayList<TypeAdapterFactory>();
  private boolean serializeNulls;
  private String datePattern;
  private int dateStyle = DateFormat.DEFAULT;
  private int timeStyle = DateFormat.DEFAULT;
  private boolean complexMapKeySerialization;
  private boolean serializeSpecialFloatingPointValues;
  private boolean escapeHtmlChars = true;
  private boolean prettyPrinting;
  private boolean generateNonExecutableJson;

//通过GsonBuilder提供的方法可以设置这些属性...

  //把GsonBuilder持有的属性值设置到Gson对象中 
  public Gson create() {
    List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();
    factories.addAll(this.factories);
    Collections.reverse(factories);
    factories.addAll(this.hierarchyFactories);
    addTypeAdaptersForDate(datePattern, dateStyle, timeStyle, factories);

    return new Gson(excluder, fieldNamingPolicy, instanceCreators,
        serializeNulls, complexMapKeySerialization,
        generateNonExecutableJson, escapeHtmlChars, prettyPrinting,
        serializeSpecialFloatingPointValues, longSerializationPolicy, factories);
  }

    通过GsonBuilder我们可以自定义Gson对象的很多属性：

    例子：

Student student = new Student(1, "malone", new Date(), Calendar.getInstance());
        Student student1 = new Student(1, "malone", new Date(), Calendar.getInstance());
        List<Student> list = ImmutableList.of(student1, student);
        Gson gson = new GsonBuilder().registerTypeAdapter(Date.class, new MyDateSerializer())
                .serializeNulls().setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE).create();
        System.out.println(gson.toJson(list));

   输出结果：[{"id":1,"name":"malone","birthday":"2014-06-03 04:28:51"},{"id":1,"name":"malone","birthday":"2014-06-03 04:28:51"}]

   针对自定义一个类型适配器，可以调用方法registerTypeAdapter，
registerTypeAdapter方法源码为：

  public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
    $Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
        || typeAdapter instanceof JsonDeserializer<?>
        || typeAdapter instanceof InstanceCreator<?>
        || typeAdapter instanceof TypeAdapter<?>);
    if (typeAdapter instanceof InstanceCreator<?>) {
      instanceCreators.put(type, (InstanceCreator) typeAdapter);
    }
    if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
      TypeToken<?> typeToken = TypeToken.get(type);
      factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));
    }
    if (typeAdapter instanceof TypeAdapter<?>) {
      factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));
    }
    return this;
  }

    由上面的源码可知，参数typeAdapter应该实现了接口：JsonSerializer， JsonDeserializer， InstanceCreator， TypeAdapter其中的一个，下面是我们自己定义的一个TypeAdapter，实现了JsonSerializer接口：

class MyDateSerializer implements JsonSerializer<Date> {
    @Override
    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
        if (Objects.equals(src, null)) {
            return new JsonPrimitive("");
        }
        String value = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(src);
        return new JsonPrimitive(value);
    }
}

    类似的可以实现多个TypeAdapter，不知道Google为什么把GsonBuilder里创建Gson对象的方法叫做create，感觉叫做builder让人感觉更自然些！

Gson支持大量的自定义操作，可以通过GsonBuilder的方法来实现！