Builder模式

使用 Builder 模式构造 JavaBean 的好处

我们一般在构造一个javaBean 对象时，无非有三种写法：
1. 直接通过构造函数传参的方式设置属性，这种方法如果属性过多的话会让构造函数十分臃肿，而且不能灵活的选择只设置某些参数。
2. 采用重叠构造区模式，先写第一个只有必要参数的构造器，第二个构造器有一个可选参数，第三个构造器有两个可选参数，以此类推；如果参数比较多时，类里面会出现一堆构造方法，并且阅读困难，很容易就把两个属性参数写颠倒位置了，编译不会出错，但运行就会出错了__《Effective Java》
3. 采用Javabean 的写法，写一堆属性的setter方法，通过生成对象，让后调用setter方法给属性赋值。 这种方法有个劣势就是构造的过程被分到几个调用中，在构造中可能处于不一致状态，无法保证一致性。
4. 采用Builder 模式构造对象，当一个类的参数多的情况下，使用重叠构造器模式客户端代码会很难编写，并且可读性差；使用javabean模式，调用一个无参的构造器，然后调用setter方法来设置每个必要的参数。但是javabean自身有着严重的缺点，因为构造过程被分到几个调用中，在构造javabean可能处于不一致的状态，类无法仅仅通过检验构造器参数的有效性来保证一致性。另一点不足之处，javabean模式阻止了把类做成不可变的可能，这就需要程序员付出额外的努力来确保他的线程安全； build模式 既能保证像重叠构造器那样的安全，也能实现JavaBean模式那样的可读性。

使用builder模式的步骤

1. 不直接生成想要的对象，而是让客户端利用所有必要的参数调用构造器（或者静态工厂），得到一个build对象。
2. 然后让客户端在build对象上调用类似的setter方法来设置每个相关的可选参数，
3. 最后，客户端调用无参的build方法来生成不可变的对象。这个builder是它构建的静态成员类。
   下面就说一下 Builder 模的使用，这个例子是htttp 中的request 对象的构造：

public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final RequestBody body;
  final Object tag;

  Request(Builder builder) {
    this.url = builder.url;
    this.method = builder.method;
    this.headers = builder.headers.build();
    this.body = builder.body;
    this.tag = builder.tag != null ? builder.tag : this;
  }

  public HttpUrl url() {
    return url;
  }

  public String method() {
    return method;
  }

  public Headers headers() {
    return headers;
  }

  public String header(String name) {
    return headers.get(name);
  }

  public List<String> headers(String name) {
    return headers.values(name);
  }

  public RequestBody body() {
    return body;
  }

  public Object tag() {
    return tag;
  }

  public Builder newBuilder() {
    return new Builder(this);
  }


  public CacheControl cacheControl() {
    CacheControl result = cacheControl;
    return result != null ? result : (cacheControl = CacheControl.parse(headers));
  }

  public boolean isHttps() {
    return url.isHttps();
  }


  public static class Builder {
    HttpUrl url;
    String method;
    Headers.Builder headers;
    RequestBody body;
    Object tag;

    public Builder() {
      this.method = "GET";
      this.headers = new Headers.Builder();
    }

    Builder(Request request) {
      this.url = request.url;
      this.method = request.method;
      this.body = request.body;
      this.tag = request.tag;
      this.headers = request.headers.newBuilder();
    }

    public Builder url(HttpUrl url) {
      if (url == null) throw new NullPointerException("url == null");
      this.url = url;
      return this;
    }


    public Builder url(String url) {
      if (url == null) throw new NullPointerException("url == null");

      // Silently replace web socket URLs with HTTP URLs.
      if (url.regionMatches(true, 0, "ws:", 0, 3)) {
        url = "http:" + url.substring(3);
      } else if (url.regionMatches(true, 0, "wss:", 0, 4)) {
        url = "https:" + url.substring(4);
      }

      HttpUrl parsed = HttpUrl.parse(url);
      if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
      return url(parsed);
    }

    public Builder url(URL url) {
      if (url == null) throw new NullPointerException("url == null");
      HttpUrl parsed = HttpUrl.get(url);
      if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
      return url(parsed);
    }

    public Builder header(String name, String value) {
      headers.set(name, value);
      return this;
    }

    public Builder addHeader(String name, String value) {
      headers.add(name, value);
      return this;
    }

    public Builder removeHeader(String name) {
      headers.removeAll(name);
      return this;
    }

    public Builder headers(Headers headers) {
      this.headers = headers.newBuilder();
      return this;
    }

    public Builder cacheControl(CacheControl cacheControl) {
      String value = cacheControl.toString();
      if (value.isEmpty()) return removeHeader("Cache-Control");
      return header("Cache-Control", value);
    }

    public Builder get() {
      return method("GET", null);
    }

    public Builder head() {
      return method("HEAD", null);
    }

    public Builder post(RequestBody body) {
      return method("POST", body);
    }

    public Builder delete(RequestBody body) {
      return method("DELETE", body);
    }

    public Builder delete() {
      return delete(Util.EMPTY_REQUEST);
    }

    public Builder put(RequestBody body) {
      return method("PUT", body);
    }

    public Builder patch(RequestBody body) {
      return method("PATCH", body);
    }

    public Builder method(String method, RequestBody body) {
      if (method == null) throw new NullPointerException("method == null");
      if (method.length() == 0) throw new IllegalArgumentException("method.length() == 0");
      if (body != null && !HttpMethod.permitsRequestBody(method)) {
        throw new IllegalArgumentException("method " + method + " must not have a request body.");
      }
      if (body == null && HttpMethod.requiresRequestBody(method)) {
        throw new IllegalArgumentException("method " + method + " must have a request body.");
      }
      this.method = method;
      this.body = body;
      return this;
    }

    public Builder tag(Object tag) {
      this.tag = tag;
      return this;
    }


    /* 
     * Request 对象创建器，想得到一个Request 对象必须使用build 方法， 
     * 在方法中增加对Builder参数的验证，并以异常的形式告诉给开发人员。 
     */         
    public Request build() {
    /**
     * 比如下面判断如果 url 是null的话就会抛出异常
     */
      if (url == null) throw new IllegalStateException("url == null");
      return new Request(this);
    }
  }
}

可以看出 Builder 是Request 静态的内部类，并且 Builder 中的属性是和 Request 中的一致的，所以得属性设置都在 Builder 中，Request 中只有获取属性的方法

使用 Builder 构造一个 Request 对象:

    Request request = new Request.Builder()  
                    .url("http://www.weather.com.cn/data/sk/101010100.html")  
                    .addHeader("header","header")  
                    .put("RequestBody")  
                    .build();  

采用javaBean 写法的缺点就是， 一但调用 new Request() 构造函数后，对象就被创建了，以后在调用 set 方法设置属性的时候这里设置一下，其他地方又设置一下，无法保证对象的状态一致性，而且代码的可读性很差

1. Builder 方式创建的对象，在调用 build() 方法之前是不会创建Request 对象的，所有的属性设置都必须在 build() 方法之前，而且创建了 Request 对象后就不可以更改其属性了，这就保证了对象状态的唯一性，而且代码的可读性也提高了。

2. 如果有些参数是必填的，可以加到 Builder 的构造函数中。