源码系列-OkHttp

package okhttp3.guide;
import java.io.IOException;import okhttp3.OkHttpClient;import okhttp3.Request;import okhttp3.Response;
public class GetExample {  OkHttpClient client = new OkHttpClient();
  String run(String url) throws IOException {    Request request = new Request.Builder()        .url(url)        .build();
    try (Response response = client.newCall(request).execute()) {      return response.body().string();    }  }
  public static void main(String[] args) throws IOException {    GetExample example = new GetExample();    String response = example.run("https://raw.github.com/square/okhttp/master/README.md");    System.out.println(response);  }}

OkHttpClient client = new OkHttpClient();

public OkHttpClient() {    this(new Builder());}

new Request.Builder()

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

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);  }
  return url(HttpUrl.get(url));}

public static HttpUrl get(String url) {    return new Builder().parse(null, url).build();  }

public Builder() {  encodedPathSegments.add(""); // The default path is '/' which needs a trailing space.}

public HttpUrl build() {  if (scheme == null) throw new IllegalStateException("scheme == null");  if (host == null) throw new IllegalStateException("host == null");  return new HttpUrl(this);}

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

public Request build() {  if (url == null) throw new IllegalStateException("url == null");  return new Request(this);}

Request(Builder builder) {  this.url = builder.url;  this.method = builder.method;  this.headers = builder.headers.build();  this.body = builder.body;  this.tags = Util.immutableMap(builder.tags);}

Response response = client.newCall(request).execute()

@Override public Call newCall(Request request) {  return RealCall.newRealCall(this, request, false /* for web socket */);}

static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {  // Safely publish the Call instance to the EventListener.  RealCall call = new RealCall(client, originalRequest, forWebSocket);  call.transmitter = new Transmitter(client, call);  return call;}

public Transmitter(OkHttpClient client, Call call) {  this.client = client;  this.connectionPool = Internal.instance.realConnectionPool(client.connectionPool());  this.call = call;  this.eventListener = client.eventListenerFactory().create(call);  this.timeout.timeout(client.callTimeoutMillis(), MILLISECONDS);}

private static final Executor executor = new ThreadPoolExecutor(0 /* corePoolSize */,    Integer.MAX_VALUE /* maximumPoolSize */, 60L /* keepAliveTime */, TimeUnit.SECONDS,    new SynchronousQueue<>(), Util.threadFactory("OkHttp ConnectionPool", true));

@Override public Response execute() throws IOException {  synchronized (this) {    if (executed) throw new IllegalStateException("Already Executed");    executed = true;  }  transmitter.timeoutEnter();  transmitter.callStart();  try {    client.dispatcher().executed(this);    return getResponseWithInterceptorChain();  } finally {    client.dispatcher().finished(this);  }}

synchronized void executed(RealCall call) {    runningSyncCalls.add(call);  }

Response getResponseWithInterceptorChain() throws IOException {  // Build a full stack of interceptors.  List<Interceptor> interceptors = new ArrayList<>();  interceptors.addAll(client.interceptors());  interceptors.add(new RetryAndFollowUpInterceptor(client));  interceptors.add(new BridgeInterceptor(client.cookieJar()));  interceptors.add(new CacheInterceptor(client.internalCache()));  interceptors.add(new ConnectInterceptor(client));  if (!forWebSocket) {    interceptors.addAll(client.networkInterceptors());  }  interceptors.add(new CallServerInterceptor(forWebSocket));
  Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,      originalRequest, this, client.connectTimeoutMillis(),      client.readTimeoutMillis(), client.writeTimeoutMillis());
  boolean calledNoMoreExchanges = false;  try {    Response response = chain.proceed(originalRequest);    if (transmitter.isCanceled()) {      closeQuietly(response);      throw new IOException("Canceled");    }    return response;  } catch (IOException e) {    calledNoMoreExchanges = true;    throw transmitter.noMoreExchanges(e);  } finally {    if (!calledNoMoreExchanges) {      transmitter.noMoreExchanges(null);    }  }}

public Response proceed(Request request, Transmitter transmitter, @Nullable Exchange exchange)    throws IOException {  if (index >= interceptors.size()) throw new AssertionError();
  calls++;
  // If we already have a stream, confirm that the incoming request will use it.  if (this.exchange != null && !this.exchange.connection().supportsUrl(request.url())) {    throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)        + " must retain the same host and port");  }
  // If we already have a stream, confirm that this is the only call to chain.proceed().  if (this.exchange != null && calls > 1) {    throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)        + " must call proceed() exactly once");  }
  // Call the next interceptor in the chain.  RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,      index + 1, request, call, connectTimeout, readTimeout, writeTimeout);  Interceptor interceptor = interceptors.get(index);  Response response = interceptor.intercept(next);
  // Confirm that the next interceptor made its required call to chain.proceed().  if (exchange != null && index + 1 < interceptors.size() && next.calls != 1) {    throw new IllegalStateException("network interceptor " + interceptor        + " must call proceed() exactly once");  }
  // Confirm that the intercepted response isn't null.  if (response == null) {    throw new NullPointerException("interceptor " + interceptor + " returned null");  }
  if (response.body() == null) {    throw new IllegalStateException(        "interceptor " + interceptor + " returned a response with no body");  }
  return response;}

Interceptor interceptor = interceptors.get(index);Response response = interceptor.intercept(next);