[关闭]
@linux1s1s 2017-01-09T12:12:52.000000Z 字数 6438 阅读 1766

Base Time-Design Patterns-Build

Base 2017-01

栗子

我们不管Build模式是啥，如何使用，在什么场景下使用，我们先看看在Android客户端红遍半边天的第三方库是如何用Build的。

OKHttp

OkHttp构建网络Request：

  1. Request request = new Request.Builder().url(url).build();

Retrofit

Retrofit构建实例：

  1. Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(GsonConverterFactory.create()).build();

Fresco

Fresco构建DraweeController实例：

  1. DraweeController controller = Fresco.newDraweeControllerBuilder()
  2.                 .setUri(Uri.parse(GIF))
  3.                 .setAutoPlayAnimations(true)
  4.                 .build();

从上面的三个实例，我们发现，大红大紫的三方库居然都使用了build模式，所以我们本着认真学习的姿势来看看他们是如何干活的。

OKHttp

我们准备以Okhttp为样板，深究内部的实现，其他两个大同小异，不再赘述。

涉及到Build的Request类如下：
Request.java

  1. public final class Request {
  2.   private final HttpUrl url;
  3.   private final String method;
  4.   private final Headers headers;
  5.   private final RequestBody body;
  6.   private final Object tag;
  8.   private volatile CacheControl cacheControl; // Lazily initialized.
  10.   private Request(Builder builder) {
  11.     this.url = builder.url;
  12.     this.method = builder.method;
  13.     this.headers = builder.headers.build();
  14.     this.body = builder.body;
  15.     this.tag = builder.tag != null ? builder.tag : this;
  16.   }
  18.   public HttpUrl url() {
  19.     return url;
  20.   }
  22.   public String method() {
  23.     return method;
  24.   }
  26.   public Headers headers() {
  27.     return headers;
  28.   }
  30.   public String header(String name) {
  31.     return headers.get(name);
  32.   }
  34.   public List<String> headers(String name) {
  35.     return headers.values(name);
  36.   }
  38.   public RequestBody body() {
  39.     return body;
  40.   }
  42.   public Object tag() {
  43.     return tag;
  44.   }
  46.   public Builder newBuilder() {
  47.     return new Builder(this);
  48.   }
  50.   /**
  51.    * Returns the cache control directives for this response. This is never null, even if this
  52.    * response contains no {@code Cache-Control} header.
  53.    */
  54.   public CacheControl cacheControl() {
  55.     CacheControl result = cacheControl;
  56.     return result != null ? result : (cacheControl = CacheControl.parse(headers));
  57.   }
  59.   public boolean isHttps() {
  60.     return url.isHttps();
  61.   }
  63.   @Override public String toString() {
  64.     return "Request{method="
  65.         + method
  66.         + ", url="
  67.         + url
  68.         + ", tag="
  69.         + (tag != this ? tag : null)
  70.         + '}';
  71.   }
  73.   public static class Builder {
  74.     private HttpUrl url;
  75.     private String method;
  76.     private Headers.Builder headers;
  77.     private RequestBody body;
  78.     private Object tag;
  80.     public Builder() {
  81.       this.method = "GET";
  82.       this.headers = new Headers.Builder();
  83.     }
  85.     private Builder(Request request) {
  86.       this.url = request.url;
  87.       this.method = request.method;
  88.       this.body = request.body;
  89.       this.tag = request.tag;
  90.       this.headers = request.headers.newBuilder();
  91.     }
  93.     public Builder url(HttpUrl url) {
  94.       if (url == null) throw new NullPointerException("url == null");
  95.       this.url = url;
  96.       return this;
  97.     }
  99.     /**
  100.      * Sets the URL target of this request.
  101.      *
  102.      * @throws IllegalArgumentException if {@code url} is not a valid HTTP or HTTPS URL. Avoid this
  103.      * exception by calling {@link HttpUrl#parse}; it returns null for invalid URLs.
  104.      */
  105.     public Builder url(String url) {
  106.       if (url == null) throw new NullPointerException("url == null");
  108.       // Silently replace websocket URLs with HTTP URLs.
  109.       if (url.regionMatches(true, 0, "ws:", 0, 3)) {
  110.         url = "http:" + url.substring(3);
  111.       } else if (url.regionMatches(true, 0, "wss:", 0, 4)) {
  112.         url = "https:" + url.substring(4);
  113.       }
  115.       HttpUrl parsed = HttpUrl.parse(url);
  116.       if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
  117.       return url(parsed);
  118.     }
  120.     /**
  121.      * Sets the URL target of this request.
  122.      *
  123.      * @throws IllegalArgumentException if the scheme of {@code url} is not {@code http} or {@code
  124.      * https}.
  125.      */
  126.     public Builder url(URL url) {
  127.       if (url == null) throw new NullPointerException("url == null");
  128.       HttpUrl parsed = HttpUrl.get(url);
  129.       if (parsed == null) throw new IllegalArgumentException("unexpected url: " + url);
  130.       return url(parsed);
  131.     }
  133.     /**
  134.      * Sets the header named {@code name} to {@code value}. If this request already has any headers
  135.      * with that name, they are all replaced.
  136.      */
  137.     public Builder header(String name, String value) {
  138.       headers.set(name, value);
  139.       return this;
  140.     }
  142.     /**
  143.      * Adds a header with {@code name} and {@code value}. Prefer this method for multiply-valued
  144.      * headers like "Cookie".
  145.      *
  146.      * <p>Note that for some headers including {@code Content-Length} and {@code Content-Encoding},
  147.      * OkHttp may replace {@code value} with a header derived from the request body.
  148.      */
  149.     public Builder addHeader(String name, String value) {
  150.       headers.add(name, value);
  151.       return this;
  152.     }
  154.     public Builder removeHeader(String name) {
  155.       headers.removeAll(name);
  156.       return this;
  157.     }
  159.     /** Removes all headers on this builder and adds {@code headers}. */
  160.     public Builder headers(Headers headers) {
  161.       this.headers = headers.newBuilder();
  162.       return this;
  163.     }
  165.     /**
  166.      * Sets this request's {@code Cache-Control} header, replacing any cache control headers already
  167.      * present. If {@code cacheControl} doesn't define any directives, this clears this request's
  168.      * cache-control headers.
  169.      */
  170.     public Builder cacheControl(CacheControl cacheControl) {
  171.       String value = cacheControl.toString();
  172.       if (value.isEmpty()) return removeHeader("Cache-Control");
  173.       return header("Cache-Control", value);
  174.     }
  176.     public Builder get() {
  177.       return method("GET", null);
  178.     }
  180.     public Builder head() {
  181.       return method("HEAD", null);
  182.     }
  184.     public Builder post(RequestBody body) {
  185.       return method("POST", body);
  186.     }
  188.     public Builder delete(RequestBody body) {
  189.       return method("DELETE", body);
  190.     }
  192.     public Builder delete() {
  193.       return delete(RequestBody.create(null, new byte[0]));
  194.     }
  196.     public Builder put(RequestBody body) {
  197.       return method("PUT", body);
  198.     }
  200.     public Builder patch(RequestBody body) {
  201.       return method("PATCH", body);
  202.     }
  204.     public Builder method(String method, RequestBody body) {
  205.       if (method == null) throw new NullPointerException("method == null");
  206.       if (method.length() == 0) throw new IllegalArgumentException("method.length() == 0");
  207.       if (body != null && !HttpMethod.permitsRequestBody(method)) {
  208.         throw new IllegalArgumentException("method " + method + " must not have a request body.");
  209.       }
  210.       if (body == null && HttpMethod.requiresRequestBody(method)) {
  211.         throw new IllegalArgumentException("method " + method + " must have a request body.");
  212.       }
  213.       this.method = method;
  214.       this.body = body;
  215.       return this;
  216.     }
  218.     /**
  219.      * Attaches {@code tag} to the request. It can be used later to cancel the request. If the tag
  220.      * is unspecified or null, the request is canceled by using the request itself as the tag.
  221.      */
  222.     public Builder tag(Object tag) {
  223.       this.tag = tag;
  224.       return this;
  225.     }
  227.     public Request build() {
  228.       if (url == null) throw new IllegalStateException("url == null");
  229.       return new Request(this);
  230.     }
  231.   }
  232. }

上面的代码很长，其实我们关注的有几点如下：
Request构造器

  1. private Request(Builder builder) {
  2.     this.url = builder.url;
  3.     this.method = builder.method;
  4.     this.headers = builder.headers.build();
  5.     this.body = builder.body;
  6.     this.tag = builder.tag != null ? builder.tag : this;
  7.   }

注意是个私有构造器，而且参数是Builder实例，这个构造器限制了必须通过Builder实例才能生成Request实例，并且，只能在看得到构造器的地方调用如下所示：

  1. public Request build() {
  2.   if (url == null) throw new IllegalStateException("url == null");
  3.   return new Request(this);
  4. }

这个成员方法build()构造了Request实例，所以有必要看一下如何获取Build实例

  1. public Builder() {
  2.   this.method = "GET";
  3.   this.headers = new Headers.Builder();
  4. }
  6. private Builder(Request request) {
  7.   this.url = request.url;
  8.   this.method = request.method;
  9.   this.body = request.body;
  10.   this.tag = request.tag;
  11.   this.headers = request.headers.newBuilder();
  12. }

提供了两个重载的构造器，而且分别是私有的和公有的，所以对于类的外部来说，只能通过公有构造器获取Build实例，然后在调用成员方法build()构造Request实例，当然如果如果想反向获取Build实例，也可以直接通过Request的成员方法获取，如下：

  1. public Builder newBuilder() {
  2.     return new Builder(this);
  3. }

对于上面的设计，可能有些人会问，为啥非得通过Build这个类来间接的完成Request的构建呢？

原因个人理解是，因为Request的参数比较多，通过Build可以有效的管理这些参数，另外还可以做有效性检查等其他操作。

至于其他的原因读者可以另行补充。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注