okhttp使用

okhttp则分为Request请求与response响应。

request请求体：每一个HTTP请求中都应该包含一个URL，一个GET或POST方法以及Header或其他参数，当然还可以含特定内容类型的数据流。

response 响应码：响应则包含一个回复代码（200代表成功，404代表未找到），Header和定制可选的body。

封装的okhttp库与okhttp使用:

blog.csdn.net/xjz123456qq…

基本请求(GET POST)

GET

Request.Builder builder = new Request.Builder();
        Request request = builder.get().url(url).build();
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException error) {
               //响应失败
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                //响应成功
            }
        });

POST

RequestBody body = RequestBody.create(JSON, jsonObject.toString());
 client.newCall(
                new Request.Builder()
                        .url(url)
                        //      .headers()//添加头
                        .post(body)
                        .build()).enqueue(new Callback() {

            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                LogUtil.i("http response " + response);
                if (response.isSuccessful()) {

                    }
                }else {

                }
            }
        });

okhttp请求流程与源码解析

由上面请求可以看出同步与异步，都是通过newCall()去实现的，那么newCall()到底了实现了什么呢？

//返回了一个Call对象
override fun newCall(request: Request): Call = RealCall(this, request, forWebSocket = false)

同步请求 call.execute()

override fun execute(): Response {
  //先判断一下当前是否请求过
  check(executed.compareAndSet(false, true)) { "Already Executed" }

  timeout.enter()
  callStart()
  try {
    //分发器进行分发
    client.dispatcher.executed(this)
    return getResponseWithInterceptorChain()// 走拦截器
  } finally {
    client.dispatcher.finished(this)//完成后的回调
  }
}

/** Used by [Call.execute] to signal it is in-flight. */
@Synchronized internal fun executed(call: RealCall) {
  runningSyncCalls.add(call)//直接去正在运行的同步队列中取值
}

源码可以看到，同步拦截器，直接去正在执行的同步队列中取值。

异步请求

override fun enqueue(responseCallback: Callback) {
//先判断当前这个call是否已经执行，执行了抛异常
  check(executed.compareAndSet(false, true)) { "Already Executed" }

  callStart()
  client.dispatcher.enqueue(AsyncCall(responseCallback))//走异步的分发
}

internal fun enqueue(call: AsyncCall) {
  synchronized(this) {
    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: Boolean
  synchronized(this) {

    val i = readyAsyncCalls.iterator()
    //迭代等待执行异步请求
    while (i.hasNext()) {
      val asyncCall = i.next()
      //正在执行异步请求的任务数 不能大于 64个
      if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.
      //同一个host的请求数 不能大于5
      if (asyncCall.callsPerHost.get() >= this.maxRequestsPerHost) continue // Host max capacity.

      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]
    asyncCall.executeOn(executorService)//放到线程池中进行处理
  }

  return isRunning
}

//异步处理任务的源码
override fun run() {
  threadName("OkHttp ${redactedUrl()}") {
    var signalledCallback = false
    timeout.enter()
    try {
      // 执行请求,走拦截器
      val response = getResponseWithInterceptorChain()
      signalledCallback = true
      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)//完成之后的回调
    }
  }
}

/** Used by [Call.execute] to signal completion. */
internal fun finished(call: RealCall) {
  finished(runningSyncCalls, call)
}

private fun <T> finished(calls: Deque<T>, call: T) {
  val idleCallback: Runnable?
  synchronized(this) {
    if (!calls.remove(call)) throw AssertionError("Call wasn't in-flight!")
    idleCallback = this.idleCallback
  }

  val isRunning = promoteAndExecute()//完成这次任务请求后，去进行下一次请求

  if (!isRunning && idleCallback != null) {
    idleCallback.run()
  }
}

上面可以看出，RealCall中有三个队列

1、正在执行的同步队列
2、正在执行的异步队列
3、准备执行的异步队列，任务进行排队准备的队列

异步请求流程:

1、enqueue()后，先判断当前任务是否被执行，没有执行走分发器的分发
2、先把任务放到等待执行的异步队列readyAsyncCalls中
3、对等待队列进行一个迭代，判断正在执行的任务数是否大于64 ，相同的host是否大于5
4、正在执行的异步队列中任务数大于64，则不能执行，继续在等待队列等待，如果当前任务的host>5,则进行下一个任务的执行判断
5、将要执行的任务放到正在执行的任务中，并且放到一个临时对列里，调线程池执行
6、线程池执行后，走拦截器，完成后，走回调。
7、拦截器走责任链模式，五大拦截器执行，完成后，回调。
8、完成后，重新触发promoteAndExecute(),进行下一个任务请求