OkHttp之网络请求流程(一)

澳门新葡亰3522平台游戏 1

在当今这个App泛滥的时代,网络请求几乎是每一个App必不可少的一部分,请求几乎遍布App的每一个界面中。我们进入A界面后,App发起了一系列请求,这时候假如还有一部分请求没有被执行,我们就进入B界面开始新的网络请求,这时候原来A界面的网络请求我们有两个选择:

本篇文章主要介绍OkHttp从发起请求到接收到结果的整个执行流程.
由上篇的概述可知,OkHttp支持同步和异步的请求,这里我们以异步请求为例进行分析

  • 取消A界面的所有未开始执行的网络请求
  • 不取消A界面的所有网络请求,但是B界面的请求要优先于A界面的请求执行,B界面的网络请求执行完毕后再去执行A界面未执行完毕的请求。

一,异步OkHttp请求示例

private void testOkHttp() throws IOException {
        final OkHttpClient client = new OkHttpClient();
        final Request request = new Request.Builder().url("https://www.google.com.hk").build();

        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {

            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                    Log.i(TAG,response.toString());
                    Log.i(TAG,response.body().string());
            }
        });
    }

上面的代码就实现了一个网络请求.
创建一个OkHttpClient对象,他包含了分发器,连接池,拦截器等等内容.
接下来创建一个请求对象,通过OkHttpClient的newCall()方法对其包装,然后添加请求队列,然后回调结果

Tip
对于OkHttpClient封装一个单实例,让所有的Http请求都重用它,
OkHttp将会有更好的性能.因为每一个OkHttpClient实例都持有自己的连接池,线程池等,重用连接池和线程池能够减少网络访问延迟以及节省内存,减少资源的浪费

下面我们就详细的分析一下OkHttp详细的网络访问流程

对于第一种情况,我们很好做到,在Activity的onDestroy回调中取消该界面中所有请求,这里需要明确一点,本篇文章的网络层是OKHttp,既然选择了OkHttp,如果要在onDestroy中取消未开始执行以及已经开始执行的网络请求,就必须给每一个请求设置一个tag,然后通过该tag来需要网络请求。比较明智的做法是以该Activity的上下文的hash值作为tag。取消请求时将hash值传入,则该界面所有的请求都可以取消。

二,OkHttp详访流程

1,创建HttpClient对象.

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

  OkHttpClient(Builder builder) {
    this.dispatcher = builder.dispatcher;
    this.proxy = builder.proxy;
    this.protocols = builder.protocols;
    this.connectionSpecs = builder.connectionSpecs;
    this.interceptors = Util.immutableList(builder.interceptors);
    this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
    this.proxySelector = builder.proxySelector;
    this.cookieJar = builder.cookieJar;
    this.cache = builder.cache;
    this.internalCache = builder.internalCache;
    this.socketFactory = builder.socketFactory;

    ... ...
    this.proxyAuthenticator = builder.proxyAuthenticator;
    this.authenticator = builder.authenticator;
    this.connectionPool = builder.connectionPool;
    this.dns = builder.dns;
    this.followSslRedirects = builder.followSslRedirects;
    this.followRedirects = builder.followRedirects;
    this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
    this.connectTimeout = builder.connectTimeout;
    this.readTimeout = builder.readTimeout;
    this.writeTimeout = builder.writeTimeout;
    this.pingInterval = builder.pingInterval;
  }

由上面可知HttpClient创建的时候,初始化了连接池,线程池,默认拦截器等等,为接下来的网络请求铺垫

2,创建Request对象

Request request = new Request.Builder().url("https://www.google.com.hk").build();

通过Request中的Builder构建一个请求对象
这个Request对象我们可以理解成一个请求Bean,里面封装了请求的url,
请求方法(post get put delete等),请求头,请求体,以及tag(用于批量取消)

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

接下来继续对Request对象进行包装,使其能够执行execute,入队enqueue,
取消cancel, 判断状态 isCancel和isExecuted
上面的call指向的是RealCall对象
我们看下Call接口

public interface Call extends Cloneable {
  Request request();
  Response execute() throws IOException;
  void enqueue(Callback responseCallback);
  void cancel();
  boolean isExecuted();
  boolean isCanceled();
  Call clone();
  interface Factory {
    Call newCall(Request request);
  }
}

3,将请求入队

@Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

OkHttpClient的dispatcher()方法返回的是一个Dispatcher对象,每个Dispatcher使用线程池来运行上面的Call任务.

接下来我们看下Dispacher的入队操作

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

runningAsyncCalls存放所有正在执行的异步任务
readyAsyncCalls存放所有正在等待执行的异步任务
当正在执行的请求小于最大请求数64且每个主机的最大请求数不超过5
则直接加入到正在执行的异步队列中且执行.
否则加入到正在等待执行的异步队列中等待执行.

**由上我们可知
请求相同主机的最大请求数目是5
所有请求最大数目是64
实际开发中,用户量一般的app服务器只有一个,那么一般最大的请求就是5
**
好了,一个请求封装准备了这么多, 顺利入队,下面我们看看他下面是怎么执行的

4,执行
RealCall封装了原始的Request,在RealCall中有一个非静态内部类AsyncCall,AsyncCall中的execute方法就是任务要执行的代码

final class AsyncCall extends NamedRunnable {
   ... ...
   ... ...
    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

通过getResponseWithInterceptorChain方法
获取到Response对象,下面我们看下他的拦截链

Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    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);
    return chain.proceed(originalRequest);
  }

RealInterceptorChain.java
public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      Connection connection) throws IOException {
   ... ...
    //取出下一个拦截器,递归调用
    RealInterceptorChain next = new RealInterceptorChain(
        interceptors, streamAllocation, httpCodec, connection, index + 1, request);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);
  ... ...
    return response;
  }

1)首先添加用户自定义的拦截器(如果有),接着依次添加重试拦截器,桥接拦截器,缓存拦截器,连接拦截器以及访问服务器的拦截器.
这些拦截器的添加顺序是固定的,不能改变
2)这些拦截器形成一个拦截链,每个拦截器专司其自己的职责,
将处理好的请求交给下一个拦截器,最后一个拦截器处理完毕后,再将其交给上一个拦截器,直到第一个,
最后将结果返回.这样一个责任链就形成了
3)每个拦截器都实现Interceptor接口

public interface Interceptor {
  Response intercept(Chain chain) throws IOException;

  interface Chain {
    Request request();

    Response proceed(Request request) throws IOException;

    Connection connection();
  }
}

4)对于拦截器之间的调用过程可能不太容易理解,下面针对2)给出一个示意图
Req: 请求Request缩写
Res: 响应Response缩写

澳门新葡亰3522平台游戏 1

基本流程图.png

5,结果回调
我们再将目光回到AsyncCall类

    @Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }
  }

当通过getResponseWithInterceptorChain()一系列的处理得到结果后.
1),会首先判断结果是否取消, 如果取消则回调传入的回调onFail中
否则,回调结果到onResponse中
2),接下来是扫尾操作
调用Dispatcher的finish方法

void finished(AsyncCall call) {
    finished(runningAsyncCalls, call, true);
  }

  private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
    int runningCallsCount;
    Runnable idleCallback;
    synchronized (this) {
      if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

    if (runningCallsCount == 0 && idleCallback != null) {
      idleCallback.run();
    }
  }

它主要做了两件事儿
A,将刚才已经完成的任务从runningAsyncCalls移除
B,如果runningAsyncCall小于5(每个主机的最大访问数量),
则从readyAsyncCalls移除添加到runningAsyncCalls中,并且执行

至此一个完整的OkHttp异步请求完毕
总的来说: 就是根据请求的url, 请求方法, 请求体构造一个Request的Bean,
然后将Request封装成一个RealCall,RealCall实现了Call接口,他有对执行逻辑的操作(取消,执行,判断执行的状态等),
接下来通过全局的OkHttpClient(拥有线程池,连接池,分发器等资源),利用分发器Dispatcher加入到执行队列或者等待队列中.
然后线程池执行RealCall的非静态内部类AsyncCall的execute方法,
然后通过getResponseWithInterceptorChain来进行一系列的拦截器操作处理,回调请求结果.
最后进行扫尾操作,移除正在执行队列的当前请求,将等待队列的请求添加到执行队列.

OkHttp的处理核心是在拦截器,每个拦截器都有自己的职责,下一篇文章详细分析各个拦截器具体都干了什么
OkHttp之拦截器(二)

但是实际情况并非如此,有一部分网络请求我们不想取消它,仍然想要进行请求,因为这部分的请求比较重要,需要拉到客户端进行使用,取消这个请求可能会带来不必要的麻烦,因此,我们需要保留这些请求。但是我们进入了一个新的界面,新界面的网络优先级比较高,应该先被执行,这就是第二种情况。

每种情况有对应的解决方法,第一种情况显得比较简单,我们先来实现它。

public class MainActivity extends AppCompatActivity implements View.OnClickListener {
    private Button btn1;
    private Button btn2;
    private OkHttpClient mOkHttpClient;
    @Override

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn1 = (Button) findViewById(R.id.btn1);
        btn2 = (Button) findViewById(R.id.btn2);
        btn1.setOnClickListener(this);
        btn2.setOnClickListener(this);
        mOkHttpClient = new OkHttpClient();
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.e("TAG", "onDestroy");
        cancelByTag(this.hashCode());
    }
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
            case R.id.btn1:
                sendRequest();
                break;
            case R.id.btn2:
                startActivity(new Intent(this, SecondActivity.class));
                finish();
                break;
        }
    }

    private void sendRequest() {
        Request.Builder builder = new Request.Builder();

 builder.url("https://www.baidu.com").tag(this.hashCode());

        Request request1 = builder.build();
        Request request2 = builder.build();
        Request request3 = builder.build();
        Request request4 = builder.build();
        Request request5 = builder.build();
        Request request6 = builder.build();
        Request request7 = builder.build();
        Request request8 = builder.build();
        Request request9 = builder.build();
        Request request10 = builder.build();

        final Call call1 = mOkHttpClient.newCall(request1);
        final Call call2 = mOkHttpClient.newCall(request2);
        final Call call3 = mOkHttpClient.newCall(request3);
        final Call call4 = mOkHttpClient.newCall(request4);
        final Call call5 = mOkHttpClient.newCall(request5);
        final Call call6 = mOkHttpClient.newCall(request6);
        final Call call7 = mOkHttpClient.newCall(request7);
        final Call call8 = mOkHttpClient.newCall(request8);
        final Call call9 = mOkHttpClient.newCall(request9);
        final Call call10 = mOkHttpClient.newCall(request10);

        final Callback callback = new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e("TAG", "failure. isCanceled:" + call.isCanceled() + " isExecuted:" + call.isExecuted());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                Log.e("TAG", "success. isCanceled:" + call.isCanceled() + " isExecuted:" + call.isExecuted());
            }
        };

        call1.enqueue(callback);
        call2.enqueue(callback);
        call3.enqueue(callback);
        call4.enqueue(callback);
        call5.enqueue(callback);
        call6.enqueue(callback);
        call7.enqueue(callback);
        call8.enqueue(callback);
        call9.enqueue(callback);
        call10.enqueue(callback);

    }

    public void cancelByTag(Object tag) {
        for (Call call : mOkHttpClient.dispatcher().queuedCalls()) {
            if (tag.equals(call.request().tag())) {
                call.cancel();
            }
        }

        for (Call call : mOkHttpClient.dispatcher().runningCalls()) {
            if (tag.equals(call.request().tag())) {
                call.cancel();
            }
        }
    }
}

当我们点击发送请求的按钮之后,所有请求都被设置了一个tag后发送出去,然后我们需要快速的点击跳转按钮,让当前页面finish掉,之后就会回调onDestroy方法,onDestyoy方法中我们调用了取消请求的方法,如果还有请求没有开始执行,该请求就会被取消掉。这样,第一种情况就简单的实现了下。

在实现第二种情况的时候,我们需要知道一个概念,就是一个集合中如何对元素进行排序,通常,有两种做法。

  • 澳门新葡亰3522平台游戏,将待比较的类实现Comparable接口,调用Collections.sort(list)方法进行排序
  • 新建一个类实现Comparator接口,调用Collections.sort(list,comparator)方法进行排序

假如现在我们有一个类叫Person,它有两个属性,name和age,我们有一个List,里面都是Person,我们希望对这个List进行排序,并且排序的原则是根据age从小到大排序。按照实现Comparable接口的方法,我们需要将Person实现该接口,就像这样子。

public class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '/'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Person another) {
        return this.age-another.age;
    }
}

这时候我们生成一个都是Person实例的List,调用sort方法进行排序看下结果如何

Person p1=new Person("张三",23);
Person p2=new Person("李四",12);
Person p3=new Person("王五",21);
Person p4=new Person("赵六",8);
Person p5=new Person("钱七",40);
List<Person> persons = Arrays.asList(p1, p2, p3, p4, p5);
System.out.println(persons);
Collections.sort(persons);
System.out.println(persons);

输出结果如下

[Person{name=’张三’, age=23}, Person{name=’李四’, age=12},
Person{name=’王五’, age=21}, Person{name=’赵六’, age=8},
Person{name=’钱七’, age=40}][Person{name=’赵六’, age=8},
Person{name=’李四’, age=12}, Person{name=’王五’, age=21},
Person{name=’张三’, age=23}, Person{name=’钱七’, age=40}]

可以看到按age进行排序,并且从小到大的排了顺序,那么如果要从大到小排序呢,很简单,修改compareTo方法即可

@Override
public int compareTo(Person another) {
    return another.age-this.age;
}

如果实现Comparator接口,那么我们无需改动Person类,最原始的Person类如下

public class Person{
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '/'' +
                ", age=" + age +
                '}';
    }
}

取而代之的方法便是新建一个类实现Comparator接口