本博文為子墨原創，轉載請注明出處！ http://blog.csdn.net/zimo2013/article/details/16971253

由于部落客的水準有限，如有誤，請您幫助指正，共同學習，共同進步！供初學者更好的了解和管理Volley！ (1).Android_開源架構_Volley(Google IO 2013)源代碼及内部實作分析

(2). Android_開源架構_Volley執行個體

1.Volley概述

在項目開發過程中，部落客曾寫過大量的通路網絡重複代碼，特别是ListView adapter很難避免getView()方法不被重複調用，如果ImageView不利用緩存機制，那麼網絡的負荷就會更大！曾将通路網絡代碼和緩存封裝起來使用，但是中間仍存在不少瑕疵！今年的Google I/O 2013上，Volley釋出了！Volley是Android平台上的網絡通信庫，能使網絡通信更快，更簡單，更健壯

Android_開源架構_Volley(Google IO 2013)源代碼及内部實作分析 1.Volley概述2.Volley源碼分析3.總結
Volley特别适合資料量不大但是通信頻繁的場景，現在android提供的源碼已經包含Volley，以後在項目中，可以根據需求引入Volley jar檔案！

2.Volley源碼分析

(1).Volley.java

Volley.newRequestQueue()方法在一個app最好執行一次，可以使用單例設計模式或者在application完成初始化，具體原因請檢視代碼分析

/**
 * @author zimo2013
 * @see http://blog.csdn.net/zimo2013
 */
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) {
        if (Build.VERSION.SDK_INT >= 9) {
            stack = new HurlStack();
        } else {
            stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
        }
    }

    Network network = new BasicNetwork(stack);

    //cacheDir 緩存路徑 /data/data/<pkg name>/cache/<name>
    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
    queue.start();
    /*
     * 執行個體化一個RequestQueue，其中start()主要完成相關工作線程的開啟，
     * 比如開啟緩存線程CacheDispatcher先完成緩存檔案的掃描， 還包括開啟多個NetworkDispatcher通路網絡線程，
     * 該多個網絡線程将從 同一個 網絡阻塞隊列中讀取消息
     * 
     * 此處可見，start()已經開啟，所有我們不用手動的去調用該方法，在start()方法中如果存在工作線程應該首先終止，并重新執行個體化工作線程并開啟
     * 在通路網絡很頻繁，而又重複調用start()，勢必會導緻性能的消耗；但是如果在通路網絡很少時，調用stop()方法，停止多個線程，然後調用start(),反而又可以提高性能，具體可折中選擇
     */

    return queue;
}

(2).RequestQueue.java

/**
 * RequestQueue類存在2個非常重要的PriorityBlockingQueue類型的成員字段mCacheQueue mNetworkQueue ，該PriorityBlockingQueue為java1.5并發庫提供的新類
 * 其中有幾個重要的方法，比如take()為從隊列中取得對象，如果隊列不存在對象，将會被阻塞，直到隊列中存在有對象，類似于Looper.loop()
 * 
 * 執行個體化一個request對象，調用RequestQueue.add(request),該request如果不允許被緩存，将會被添加至mNetworkQueue隊列中，待多個NetworkDispatcher線程take()取出對象
 * 如果該request可以被緩存，該request将會被添加至mCacheQueue隊列中，待mCacheDispatcher線程從mCacheQueue.take()取出對象，
 * 如果該request在mCache中不存在比對的緩存時，該request将會被移交添加至mNetworkQueue隊列中，待網絡通路完成後，将關鍵頭資訊添加至mCache緩存中去！
 * 
 * @author zimo2013
 * @see http://blog.csdn.net/zimo2013
 */
public void start() {
    stop();
    
    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();
    }
}

(3).CacheDispatcher.java

/**
 * @author zimo2013
 * @see http://blog.csdn.net/zimo2013
 */
@Override
public void run() {
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

    //緩存初始化，會周遊整個緩存檔案夾
    mCache.initialize();
    {
    	//執行代碼
    	/*if (!mRootDirectory.exists()) {
            if (!mRootDirectory.mkdirs()) {
                VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
            }
            return;
        }

        File[] files = mRootDirectory.listFiles();
        if (files == null) {
            return;
        }
        for (File file : files) {
            FileInputStream fis = null;
            try {
                fis = new FileInputStream(file);
                CacheHeader entry = CacheHeader.readHeader(fis);
                entry.size = file.length();
                putEntry(entry.key, entry);
            } catch (IOException e) {
                if (file != null) {
                   file.delete();
                }
            } finally {
                try {
                    if (fis != null) {
                        fis.close();
                    }
                } catch (IOException ignored) { }
            }
        }*/
    }

    while (true) {
        try {
        	//該方法可能會被阻塞
            final Request request = mCacheQueue.take();

            Cache.Entry entry = mCache.get(request.getCacheKey());
            if (entry == null) {
            	//緩存不存在，則将該request添加至網絡隊列中
                mNetworkQueue.put(request);
                continue;
            }

            //是否已經過期
            if (entry.isExpired()) {
                request.setCacheEntry(entry);
                mNetworkQueue.put(request);
                continue;
            }

            Response<?> response = request.parseNetworkResponse(
                    new NetworkResponse(entry.data, entry.responseHeaders));

            //存在緩存，執行相關操作

        } catch (InterruptedException e) {
        }
    }
}

(4).NetworkDispatcher.java

/**
 * @author zimo2013
 * @see http://blog.csdn.net/zimo2013
 */
@Override
public void run() {
    Request request;
    while (true) {
        try {
        	//可能會被
            request = mQueue.take();
        } catch (InterruptedException e) {
            // We may have been interrupted because it was time to quit.
            if (mQuit) {
                return;
            }
            continue;
        }

        try {
        	
        	//通路網絡，得到資料
            NetworkResponse networkResponse = mNetwork.performRequest(request);

            if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                request.finish("not-modified");
                continue;
            }

            // Parse the response here on the worker thread.
            Response<?> response = request.parseNetworkResponse(networkResponse);

            // 寫入緩存
            if (request.shouldCache() && response.cacheEntry != null) {
                mCache.put(request.getCacheKey(), response.cacheEntry);
                request.addMarker("network-cache-written");
            }

            // Post the response back.
            request.markDelivered();
            mDelivery.postResponse(request, response);
        } catch (VolleyError volleyError) {
            parseAndDeliverNetworkError(request, volleyError);
        } catch (Exception e) {
            VolleyLog.e(e, "Unhandled exception %s", e.toString());
            mDelivery.postError(request, new VolleyError(e));
        }
    }
}

(5).StringRequest.java

其中在parseNetworkResponse()中，完成将byte[]到String的轉化,可能會出現字元亂碼，HttpHeaderParser.parseCharset(response.headers)方法在尚未指定是傳回為ISO-8859-1，可以修改為utf-8

public class StringRequest extends Request<String> {
    private final Listener<String> mListener;

    /**
     * Creates a new request with the given method.
     *
     * @param method the request {@link Method} to use
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public StringRequest(int method, String url, Listener<String> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }

    @Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }

    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {
        String parsed;
        try {
        	//将data位元組資料轉化為String對象
            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        //傳回Response對象，其中該對象包含通路相關資料
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }
}

(6).ImageLoader.java

/**
 * @author zimo2013
 * @see http://blog.csdn.net/zimo2013
 */
public ImageContainer get(String requestUrl, ImageListener imageListener,
        int maxWidth, int maxHeight) {
    throwIfNotOnMainThread();
    final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);

    //從mCache得到bitmap對象，是以可以覆寫ImageCache，完成圖檔的三級緩存，即在原有的LruCache添加一個軟引用緩存
    Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
    if (cachedBitmap != null) {
    	//得到緩存對象
        ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
        imageListener.onResponse(container, true);
        return container;
    }

    ImageContainer imageContainer =
            new ImageContainer(null, requestUrl, cacheKey, imageListener);

    // 首先更新該view，其指定了defaultImage
    imageListener.onResponse(imageContainer, true);

    // 根據可以去檢查該請求是否已經發起過
    BatchedImageRequest request = mInFlightRequests.get(cacheKey);
    if (request != null) {
        request.addContainer(imageContainer);
        return imageContainer;
    }

    Request<?> newRequest =
        new ImageRequest(requestUrl, new Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
            	//如果請求成功
                onGetImageSuccess(cacheKey, response);
            }
        }, maxWidth, maxHeight,
        Config.RGB_565, new ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                onGetImageError(cacheKey, error);
            }
        });
    //添加至請求隊列中
    mRequestQueue.add(newRequest);
    //同一添加進map集合，以友善檢查該request是否正在請求網絡，可以節約資源
    mInFlightRequests.put(cacheKey, new BatchedImageRequest(newRequest, imageContainer));
    return imageContainer;
}

private void onGetImageSuccess(String cacheKey, Bitmap response) {
	//緩存對象
    mCache.putBitmap(cacheKey, response);

    // 請求完成，不需要檢測
    BatchedImageRequest request = mInFlightRequests.remove(cacheKey);

    if (request != null) {
        request.mResponseBitmap = response;
        //處理結果
        batchResponse(cacheKey, request);
    }
}

private void batchResponse(String cacheKey, BatchedImageRequest request) {
    mBatchedResponses.put(cacheKey, request);
    //通過handler，發送一個操作
    if (mRunnable == null) {
        mRunnable = new Runnable() {
            @Override
            public void run() {
                for (BatchedImageRequest bir : mBatchedResponses.values()) {
                    for (ImageContainer container : bir.mContainers) {
                        if (container.mListener == null) {
                            continue;
                        }
                        if (bir.getError() == null) {
                            container.mBitmap = bir.mResponseBitmap;
                            //更新結果
                            container.mListener.onResponse(container, false);
                        } else {
                            container.mListener.onErrorResponse(bir.getError());
                        }
                    }
                }
                mBatchedResponses.clear();
                mRunnable = null;
            }

        };
        // mHandler對應的looper是MainLooper，是以被MainLooper.loop()得到該message，故該runnable操作在主線程中執行，
        mHandler.postDelayed(mRunnable, mBatchResponseDelayMs);
    }
}

3.總結

Android_開源架構_Volley(Google IO 2013)源代碼及内部實作分析 1.Volley概述2.Volley源碼分析3.總結

RequestQueue類存在2個非常重要的PriorityBlockingQueue類型的成員字段mCacheQueue mNetworkQueue ，該PriorityBlockingQueue為java1.5并發庫提供的！其中有幾個重要的方法，比如take()為從隊列中取得對象，如果隊列不存在對象，将會被阻塞，直到隊列中存在有對象，類似于Looper.loop()。執行個體化一個request對象，調用RequestQueue.add(request),該request如果不允許被緩存，将會被添加至mNetworkQueue隊列中，待多個NetworkDispatcher線程從mNetworkQueue中take()取出對象。如果該request可以被緩存，該request将會被添加至mCacheQueue隊列中，待mCacheDispatcher線程從mCacheQueue.take()取出對象，如果該request在mCache中不存在比對的緩存時，該request将會被移交添加至mNetworkQueue隊列中，待網絡通路完成後，将關鍵頭資訊添加至mCache緩存中去，并通過ResponseDelivery主線程調用request的相關方法！

Volley執行個體，>>Android_開源架構_Volley執行個體

Android_開源架構_Volley(Google IO 2013)源代碼及内部實作分析 1.Volley概述2.Volley源碼分析3.總結

1.Volley概述

2.Volley源碼分析

(1).Volley.java

(2).RequestQueue.java

(3).CacheDispatcher.java

(4).NetworkDispatcher.java

(5).StringRequest.java

(6).ImageLoader.java

3.總結

繼續閱讀

專訪鄧凡平：深入了解Android

與專家面對面：Android開發入門問與答

Android MVP架構MVCMVP

mvp初探

Android常用工具類簡介目錄

android常用工具類轉載自：http://www.trinea.cn/android/android-common-utils/Android常用工具類

Android常用工具類ToastUtilsSizeUtilsLogUtilsRetrofitManagerAnimUtil

Android Studio 0.8.0解決 Failure [INSTALL_FAILED_OLDER_SDK] 問題

Android – ListView 中添加按鈕，動态删除添加ItemView的操作

Kotlin的ListView與RecyclerView的簡單應用

關于公司的那些坑：Android Studio篇

android SQLite事務和kotlin協程

無法正常編譯錯誤Compilation failed to complete

關于Gradle配置的小結

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Android APK檔案反編譯Android APK檔案反編譯