OkHttpClient client = new OkHttpClient.Builder().build();Request request = new Request.Builder().url(url).build();try {Response response = client.newCall(request).execute();response.body().string();} catch (IOException e) {e.printStackTrace();}

OkHttpClient client = new OkHttpClient.Builder().build();Request request = new Request.Builder().url(url).build();client.newCall(request).enqueue(new Callback() {@Overridepublic void onFailure(@NotNull Call call, @NotNull IOException e) {}@Overridepublic void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {response.body().string();}});

class Request internal constructor(@get:JvmName("url") val url: HttpUrl,@get:JvmName("method") val method: String,@get:JvmName("headers") val headers: Headers,@get:JvmName("body") val body: RequestBody?,internal val tags: Map<Class<*>, Any>
) {

override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

class RealCall(val client: OkHttpClient,/** The application's original request unadulterated by redirects or auth headers. */val originalRequest: Request,val forWebSocket: Boolean
) : Call {//同步请求override fun execute(): Response {...}//异步请求override fun enqueue(responseCallback: Callback) {...}//通过拦截器责任链获取请求结果
@Throws(IOException::class)internal fun getResponseWithInterceptorChain(): Response {...}
}

 override fun execute(): Response {//判断当前call是否请求过，如果check（true）则抛出异常synchronized(this) {check(!executed) { "Already Executed" }executed = true}
//超时逻辑开启，超时时间设置在client.callTimeoutMillis 进行设置timeout.enter()
//事件监听器的请求开始时间回调callStart()try {// 调用client的dispatcher调度器执行call（将RealCall加入同步runningSyncCalls队列）client.dispatcher.executed(this)
// 通过拦截器责任链模式进行请求和返回处理等一系类逻辑return getResponseWithInterceptorChain()} finally {//不管请求是否成功,都将call移出runningSyncCalls队列client.dispatcher.finished(this)}}

@Throws(IOException::class)internal fun getResponseWithInterceptorChain(): Response {// 建立一个拦截器集合val interceptors = mutableListOf<Interceptor>()interceptors += client.interceptors//client配置的拦截器interceptors += RetryAndFollowUpInterceptor(client)//重试请求拦截器interceptors += BridgeInterceptor(client.cookieJar)//interceptors += CacheInterceptor(client.cache)//缓存拦截器interceptors += ConnectInterceptor//连接拦截器if (!forWebSocket) {interceptors += client.networkInterceptors}interceptors += CallServerInterceptor(forWebSocket)//执行拦截器
//生成拦截器链val chain = RealInterceptorChain(call = this,//RealCallinterceptors = interceptors,//拦截器集合index = 0,exchange = null,request = originalRequest,//Request对象connectTimeoutMillis = client.connectTimeoutMillis,readTimeoutMillis = client.readTimeoutMillis,writeTimeoutMillis = client.writeTimeoutMillis)var calledNoMoreExchanges = falsetry {//把request传入拦截器链对象的proceed方法得到responseval response = chain.proceed(originalRequest)
//取消请求call.cancel()if (isCanceled()) {response.closeQuietly()throw IOException("Canceled")}
//返回请求结果return response} catch (e: IOException) {calledNoMoreExchanges = truethrow noMoreExchanges(e) as Throwable} finally {if (!calledNoMoreExchanges) {noMoreExchanges(null)}}}
.....

class RealInterceptorChain(internal val call: RealCall,private val interceptors: List<Interceptor>,//拦截器链表private val index: Int,//计数器internal val exchange: Exchange?,internal val request: Request,internal val connectTimeoutMillis: Int,internal val readTimeoutMillis: Int,internal val writeTimeoutMillis: Int
) : Interceptor.Chain {@Throws(IOException::class)override fun proceed(request: Request): Response {check(index < interceptors.size)calls++if (exchange != null) {check(exchange.finder.sameHostAndPort(request.url)) {"network interceptor ${interceptors[index - 1]} must retain the same host and port"}check(calls == 1) {"network interceptor ${interceptors[index - 1]} must call proceed() exactly once"}}
//创建一个新的RealInterceptorChain实例,并将计数器index+1
//这是kotlin写法,并没有改变当前实例的计数器index值val next = copy(index = index + 1, request = request)
//取出当前顺序的拦截器,第一个index=0val interceptor = interceptors[index]
//调用拦截器的拦截方法interceptor.intercept(next)并传入新的RealInterceptorChain实例@Suppress("USELESS_ELVIS")val response = interceptor.intercept(next) ?: throw NullPointerException("interceptor $interceptor returned null")if (exchange != null) {check(index + 1 >= interceptors.size || next.calls == 1) {"network interceptor $interceptor must call proceed() exactly once"}}check(response.body != null) { "interceptor $interceptor returned a response with no body" }
//返回请求结果return response}

class RealCall(override fun enqueue(responseCallback: Callback) {synchronized(this) {check(!executed) { "Already Executed" }executed = true}callStart()
//调用了dispatcher调度器的enqueue()方法client.dispatcher.enqueue(AsyncCall(responseCallback))}

class Dispatcher constructor() {// 默认最大请求数 64@get:Synchronized var maxRequests = 64// 默认最大并发Host 5@get:Synchronized var maxRequestsPerHost = 5// 线程池执行器 默认创建可缓存线程池 @get:JvmName("executorService") val executorService: ExecutorServiceget() {if (executorServiceOrNull == null) {executorServiceOrNull = ThreadPoolExecutor(0, Int.MAX_VALUE, 60, TimeUnit.SECONDS,SynchronousQueue(), threadFactory("OkHttp Dispatcher", false))}return executorServiceOrNull!!}//准备阶段的异步call队列private val readyAsyncCalls = ArrayDeque<AsyncCall>()//运行中的异步call队列private val runningAsyncCalls = ArrayDeque<AsyncCall>()//运行中的同步call队列private val runningSyncCalls = ArrayDeque<RealCall>()internal fun enqueue(call: AsyncCall) {synchronized(this) {//将asyncCall加入准备阶段的异步call队列readyAsyncCalls.add(call)// Mutate the AsyncCall so that it shares the AtomicInteger of an existing running call to// the same host.if (!call.call.forWebSocket) {val existingCall = findExistingCallWithHost(call.host)if (existingCall != null) call.reuseCallsPerHostFrom(existingCall)}}
// 准备线程池执行器，及执行promoteAndExecute()}private fun promoteAndExecute(): Boolean {this.assertThreadDoesntHoldLock()
//局部变量队列缓存val executableCalls = mutableListOf<AsyncCall>()val isRunning: Booleansynchronized(this) {//获取准备阶段的异步call队列的迭代器,遍历获取队列中的异步callval i = readyAsyncCalls.iterator()while (i.hasNext()) {val asyncCall = i.next()if (runningAsyncCalls.size >= this.maxRequests) break // 已达请求数上限if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // 已达并发数上限i.remove()asyncCall.callsPerHost.incrementAndGet()executableCalls.add(asyncCall)//加入此次执行队列缓存runningAsyncCalls.add(asyncCall)// 加入正在执行队列}isRunning = runningCallsCount() > 0}for (i in 0 until executableCalls.size) {val asyncCall = executableCalls[i]
// 将线程执行器传入call，在Call中进行执行asyncCall.executeOn(executorService)}return isRunning}

internal inner class AsyncCall(private val responseCallback: Callback) : Runnable {fun executeOn(executorService: ExecutorService) {client.dispatcher.assertThreadDoesntHoldLock()var success = falsetry {//AsyncCall实现了runnable接口,所以使用线程池执行AsyncCallexecutorService.execute(this)success = true} catch (e: RejectedExecutionException) {val ioException = InterruptedIOException("executor rejected")ioException.initCause(e)noMoreExchanges(ioException)responseCallback.onFailure(this@RealCall, ioException)} finally {if (!success) {client.dispatcher.finished(this) // This call is no longer running!}}}override fun run() {threadName("OkHttp ${redactedUrl()}") {var signalledCallback = falsetimeout.enter()try {//这里又到了之前分析的拦截器责任链请求val response = getResponseWithInterceptorChain()signalledCallback = true
//最终将结果放入callback.onResponse()返回responseCallback.onResponse(this@RealCall, response)} catch (e: IOException) {if (signalledCallback) {// Do not signal the callback twice!Platform.get().log("Callback failure for ${toLoggableString()}", Platform.INFO, e)} else {responseCallback.onFailure(this@RealCall, e)}} catch (t: Throwable) {cancel()if (!signalledCallback) {val canceledException = IOException("canceled due to $t")canceledException.addSuppressed(t)responseCallback.onFailure(this@RealCall, canceledException)}throw t} finally {client.dispatcher.finished(this)}}}}