97视频在线观看网站,日本男人一区二区三区,中日韩三级片网站

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

Android Volley庫源碼簡析（HTTP Request部分）

目源碼的目錄樹：

創(chuàng)新互聯(lián)公司專業(yè)為企業(yè)提供文山州網(wǎng)站建設(shè)、文山州做網(wǎng)站、文山州網(wǎng)站設(shè)計、文山州網(wǎng)站制作等企業(yè)網(wǎng)站建設(shè)、網(wǎng)頁設(shè)計與制作、文山州企業(yè)網(wǎng)站模板建站服務(wù)，10年文山州做網(wǎng)站經(jīng)驗，不只是建網(wǎng)站，更提供有價值的思路和整體網(wǎng)絡(luò)服務(wù)。

 
   
  [Android]   
  ┗━[Volley]   
  ┣━AuthFailureError.java   
  ┣━Cache.java   
  ┣━CacheDispatcher.java   
  ┣━DefaultRetryPolicy.java   
  ┣━ExecutorDelivery.java   
  ┣━InternalUtils.java   
  ┣━Network.java   
  ┣━NetworkDispatcher.java   
  ┣━NetworkError.java   
  ┣━NetworkResponse.java   
  ┣━NoConnectionError.java   
  ┣━ParseError.java   
  ┣━RedirectError.java   
  ┣━Request.java   
  ┣━RequestQueue.java   
  ┣━Response.java   
  ┣━ResponseDelivery.java   
  ┣━RetryPolicy.java   
  ┣━ServerError.java   
  ┣━TimeoutError.java   
  ┣━[toolbox]   
  ┃ ┣━AndroidAuthenticator.java   
  ┃ ┣━Authenticator.java   
  ┃ ┣━BasicNetwork.java   
  ┃ ┣━ByteArrayPool.java   
  ┃ ┣━ClearCacheRequest.java   
  ┃ ┣━DiskBasedCache.java   
  ┃ ┣━httpClientStack.java   
  ┃ ┣━HttpHeaderParser.java   
  ┃ ┣━HttpStack.java   
  ┃ ┣━HurlStack.java   
  ┃ ┣━ImageLoader.java   
  ┃ ┣━ImageRequest.java   
  ┃ ┣━JsonArrayRequest.java   
  ┃ ┣━JsonObjectRequest.java   
  ┃ ┣━JsonRequest.java   
  ┃ ┣━NetworkImageView.java   
  ┃ ┣━NoCache.java   
  ┃ ┣━PoolingByteArrayOutputStream.java   
  ┃ ┣━RequestFuture.java   
  ┃ ┣━StringRequest.java   
  ┃ ┗━Volley.java   
  ┣━VolleyError.java   
  ┗━VolleyLog.java

可以看出，Volley源碼放置得較為雜亂，不同功能模塊的類并沒有歸到不同的包中。相比之下UIL的源碼結(jié)構(gòu)較為規(guī)范和合理。

從常用case入手，推斷其項目架構(gòu)

官網(wǎng)上給出的最簡單的使用例子如下所示：

final TextView mTextView = (TextView) findViewById(R.id.text);

 
   
  // 1. 新建一個Queue   
  RequestQueue queue = Volley.newRequestQueue(this);   
  String url ="http://www.google.com";   
     
  // 2. 新建一個Request，寫好listener   
  StringRequest stringRequest = new StringRequest(Request.Method.GET, url,   
  new Response.Listener() {   
  @Override   
  public void onResponse(String response) {   
  // Display the first 500 characters of the response string.   
  mTextView.setText("Response is: "+ response.substring(0,500));   
  }   
  }, new Response.ErrorListener() {   
  @Override   
  public void onErrorResponse(VolleyError error) {   
  mTextView.setText("That didn't work!");   
  }   
  });   
  // 3. 將Request放到Queue里面執(zhí)行   
  queue.add(stringRequest);   
     
  結(jié)合下面這張圖：   
     
  架構(gòu)圖   
     
  我們可以大致了解Volley的使用方法（見注釋）和內(nèi)部結(jié)構(gòu)。下面就這個usecase展開進(jìn)行源碼級別的簡述。   
  Volley類   
     
  Volley類提供了4個靜態(tài)方法來方便用戶新建Queue。其中：   
     
  public static RequestQueue newRequestQueue(Context context) {   
  return newRequestQueue(context, null);   
  }   
     
  一句最終會調(diào)用：   
     
  // 傳入 context，stack=null，maxDiskCacheBytes=-1   
  public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {   
  File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);   
     
  String userAgent = "volley/0"; //1. 設(shè)置userAgent   
  try {   
  String packageName = context.getPackageName();   
  PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);   
  userAgent = packageName + "/" + info.versionCode;   
  } catch (NameNotFoundException e) {   
  }   
     
  if (stack == null) {   
  if (Build.VERSION.SDK_INT >= 9) { //2. 選擇用哪個httpclient   
  stack = new HurlStack();   
  } else {   
  // Prior to Gingerbread, HttpUrlConnection was unreliable.   
  // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html   
  stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));   
  }   
  }   
     
  Network network = new BasicNetwork(stack);   
     
  RequestQueue queue;   
  if (maxDiskCacheBytes <= -1)   
  {   
  // No maximum size specified   
  queue = new RequestQueue(new DiskBasedCache(cacheDir), network); //3. 新建Queue   
  }   
  else   
  {   
  // Disk cache size specified   
  queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);   
  }   
     
  queue.start();// 4. 傳入Queue   
     
  return queue;   
  }

值得注意的是：

Volley會根據(jù)SDK的version來決定使用java.net.HttpURLConnection（Build.VERSION.SDK_INT >= 9）還是org.apache.http.client.HttpClient

新建Queue后，Queue馬上會被start。

 
   
   stack類負(fù)責(zé)發(fā)送request（com.android.volley.Request）和獲取response（org.apache.http.HttpResponse），network類負(fù)責(zé)分析和處理response，包裝成NetworkResponse（com.android.volley.NetworkResponse）。   
     
  我們首先忽略掉network相關(guān)的細(xì)節(jié)，看一下queue的實現(xiàn)和request的調(diào)度策略。   
  RequestQueue   
     
  先來看一下RequestQueue的構(gòu)造方法：   
     
  public RequestQueue(Cache cache, Network network) {   
  this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);   
  }

調(diào)用：

 
   
  public RequestQueue(Cache cache, Network network, int threadPoolSize) {   
  this(cache, network, threadPoolSize,   
  new ExecutorDelivery(new Handler(Looper.getMainLooper())));   
  }   
     
  這里出現(xiàn)了一個新面孔ExecutorDelivery，根據(jù)字面意思可以猜測它是負(fù)責(zé)將請求的結(jié)果分發(fā)到主線程上，或者在主線程上執(zhí)行回調(diào)（listener）。繼續(xù)調(diào)用：   
     
  public RequestQueue(Cache cache, Network network, int threadPoolSize,   
  ResponseDelivery delivery) {   
  mCache = cache;   
  mNetwork = network;   
  mDispatchers = new NetworkDispatcher[threadPoolSize];   
  mDelivery = delivery;   
  }

這里又出現(xiàn)了一個新面孔NetworkDispatcher。留意到threadPoolSize這個數(shù)組長度參數(shù)的字面意義，結(jié)合上面的Volley架構(gòu)圖，猜想NetworkDispatcher是一個work thread，循環(huán)等待并通過network執(zhí)行在Queue上的request。

RequestQueue被實例化后，便調(diào)用其start()方法：

 
   
  public void start() {   
  stop(); // Make sure any currently running dispatchers are stopped.   
  // Create the cache dispatcher and start it.   
  mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);   
  mCacheDispatcher.start();   
     
  // Create network dispatchers (and corresponding threads) up to the pool size.   
  for (int i = 0; i < mDispatchers.length; i++) {   
  NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,   
  mCache, mDelivery);   
  mDispatchers[i] = networkDispatcher;   
  networkDispatcher.start();   
  }   
  }   
     
  相應(yīng)地有：   
     
  public void stop() {   
  if (mCacheDispatcher != null) {   
  mCacheDispatcher.quit();   
  }   
  for (int i = 0; i < mDispatchers.length; i++) {   
  if (mDispatchers[i] != null) {   
  mDispatchers[i].quit();   
  }   
  }   
  }

這里的邏輯很簡單：

開始之前停止所有舊的任務(wù)（即interrupt所有worker thread）。

啟動一個負(fù)責(zé)cache的worker thread。

啟動n個負(fù)責(zé)network的worker thread。

worker thread開始不斷地等待來自Queue的request。

Request

接下來執(zhí)行queue.add(stringRequest); ，一個request被加入到queue中，代碼如下所示：

 
   
  public  Request add(Request request) {   
  // Tag the request as belonging to this queue and add it to the set of current requests.   
  request.setRequestQueue(this);   
  synchronized (mCurrentRequests) {   
  mCurrentRequests.add(request);   
  }   
     
  // Process requests in the order they are added.   
  request.setSequence(getSequenceNumber());   
  request.addMarker("add-to-queue"); // marker用來指示request當(dāng)前的狀態(tài)，實際上是用來打log   
     
  // If the request is uncacheable, skip the cache queue and go straight to the network.   
  if (!request.shouldCache()) {   
  mNetworkQueue.add(request);   
  return request;   
  }   
     
  // Insert request into stage if there's already a request with the same cache key in flight.   
  synchronized (mWaitingRequests) {   
  String cacheKey = request.getCacheKey();   
  if (mWaitingRequests.containsKey(cacheKey)) {   
  // There is already a request in flight. Queue up.   
  Queue> stagedRequests = mWaitingRequests.get(cacheKey);   
  if (stagedRequests == null) {   
  stagedRequests = new LinkedList>();   
  }   
  stagedRequests.add(request);   
  mWaitingRequests.put(cacheKey, stagedRequests);   
  if (VolleyLog.DEBUG) {   
  VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);   
  }   
  } else {   
  // Insert 'null' queue for this cacheKey, indicating there is now a request in   
  // flight.   
  mWaitingRequests.put(cacheKey, null);   
  mCacheQueue.add(request);   
  }   
  return request;   
  }   
  }

這里的邏輯是：

對新加進(jìn)來的request進(jìn)行一些設(shè)置。

如果不需要cache，那么把request直接加到network queue中。

根據(jù)key檢查request是否正在執(zhí)行。如果是，則將其放入到waiting鏈表中。猜想當(dāng)request完成的時候會調(diào)用某個方法將key在waiting鏈表中刪除，然后依次執(zhí)行waiting的request。如果否，則將其加入cache queue中。

CacheDispatcher

假設(shè)該uri訪問是***次執(zhí)行，那么對應(yīng)的request會被放到cache queue中。cache worker thread（cache dispatcher）發(fā)現(xiàn)cache queue中存在request，會馬上將其dequeue并執(zhí)行。我們來看一下CacheDispatcher的run方法：

 
   
  public class CacheDispatcher extends Thread {   
     
  private final Cache mCache; // 一開始傳入了“new DiskBasedCache(cacheDir)”   
     
  ...   
     
  public void quit() {   
  mQuit = true;   
  interrupt();   
  }   
     
  @Override   
  public void run() {   
  if (DEBUG) VolleyLog.v("start new dispatcher");   
  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);   
     
  // Make a blocking call to initialize the cache.   
  mCache.initialize();   
     
  Request request;   
  while (true) {   
  // release previous request object to avoid leaking request object when mQueue is drained.   
  request = null; //確保***一個request做完后能及時回收內(nèi)存。   
  try {   
  // Take a request from the queue.   
  request = mCacheQueue.take(); // 堵塞   
  } catch (InterruptedException e) {   
  // We may have been interrupted because it was time to quit.   
  if (mQuit) {   
  return; // 退出點   
  }   
  continue;   
  }   
  try {   
  request.addMarker("cache-queue-take");   
     
  // If the request has been canceled, don't bother dispatching it.   
  if (request.isCanceled()) {   
  request.finish("cache-discard-canceled");   
  continue;   
  }   
     
  // miss cache則直接將request放到network queue中   
  Cache.Entry entry = mCache.get(request.getCacheKey());   
  if (entry == null) {   
  request.addMarker("cache-miss");   
  // Cache miss; send off to the network dispatcher.   
  mNetworkQueue.put(request);   
  continue;   
  }   
     
  // cache 過期了，直接將request放到network queue中   
  if (entry.isExpired()) {   
  request.addMarker("cache-hit-expired");   
  request.setCacheEntry(entry);   
  mNetworkQueue.put(request);   
  continue;   
  }   
     
  // 將cache中的data包裝成一個response   
  request.addMarker("cache-hit");   
  Response response = request.parseNetworkResponse(   
  new NetworkResponse(entry.data, entry.responseHeaders));   
  request.addMarker("cache-hit-parsed");   
     
  if (!entry.refreshNeeded()) {   
  // cache不需要刷新，直接將response交給delivery   
  mDelivery.postResponse(request, response);   
  } else {   
  // cache需要刷新?，F(xiàn)將舊的內(nèi)容返回，同時將request放進(jìn)network queue。   
  request.addMarker("cache-hit-refresh-needed");   
  request.setCacheEntry(entry);   
     
  // Mark the response as intermediate.   
  response.intermediate = true;   
     
  // Post the intermediate response back to the user and have   
  // the delivery then forward the request along to the network.   
  final Request finalRequest = request;   
  mDelivery.postResponse(request, response, new Runnable() {   
  @Override   
  public void run() {   
  try {   
  mNetworkQueue.put(finalRequest);   
  } catch (InterruptedException e) {   
  // Not much we can do about this.   
  }   
  }   
  });   
  }   
  } catch (Exception e) {   
  VolleyLog.e(e, "Unhandled exception %s", e.toString());   
  }   
  }   
  }   
  }

接下來看一下mDelivery.postResponse這個方法。

ExecutorDelivery

從上文得知，mDelivery是一個ExecutorDelivery的實例（在新建RequestQueue時傳入）。

ExecutorDelivery的初始化代碼如下所示：

 
   
  public ExecutorDelivery(final Handler handler) {   
  // Make an Executor that just wraps the handler.   
  mResponsePoster = new Executor() { // java.util.concurrent.Executor;   
  @Override   
  public void execute(Runnable command) {   
  handler.post(command);   
  }   
  };   
  }

關(guān)于java.util.concurrent.Executor可以看這篇文章，這里就不展開了。

postResponse代碼如下所示：

 
   
  @Override   
  public void postResponse(Request request, Response response, Runnable runnable) {   
  request.markDelivered(); //標(biāo)記為已分發(fā)   
  request.addMarker("post-response");   
  mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable)); // 在初始化時傳入的handler中執(zhí)行ResponseDeliveryRunnable   
  }   
     
  ResponseDeliveryRunnable是ExecutorDelivery的一個子類，負(fù)責(zé)根據(jù)request的不同結(jié)果調(diào)用對應(yīng)的listener方法：   
     
  @SuppressWarnings("rawtypes")   
  private class ResponseDeliveryRunnable implements Runnable {   
     
  private final Request mRequest;   
  private final Response mResponse;   
  private final Runnable mRunnable;   
     
  public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {   
  mRequest = request;   
  mResponse = response;   
  mRunnable = runnable;   
  }   
     
  @SuppressWarnings("unchecked")   
  @Override   
  public void run() { // 在主線程中執(zhí)行   
  // If this request has canceled, finish it and don't deliver.   
  if (mRequest.isCanceled()) {   
  mRequest.finish("canceled-at-delivery"); // 會調(diào)用 RequestQueue的finish方法   
  return;   
  }   
     
  // Deliver a normal response or error, depending.   
  if (mResponse.isSuccess()) {   
  mRequest.deliverResponse(mResponse.result); //調(diào)用 listener的onResponse(response)   
  } else {   
  mRequest.deliverError(mResponse.error);   
  }   
     
  // If this is an intermediate response, add a marker, otherwise we're done   
  // and the request can be finished.   
  if (mResponse.intermediate) {   
  mRequest.addMarker("intermediate-response");   
  } else {   
  mRequest.finish("done");   
  }   
     
  // If we have been provided a post-delivery runnable, run it.   
  if (mRunnable != null) {   
  mRunnable.run();   
  }   
  }   
  }

接下來我們回頭看看NetworkDispatcher對network queue的處理。

NetworkDispatcher

NetworkDispatcher的源碼如下所示：

 
   
  public class NetworkDispatcher extends Thread {   
     
  private final Network mNetwork; // BasicNetwork實例   
     
  ...   
     
  private final BlockingQueue> mQueue; // network queue   
     
  ...   
     
  public void quit() {   
  mQuit = true;   
  interrupt();   
  }   
     
  @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)   
  private void addTrafficStatsTag(Request request) { // 方便統(tǒng)計Volley的網(wǎng)絡(luò)流量   
  ...   
  }   
     
  @Override   
  public void run() {   
  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);   
  Request request;   
  while (true) {   
  long startTimeMs = SystemClock.elapsedRealtime();   
  // release previous request object to avoid leaking request object when mQueue is drained.   
  request = null;   
  try {   
  //1. 堵塞讀取network queue中的request   
  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 the request was cancelled already, do not perform the   
  // network request.   
  if (request.isCanceled()) {   
  request.finish("network-discard-cancelled");   
  continue;   
  }   
     
  addTrafficStatsTag(request);   
     
  //2. 在network對象中堵塞執(zhí)行request   
  NetworkResponse networkResponse = mNetwork.performRequest(request);   
  request.addMarker("network-http-complete");   
     
  // If the server returned 304 AND we delivered a response already,   
  // we're done -- don't deliver a second identical response.   
  if (networkResponse.notModified && request.hasHadResponseDelivered()) { // 304表示資源未被修改   
  request.finish("not-modified");   
  continue;   
  }   
     
  //3. 將NetworkResponse轉(zhuǎn)成Response   
  Response response = request.parseNetworkResponse(networkResponse);   
  request.addMarker("network-parse-complete");   
     
  // Write to cache if applicable.   
  // TODO: Only update cache metadata instead of entire record for 304s.   
  if (request.shouldCache() && response.cacheEntry != null) {   
  // 4. Response放到cache中   
  mCache.put(request.getCacheKey(), response.cacheEntry);   
  request.addMarker("network-cache-written");   
  }   
     
  //5. 通過Delivery回調(diào)結(jié)果   
  request.markDelivered();   
  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);   
  }   
  }   
  }   
     
  private void parseAndDeliverNetworkError(Request request, VolleyError error) {   
  error = request.parseNetworkError(error);   
  mDelivery.postError(request, error);   
  }   
  }

NetworkDispatcher的處理流程和CacheDispatcher差不多，見注釋。TrafficStats的介紹可以看這里。

上述代碼的關(guān)鍵在于mNetwork.performRequest(request)和request.parseNetworkResponse(networkResponse)這兩個調(diào)用。

 
   
  Network   
     
  Network是一個接口，只有一個performRequest(Request request)方法：   
     
  public interface Network {   
     
  public NetworkResponse performRequest(Request request) throws VolleyError;   
     
  }

本文例子中Network的實現(xiàn)類是BasicNetwork：

 
   
  public class BasicNetwork implements Network {   
  protected static final boolean DEBUG = VolleyLog.DEBUG;   
  private static int SLOW_REQUEST_THRESHOLD_MS = 3000;   
  private static int DEFAULT_POOL_SIZE = 4096;   
  protected final HttpStack mHttpStack;   
  protected final ByteArrayPool mPool;   
     
  public BasicNetwork(HttpStack httpStack) {   
  // If a pool isn't passed in, then build a small default pool that will give us a lot of   
  // benefit and not use too much memory.   
  this(httpStack, new ByteArrayPool(DEFAULT_POOL_SIZE));   
  }   
  ...   
  }   
     
  注意到BasicNetwork的兩個關(guān)鍵的成員：mHttpStack和mPool，和對apache依賴：   
     
  import org.apache.http.Header;   
  import org.apache.http.HttpEntity;   
  import org.apache.http.HttpResponse;   
  import org.apache.http.HttpStatus;   
  import org.apache.http.StatusLine;

可我們先來看一下performRequest()的執(zhí)行流程：

 
   
  public NetworkResponse performRequest(Request request) throws VolleyError {   
  long requestStart = SystemClock.elapsedRealtime();   
  while (true) {   
  // 依賴 org.apache.http.HttpResponse   
  HttpResponse httpResponse = null;   
  byte[] responseContents = null;   
  Map responseHeaders = Collections.emptyMap();   
  try {   
  // 1. 生成header   
  Map headers = new HashMap();   
  addCacheHeaders(headers, request.getCacheEntry());   
  // 2. 通過httpstack發(fā)起請求。注意‘發(fā)起請求’這個動作不在request中進(jìn)行，request只是保存著請求的信息。   
  httpResponse = mHttpStack.performRequest(request, headers);   
  // 3. 獲得請求結(jié)果的一些信息   
  StatusLine statusLine = httpResponse.getStatusLine();   
  int statusCode = statusLine.getStatusCode();   
     
  responseHeaders = convertHeaders(httpResponse.getAllHeaders());   
  // 4. 通過statusCode(304)來判斷是否可以直接使用cache   
  if (statusCode == HttpStatus.SC_NOT_MODIFIED) {   
     
  Entry entry = request.getCacheEntry();   
  if (entry == null) {   
  return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,   
  responseHeaders, true,   
  SystemClock.elapsedRealtime() - requestStart);   
  }   
     
  // 從cache中取出data，返回新的NetworkResponse   
  entry.responseHeaders.putAll(responseHeaders);   
  return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,   
  entry.responseHeaders, true,   
  SystemClock.elapsedRealtime() - requestStart);   
  }   
     
  // 5. 通過statusCode通過判斷是否需要重定向   
  if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {   
  String newUrl = responseHeaders.get("Location");   
  request.setRedirectUrl(newUrl);   
  }   
     
  // 6. 取出reponse中的data，為字節(jié)數(shù)組   
  // Some responses such as 204s do not have content. We must check.   
  if (httpResponse.getEntity() != null) {   
  // 通過entityToBytes從outputstream中讀取數(shù)據(jù)，throws IOException   
  responseContents = entityToBytes(httpResponse.getEntity());   
  } else {   
  // Add 0 byte response as a way of honestly representing a   
  // no-content request.   
  responseContents = new byte[0];   
  }   
     
  // if the request is slow, log it.   
  long requestLifetime = SystemClock.elapsedRealtime() - requestStart;   
  logSlowRequests(requestLifetime, request, responseContents, statusLine);   
     
  if (statusCode < 200 || statusCode > 299) {   
  throw new IOException();   
  }   
  return new NetworkResponse(statusCode, responseContents, responseHeaders, false,   
  SystemClock.elapsedRealtime() - requestStart);   
  } catch (SocketTimeoutException e) {   
  attemptRetryOnException("socket", request, new TimeoutError());   
  } catch (ConnectTimeoutException e) {   
  attemptRetryOnException("connection", request, new TimeoutError());   
  } catch (MalformedURLException e) {   
  throw new RuntimeException("Bad URL " + request.getUrl(), e);   
  } catch (IOException e) {   
  // 7. 如果entityToBytes方法throw了IOException   
  int statusCode = 0;   
  NetworkResponse networkResponse = null;   
  if (httpResponse != null) {   
  statusCode = httpResponse.getStatusLine().getStatusCode();   
  } else {   
  throw new NoConnectionError(e);   
  }   
  if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||   
  statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {   
  VolleyLog.e("Request at %s has been redirected to %s", request.getOriginUrl(), request.getUrl());   
  } else {   
  VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());   
  }   
  // 如果reponseContent有數(shù)據(jù)   
  if (responseContents != null) {   
  networkResponse = new NetworkResponse(statusCode, responseContents,   
  responseHeaders, false, SystemClock.elapsedRealtime() - requestStart);   
  // 那么根據(jù)statusCode執(zhí)行重試   
  if (statusCode == HttpStatus.SC_UNAUTHORIZED ||   
  statusCode == HttpStatus.SC_FORBIDDEN) {   
  attemptRetryOnException("auth",   
  request, new AuthFailureError(networkResponse));   
  } else if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||   
  statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {   
  attemptRetryOnException("redirect",   
  request, new RedirectError(networkResponse));   
  } else {   
  // TODO: Only throw ServerError for 5xx status codes.   
  throw new ServerError(networkResponse);   
  }   
  } else {   
  throw new NetworkError(e);   
  }   
  }   
  }   
  }

attemptRetryOnException()代碼如下所示：

 
   
  private static void attemptRetryOnException(String logPrefix, Request request,   
     
  VolleyError exception) throws VolleyError {   
     
  RetryPolicy retryPolicy = request.getRetryPolicy();   
     
  int oldTimeout = request.getTimeoutMs();

 
   
  try {   
  // 關(guān)鍵語句   
  retryPolicy.retry(exception);   
  } catch (VolleyError e) {   
  request.addMarker(   
  String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));   
  throw e;   
  }   
  request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));   
  }

RetryPolicy是一個接口：

 
   
  public interface RetryPolicy {   
  public int getCurrentTimeout();   
  public int getCurrentRetryCount();   
  public void retry(VolleyError error) throws VolleyError;   
  }

如沒有特殊指定，request中的RetryPolicy為DefaultRetryPolicy，其retry方法實現(xiàn)如下：

 
   
  public void retry(VolleyError error) throws VolleyError {   
  mCurrentRetryCount++;   
  mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);   
  if (!hasAttemptRemaining()) {   
  throw error;   
  }   
  }

如果還沒超出重試次數(shù)上限，那么不會拋出異常，并返回到performRequest()的while循環(huán)中。接下來分析一下BaseNetwork的entityToBytes()方法：

 
   
  private byte[] entityToBytes(HttpEntity entity) throws IOException, ServerError {   
  // 1. 新建PoolingByteArrayOutputStream   
  PoolingByteArrayOutputStream bytes =   
  new PoolingByteArrayOutputStream(mPool, (int) entity.getContentLength());   
  byte[] buffer = null;   
  try {   
  InputStream in = entity.getContent();   
  if (in == null) {   
  throw new ServerError();   
  }

 
   
  // 2. 在字節(jié)池中取出1024字節(jié)buffer   
  buffer = mPool.getBuf(1024);   
  int count;   
  // 3. 從entity的inputStream中讀出數(shù)據(jù)到buffer   
  while ((count = in.read(buffer)) != -1) {   
  // 將buffer寫到PoolingByteArrayOutputStream中   
  bytes.write(buffer, 0, count);   
  }   
  // 4. 將所有數(shù)據(jù)返回   
  return bytes.toByteArray();   
  } finally&n                                                

                                                網(wǎng)站題目：Android Volley庫源碼簡析（HTTP Request部分）                                                

                                                文章轉(zhuǎn)載：http://www.5511xx.com/article/cogegso.html

日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

新聞中心

其他資訊