okttp3-源码分析(1)execute()方法和enqueue()方法

最近在看okhttp源码,我们都知道okhttp是用来进行网络请求,下面就从最常用的execute()方法和enqueue()方法切入,来分析okhttp的请求过程。
先来看okhttp的基本用法,之后的分析应该都会以基本用法来进行:

String url = "http://wwww.baidu.com";//这里是URL
OkHttpClient okHttpClient = new OkHttpClient();//先构建okhttp客户端
final Request request = new Request.Builder()//构建request对象
        .url(url)
        .get()//默认就是GET请求,可以不写
        .build();
Call call = okHttpClient.newCall(request);//创建Call对象

Response response = call.execute();//同步方法,会抛异常

call.enqueue(new Callback() {//执行异步请求
    @Override
    public void onFailure(Call call, IOException e) {
       //这里是请求失败的逻辑
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
       //这里写请求成功的逻辑
    }
});

execute()同步请求

先来看看execute()方法,该方法会立即进行请求。调用该方法时,实际上调用的是RealCall类下的execute()方法。Call本身是一个接口,而RealCall实现了Call接口

  @Override public Response execute() throws IOException {
    synchronized (this) {//同步检测,看请求是否已经执行
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();//有待研究,和重定向拦截器油管。机翻:捕获调用堆栈跟踪
    timeout.enter();
    eventListener.callStart(this);//事件监听器
    try {
      client.dispatcher().executed(this);//实际调用dispatcher来真正执行,在这里会把请求加入执行队列
      Response result = getResponseWithInterceptorChain();
      //上面这个是重要方法,会调用拦截器来获得请求
      if (result == null) throw new IOException("Canceled");//下面这些都是异常情况处理
      return result;
    } catch (IOException e) {
      e = timeoutExit(e);
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);//这里会把请求移出执行队列
    }
  }

补充点:
dispatcher是okhttp的重要类。他里面维护三个队列,这里涉及到的队列是 runningSyncCalls,即同步执行队列。
其他两个队列分别是异步准备队列,和异步执行队列。

下面看很重要的getResponseWithInterceptorChain()方法,不管是同步请求还是异步请求都会调用该方法。

  Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());//自定义的应用拦截器
    interceptors.add(retryAndFollowUpInterceptor);//重定向拦截器
      //进行重定向的工作,在这里创建StreamAllocation(很重要的类)
    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, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

这里就是okhttp责任链的实现,这里需要搞清楚,还得认真研究每个拦截器,这部分的坑就在下一节再填吧。
总之这个方法就是调用各个拦截器,进行一系列的设置之后向服务器发送请求,并且返回请求结果。

enqueue() 异步请求

异步请求操作中重要的实现类就是RealCall下的内部类AsyncCall,AsyncCall继承了抽象类NamedRuunble,而抽象类NamedRunnble实现了Runable接口,并重写了run方法。

public abstract class NamedRunnable implements Runnable {
  protected final String name;//线程的名字

  public NamedRunnable(String format, Object... args) {
    this.name = Util.format(format, args);
  }

  @Override public final void run() {
    String oldName = Thread.currentThread().getName();
    Thread.currentThread().setName(name);
    try {
      execute();//调用execut()方法开始时执行
    } finally {
      Thread.currentThread().setName(oldName);
    }
  }

  protected abstract void execute();//需要子类实现
}

//下面是AsyncCall下的execute()方法
    @Override protected void execute() {
      boolean signalledCallback = false;
      timeout.enter();
      try {
        Response response = getResponseWithInterceptorChain();
        //调用责任链来获得请求(上面已经介绍过了)
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
          //如果被取消,就执行我们传入的responseCallback的onFailure方法
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
          //如果成功,就执行我们传入的responseCallback的onResponse方法
        }
      } catch (IOException e) {
        e = timeoutExit(e);
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          eventListener.callFailed(RealCall.this, e);
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);//移出队列
      }
    }

我们常用的enqueue方法实际调用的同样是RealCall下的enqueue() 方法。这个方法做的其实就是吧请求封装成AsyncCall并加入队列,因为AsyncCall已经间接实现了Runnable的接口,所以这个方法的最终目的是执行AsyncCall线程,在okhttp中会交给线程池处理。

  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    //以上部分的代码,基本和execute()方法一样,可以理解成请求前的准备工作吧,后面再来把这部分坑补上
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
    //创建一个异步线程,直接丢进异步准备队列,具体看下面分析
  }

//下面是Dispatcher里面的enqeue方法
  void enqueue(AsyncCall call) {
    synchronized (this) {
      readyAsyncCalls.add(call);//加入准备队列
    }
    promoteAndExecute();//异步执行,重要方法
  }

不管是execute()还是enqueue()都会调用dispatcher的同名方法。可见dispatcher正如他的类名一样,是okhttp的调度中心
区别就是:
dispatcher的execute()方法加入队列后,方法就结束了
而enqueue()方法只是加入准备队列,把执行交给了promoteAndExecute()去做。

下面看promoteAndExecute()方法:

//顾名思义,把准备队列的请求推到运行队列,并执行
  private boolean promoteAndExecute() {
    assert (!Thread.holdsLock(this));//断言,调试用

    List<AsyncCall> executableCalls = new ArrayList<>();//需要执行的请求队列
    boolean isRunning;//是否在执行的标志

    synchronized (this) {
      for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        AsyncCall asyncCall = i.next();//利用迭代器,在准备队列中取出每个请求

        if (runningAsyncCalls.size() >= maxRequests) break;
          // Max capacity.执行队列已经满了的话,就退出队列
        if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; 
          // Host max capacity. 估计是可同时发送的Host有限制(待研究)

        i.remove();//把请求移出准备队列
        executableCalls.add(asyncCall);//加入需要执行的请求队列(上面创建的那个)
        runningAsyncCalls.add(asyncCall);//加入运行队列
      }
      isRunning = runningCallsCount() > 0;//count大于0,说明正在执行,isRunning就为true
    }

    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);//取出请求
      asyncCall.executeOn(executorService());
      //创建executorService线程池,并传给给RealCall的内部类asyncall 的excuteOn执行
    }

    return isRunning;
  }
	
	//这里是executorService线程池的创建代码
 public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
//同步创建,核心线程为0,最大线程数为Integer.MAX_VALUE,线程空闲存活时间为60s,没有容量的队列
    }
    return executorService;
  }

//这里是AsyncCall的executeOn()方法
    void executeOn(ExecutorService executorService) {
      assert (!Thread.holdsLock(client.dispatcher()));//断言.方便调试程序?(不确定)
      boolean success = false;
      try {
        executorService.execute(this);//这个this就是AsyncCall,可以理解为异步线程
        //异步执行,把请求交给executeService执行,executeService是dispatcher里创建的线程池
        success = true;
      } catch (RejectedExecutionException e) {
        InterruptedIOException ioException = new InterruptedIOException("executor rejected");
        ioException.initCause(e);
        eventListener.callFailed(RealCall.this, ioException);
        responseCallback.onFailure(RealCall.this, ioException);
      } finally {
        if (!success) {
        //将它从队列中移出
          client.dispatcher().finished(this); // This call is no longer running!
        }
      }
    }

总结

okhttp的execute()方法在调用Dispatch的对应方法,将请求加入同步执行队列后,会直接进行网络请求。
而enqueue()方法就较为复杂一点,会创建一个间接实现了Runnable接口的AsyncCall对象(该对象重写了run方法,并把进行网络请求的逻辑写到run方法中),并把AsyncCall对象加入到异步准备队列中,之后在Dispatcher的promoteAndExecute()方法中又会将异步准备队列里的AsyncCall对象取出,添加到异步执行队列中并把AsyncCall对象交给名为executorService的线程池里内执行。

最后,在请求执行完成后,不管是同步和异步请求,都会将自己从对应的队列中移出。

你可能感兴趣的:(Android网络框架,java,http,android,源码)