<p>众所周知，Volley是google在2013年开源的一款异步异步异步http网络请求库，采用Volley进行网络请求非常简单。那么怎样个异步法？最简单的解释就是：</p>    <p>使用Volley你不用再像原生的HttpUrlConnection一样new Thread(new runable());新开工作线程这些事Volley都帮你做了。</p>    <p>Volley为http请求提供了如下的保障：</p>    <ol>     <li>response缓存。Volley内部维护了一个cache，用来对网络请求的结果进行缓存，再次发起该请求时会首先访问cache，当请求内容和上次相同时会直接从cache返回数据，避免重复的网络请求。</li>     <li>request请求队列，Volley会将通过request.add()方法添加的request放置在请求队列，并从该队列中逐一取出请求进行请求。并支持请求优先级的设置。</li>     <li>response分发。Volley采用异步的请求方式，请求成功并获得返回值时会在工作线程中对结果进行解析，并将response分发到主线程，意味着在Volley的回调方法中，代码直接运行在主线程，方便了UI更新等操作。这一点和okHttp有很大区别，okHttp异步方式的回调仍然运行在工作线程。这样不同的实现也各有各的好处。</li>     <li>支持request的自定义，Volley原生request包括了JsonRequest、JsonArrayReuqest、ImageRequest和StringResquest四种，分别用于json对象、json数组以及字符串类型的返回值请求，除此以外，Volley允许继承Request类实现自己的请求，比如你可以实现返回一个JavaBean的请求。</li>    </ol>    <p>Volley适合频繁但数据量不大的网络请求，例如常见API调用，并不适合大文件的下载。Volley将整个response加载到内存并进行操作（可以是解析等操作）大文件可能会引起OOM</p>    <p><a href="/misc/goto?guid=4959739463053640074" rel="nofollow,noindex">官网对Volley的介绍</a></p>    <h2>Volley简单使用</h2>    <p>最简单Volley的使用包括三个步骤：</p>    <ol>     <li>创建RequestQueue</li>     <li>创建Request</li>     <li> <p>将Request添加到RequestQueue</p> <pre>  <code class="language-java">RequestQueue requestQueue = Volley.newRequestQueue(context);  StringRequest stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {      @Override      public void onResponse(String response) {       //这里可以更新UI      }          }, new Response.ErrorListener() {      @Override      public void onErrorResponse(VolleyError error) {        }  });  requestQueue.add(stringRequest);</code></pre> </li>    </ol>    <p>本文的重点是分析Volley的工作流程，各种请求的具体使用可以参考以下链接：</p>    <h2>Volley原理解析</h2>    <p>先来一张Volley工作流程图镇楼：</p>    <p style="text-align:center"><img src="https://simg.open-open.com/show/4a8d12811ffd5fe806e3cf35a19ec58e.png"></p>    <p>Volley中包括以下几种线程：</p>    <ul>     <li>缓冲读取线程(cacheDispatcher)——用于从缓冲中获取数据(继承自Thread)</li>     <li>网络请求线程(networkDispatcher)——用于发送网络请求来获取数据(继承自Thread)</li>     <li>response分发线程(mResponsePoster)——用于将请求结果(可能来自cache和网络)分发到主线程(Executor对象)</li>    </ul>    <h3>1.RequestQueue的创建</h3>    <p>既然使用Volley首先创建的是RequestQueue对象，那我们就从Volley.newRequestQueue(context)方法开始。该静态方法通过调用重载的静态方法，内部调用构造方法创建一个requestQueue对象：</p>    <pre>  <code class="language-java">public static RequestQueue newRequestQueue(Context context, HttpStack stack) {          //创建缓存      File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);        String userAgent = "volley/0";      try {          String packageName = context.getPackageName();          PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);          userAgent = packageName + "/" + info.versionCode;      } catch (NameNotFoundException e) {      }        if (stack == null) {          //API9及以上则使用HttpUrlConnection          if (Build.VERSION.SDK_INT >= 9) {              stack = new HurlStack();          } else {              //小于9则使用HttpClient              // Prior to Gingerbread, HttpUrlConnection was unreliable.              stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));          }      }      //用于后面的网络请求      Network network = new BasicNetwork(stack);      //根据设置的缓存目录创建请求队列      RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);      //启动请求队列      queue.start();      return queue;  }</code></pre>    <p>从上面的代码可以发现，Volley内部是采用HttpUrlConnection或者HttpClient进行网络请求的(HttpClient已经废弃不再维护)。</p>    <p>我们重点关注一下这一行代码：</p>    <pre>  <code class="language-java">RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);</code></pre>    <p>以上代码创建了一个新的请求队列。并传入DiskBasedCache(cacheDir)来根据相应目录初始化缓存。</p>    <p>跟踪上述构造方法，发现调用了另一个三个参数的构造方法：</p>    <pre>  <code class="language-java">public RequestQueue(Cache cache, Network network) {      //调用三个参数的构造方法      this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);  }</code></pre>    <p>DEFAULT_NETWORK_THREAD_POOL_SIZE是声明的常量=4，所以我们知道Volley的网络请求线程数量默认为4个。上述构造方法调用了四个参数的构造方法：</p>    <pre>  <code class="language-java">public RequestQueue(Cache cache, Network network, int threadPoolSize) {      //调用四个参数对的构造方法      this(cache, network, threadPoolSize,              new ExecutorDelivery(new Handler(Looper.getMainLooper())));  }</code></pre>    <p>注意以上方法的最后一个参数，这是一个绑定了主线程handler的ExecutorDelivery对象，用处在后文进行说明</p>    <p>四个参数的构造方法的实现：</p>    <pre>  <code class="language-java">public RequestQueue(Cache cache, Network network, int threadPoolSize,          ResponseDelivery delivery) {      mCache = cache;      mNetwork = network;      mDispatchers = new NetworkDispatcher[threadPoolSize];      mDelivery = delivery;  }</code></pre>    <p>这样requestqueue就创建完成，</p>    <h3>2.网络请求的执行</h3>    <p>创建的requestqueue.queue.start()方法在创建的最后一行得到了调用。</p>    <p>queue.start()的具体实现：</p>    <pre>  <code class="language-java">public void start() {      stop();  // 确保现有的dispatcher停止工作      // 创建cacheDispatcher并启动      mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);      mCacheDispatcher.start();        //根据线程池(mDispatchers)的大小创建网络请求线程。      for (int i = 0; i < mDispatchers.length; i++) {          NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,mCache, mDelivery);          mDispatchers[i] = networkDispatcher;          //按创建顺序启动对应的线程          networkDispatcher.start();      }  }</code></pre>    <p>正如代码的注释一样，先创建并启动缓存线程用来读取缓存内容，再创建网络请求线程用于网络请求。mDispatchers为线程数组，默认大小为4，networkDispatcher网络请求执行线程。</p>    <p>我们重点分析一下网络请求线程的创建：</p>    <pre>  <code class="language-java">NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,mCache, mDelivery);</code></pre>    <p>我们着重关注一下mDelivery对象，它是一个绑定了主线程handler的ExecutorDelivery对象</p>    <p>由于NetworkDispatcher本身是一个线程，调用start()方式实际会执行它的run()方法，我们来到run()方法内部：</p>    <pre>  <code class="language-java">@Override  public void run() {      Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);      while (true) {          long startTimeMs = SystemClock.elapsedRealtime();          Request<?> request;          try {                 //从请求队列中取出网络请求              request = mQueue.take();          } catch (InterruptedException e) {              // We may have been interrupted because it was time to quit.              if (mQuit) {                  return;              }              continue;          }            try {              request.addMarker("network-queue-take");              //判断请求是否取消，取消则不执行该请求              if (request.isCanceled()) {                  request.finish("network-discard-cancelled");                  continue;              }                addTrafficStatsTag(request);                // 发送网络请求              NetworkResponse networkResponse = mNetwork.performRequest(request);              ...               // 在子线程解析返回结果              Response<?> response = request.parseNetworkResponse(networkResponse);                 ...              省略的代码用于请求成功的结果进行缓存              ...              //将请求的结果发送出去              mDelivery.postResponse(request, response);          } catch (VolleyError volleyError) {              volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);              parseAndDeliverNetworkError(request, volleyError);          } catch (Exception e) {              VolleyLog.e(e, "Unhandled exception %s", e.toString());              VolleyError volleyError = new VolleyError(e);              volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);              mDelivery.postError(request, volleyError);          }      }  }</code></pre>    <p>代码比较多，由于主要研究网络请求部分，上述代码的请求结果缓存部分我进行了省略，你可以自行查看源码。</p>    <p>上述代码的核心在于以下三个方法：</p>    <pre>  <code class="language-java">mNetwork.performRequest()  Response<?> response = request.parseNetworkResponse()  mDelivery.postResponse(request, response);</code></pre>    <p>避免代码过多我就不贴源代码了，作用：</p>    <ul>     <li>mNetwork.performRequest()——最终调用HurlStack().performRequest()方法采用httpUrlConnection的方式进行网络请求。</li>     <li>request.parseNetworkResponse()——根据parseNetworkResponse()的具体逻辑实现在子线程对结果进行解析( 这也是自定义Request需要实现的方法之一，比如需要返回javaBean就需要该方法中进行解析 )</li>     <li>mDelivery.postResponse(request, response)——将解析结果分发到 <strong>主线程</strong></li>    </ul>    <h3>3.Response的分发</h3>    <p>最后我们来看看Response的分发。</p>    <p>mDelivery是一个ExecutorDelivery对象，内部存在一个成员对象叫做mResponsePoster(为Executor类型)，最终调用这个mResponsePoster.execute()方法对response进行分发。</p>    <p>具体过程如下：</p>    <p>mDelivery.postResponse(request, response)方法怎么把结果分发到主线程：</p>    <p>该方法实现如下，调用了重载的postResponse(request, response, null)方法：</p>    <pre>  <code class="language-java">public void postResponse(Request<?> request, Response<?> response) {      postResponse(request, response, null);  }</code></pre>    <p>源码如下：</p>    <pre>  <code class="language-java">public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {      request.markDelivered();      request.addMarker("post-response");      //执行分发      mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));  }</code></pre>    <p>mResponsePoster也是一个Executor对象，通过execute()方法来执行Runnable对象的run()方法：它的execute()方法实现如下：</p>    <pre>  <code class="language-java">public ExecutorDelivery(final Handler handler) {      // 采用handler.post()方法将runnable对象运行在主线程      mResponsePoster = new Executor() {          @Override          public void execute(Runnable command) {              handler.post(command);          }      };  }</code></pre>    <p>可以看到这里使用了handler.post()来使得runnable对象运行在与该handler所绑定的线程中</p>    <p>那么这个handler是在哪里赋值的呢？</p>    <p>往上翻，那就是在前文中两次注明的mDelivery对象，它是一个绑定了主线程handler的ExecutorDelivery对象，所以这里的handler是和主线程绑定的，在分发response的时候，我们的回调方法最终会运行在主线程。</p>    <p>ResponseDeliveryRunnable类的run()方法部分代码实现如下：</p>    <pre>  <code class="language-java">// 分发请求结果或者错误消息  if (mResponse.isSuccess()) {      mRequest.deliverResponse(mResponse.result);  } else {      mRequest.deliverError(mResponse.error);  }</code></pre>    <p>deliverResponse(mResponse.result)也是在自定义Request的时候可以覆盖的方法。在Volley自带的StringRequest类中，该方法实现如下：</p>    <pre>  <code class="language-java">@Override  protected void deliverResponse(String response) {      mListener.onResponse(response);  }</code></pre>    <p>这里就调用了我们在使用Volley创建StringRequest对象时设置的监听器的onResponse(reponse)方法。然后就可以在改方法中更新UI了。</p>    <h2>Volley用到线程池了吗？</h2>    <p>直观地看来，Volley是没有用到线程池的，它采用的是一个默认长度为4的线程数组(名为mDispatcher)，在具体的网络请求线程(networkDispatcher)的run()方法中，Volley采用了如下的结构：</p>    <pre>  <code class="language-java">public void run(){      while(true){      //从请求队列中取出请求      requestQueue.take();      ...      }  }</code></pre>    <p>这个死循环使得run()方法永远不会结束，对应的线程也就不会被销毁，而当requestQueue.take()没有获取到请求的时候(即请求队列已空)，该线程就会被阻塞而暂时停止运行。有新的请求的时候又得到运行进而发送新的网络请求。</p>    <p>可以发现，Volley没有使用线程池来管理网络请求线程，而是采用死循环的方式来避免了不断地创建、销毁线程带来的开销，达到了和线程池同样的效果。</p>    <h2>最后</h2>    <p>这里只是简单梳理了一遍Volley的网络请求流程，对缓存部分没有作过多的讲解，若想了解更多，还请读者自行查看源码。</p>    <p> </p>    <p>来自：http://www.distancelin.cn/2017/02/28/你想知道的volley使用及原理/</p>    <p> </p>