Builder模式

Builder模式：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

实用范围
1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2、当构造过程必须允许被构造的对象有不同表示时。

Product是一个产品类，由四个部分组成，有的部分是必要的，有的是非必要的，用Builder模式的实现如下：

public class Product {

    private final String part1;           // 必传参数
    private final String part2;           // 必传参数
    private final int part3;              // 可选参数
    private final String part4;           // 可选参数

    private User(UserBuilder builder) {
        this.part1 = builder.part1;
        this.part2 = builder.part2;
        this.part3 = builder.part3;
        this.part4 = builder.part4;
    }

    public String getPart1() {
        return part1;
    }

    public String getPart2() {
        return part2;
    }

    public int getPart3() {
        return part3;
    }

    public String getPart4() {
        return part4;
    }
}


public class Builder {
        private final String part1;
        private final String part2;
        private int part3;
        private String part4;

  4      public Builder(String part1, String part2) {
            this.part1 = part2;
            this.part1 = part2;
        }

        public Builder buildPart3(int part3) {
            this.part3= part3;
            return this;
        }

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

        public User build() {
            return new Product(this);
        }
    }

创建一个Product对象：

Product product = new Product().Builder(part1, part2)
                            .buildPart3(part3)
                            .buildPart4(part4)
                            .build();

其中：
Product类的构造方法是私有的。也就是说调用者不能直接创建Product对象。
Product类的属性都是不可变的。所有的属性都添加了final修饰符，并且在构造方法中设置了值。并且，对外只提供getters方法。
Builder模式使用了链式调用。可读性更佳。
Builder的内部类构造方法中只接收必传的参数，并且该必传的参数适用了final修饰符。

下面一个例子是okHttp中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);  
    }  
  }  
}  

构造一个request对象:

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