2. 程式人生 > >Android中 網路框架Volley的用法

Android中 網路框架Volley的用法

阿新 • • 發佈：2019-01-26

Volley是在Google I/O 2013上釋出的一框網路通訊http模組，新版本的Android已經廢除了HttpClient的使用，目前主流的android網路通訊庫有：Async-Http、NoHttp、xUtil等。本文就自己學習了Volley一些相關知識，基於Volley的部分原始碼分析，簡單描述一下Volley的用法，主要從以下幾點進行介紹：

  1. Volley原始碼淺析
  2. Volley使用教程
  3. 總結

1、Volley原始碼淺析：
首先，我們先看下Volley.java的整個類程式碼：

package com.android.volley.toolbox;

import
 
 android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager.NameNotFoundException;
import android.net.http.AndroidHttpClient;
import android.os.Build;

import com.android.volley.Network;
import com.android.volley.RequestQueue;

import java.io.File;

public
 
 class Volley {

    /** Default on-disk cache directory. */
    private static final String DEFAULT_CACHE_DIR = "volley";

    /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @param
 
 stack An {@link HttpStack} to use for the network, or null for default.
     * @return A started {@link RequestQueue} instance.
     */
    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 {
                // 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 = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();

        return queue;
    }

    /**
     * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
     *
     * @param context A {@link Context} to use for creating the cache dir.
     * @return A started {@link RequestQueue} instance.
     */
    public static RequestQueue newRequestQueue(Context context) {
        return newRequestQueue(context, null);
    }
}

其實可以發現，整個類並不龐大，不到100行的程式碼量，當我們使用Volley時，我們呼叫了newRequestQueue(Context context)這個方法來初始化一個請求佇列，該方法在原始碼中呼叫的是newRequestQueue(Context context, HttpStack stack)這塊主體的程式碼塊。
該方法的前面聲明瞭快取路徑，接下來初始化了HttpStack：

if (Build.VERSION.SDK_INT >= 9) {
   stack = new HurlStack();
}

進入HurlStack中我們看下它主要的方法：

@Override
    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
            throws IOException, AuthFailureError {
        String url = request.getUrl();
        HashMap<String, String> map = new HashMap<String, String>();
        map.putAll(request.getHeaders());
        map.putAll(additionalHeaders);
        if (mUrlRewriter != null) {
            String rewritten = mUrlRewriter.rewriteUrl(url);
            if (rewritten == null) {
                throw new IOException("URL blocked by rewriter: " + url);
            }
            url = rewritten;
        }
        URL parsedUrl = new URL(url);
        HttpURLConnection connection = openConnection(parsedUrl, request);
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }
        setConnectionParametersForRequest(connection, request);
        // Initialize HttpResponse with data from the HttpURLConnection.
        ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
        int responseCode = connection.getResponseCode();
        if (responseCode == -1) {
            // -1 is returned by getResponseCode() if the response code could not be retrieved.
            // Signal to the caller that something was wrong with the connection.
            throw new IOException("Could not retrieve response code from HttpUrlConnection.");
        }
        StatusLine responseStatus = new BasicStatusLine(protocolVersion,
                connection.getResponseCode(), connection.getResponseMessage());
        BasicHttpResponse response = new BasicHttpResponse(responseStatus);
        response.setEntity(entityFromConnection(connection));
        for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
            if (header.getKey() != null) {
                Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
                response.addHeader(h);
            }
        }
        return response;
    }

就是涉及跟網路通訊互動的方式，基於了HttpURLConnection 的實現。回到Volley類中，接下來就是這幾句程式碼：

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
return queue;

我們的請求佇列就是在這裡生成的。這邊就涉及到了RequestQueue這個類，我們還是先看下這個類的構造方法吧，下面方法塊是最終在類內部呼叫的最終構造方法：

/**
     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
     *
     * @param cache A Cache to use for persisting responses to disk
     * @param network A Network interface for performing HTTP requests
     * @param threadPoolSize Number of network dispatcher threads to create
     * @param delivery A ResponseDelivery interface for posting responses and errors
     */
    public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

那我們知道了，初始化queue主要跟以下幾個物件有關：Cache 、Network 、ResponseDelivery 、NetworkDispatcher、CacheDispatcher

之後便是queue.start()方法：

/**
     * Starts the dispatchers in this queue.
     */
    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();
        }
    }

至此，便返回一個請求佇列，完成queue的初始化工作。

最後，我們這個佇列可以新增request，完成訪問網路的工作。我們也還是貼下add方法的原始碼進行看下先：

/**
     * Adds a Request to the dispatch queue.
     * @param request The request to service
     * @return The passed-in request
     */
    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");

        // 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<Request> stagedRequests = mWaitingRequests.get(cacheKey);
                if (stagedRequests == null) {
                    stagedRequests = new LinkedList<Request>();
                }
                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;
        }

當mCacheQueue或者mNetworkQueue的add方法新增請求之後，我們執行的執行緒就會接收到請求，從而去處理相對應的請求，最後將處理的結果由mDelivery來發送到主執行緒進行更新。到這裡，我們的請求就會在快取執行緒或者網路執行緒中去處理了，在以上步驟完成之後，request會呼叫自身的finish()方法，表示結束整個請求：

/**
     * Called from {@link Request#finish(String)}, indicating that processing of the given request
     * has finished.
     *
     * <p>Releases waiting requests for <code>request.getCacheKey()</code> if
     *      <code>request.shouldCache()</code>.</p>
     */
    void finish(Request request) {
        // Remove from the set of requests currently being processed.
        synchronized (mCurrentRequests) {
            mCurrentRequests.remove(request);
        }

        if (request.shouldCache()) {
            synchronized (mWaitingRequests) {
                String cacheKey = request.getCacheKey();
                Queue<Request> waitingRequests = mWaitingRequests.remove(cacheKey);
                if (waitingRequests != null) {
                    if (VolleyLog.DEBUG) {
                        VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",
                                waitingRequests.size(), cacheKey);
                    }
                    // Process all queued up requests. They won't be considered as in flight, but
                    // that's not a problem as the cache has been primed by 'request'.
                    mCacheQueue.addAll(waitingRequests);
                }
            }
        }
    }

幹完了原始碼分析的工作，接下來我們就實際操刀一下：

2、使用教程：

1、AndroidManifest中新增訪問網路的許可權，不用說都知道。

2、引入Volley包。這裡大家可以去搜一下。

3、程式碼編寫。

按我自己的程式碼風格，喜歡先封裝一下VolleyUtil的工具類，寫了部分程式碼，不打完善，大家可以自行補充。：VolleyUtil .java



import android.content.Context;

import com.android.volley.NetworkResponse;
import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.Response;
import com.android.volley.toolbox.HttpHeaderParser;
import com.android.volley.toolbox.JsonObjectRequest;
import com.android.volley.toolbox.StringRequest;
import com.android.volley.toolbox.Volley;

import org.json.JSONObject;

import java.io.UnsupportedEncodingException;

/**
 * 作者：viviant on 2016/6/30 14:08
 * 描述：Volley封裝類
 */
public class VolleyUtil {

    private static RequestQueue mQueue; // volley的請求佇列
    private static VolleyUtil instance;
    private static Context context;

    private VolleyUtil(Context context) {
        this.context = context;
    }

    public static VolleyUtil getInstance() {
            synchronized (VolleyUtil.class) {
                if (instance == null) {
                    instance = new VolleyUtil(context);
                }
            }
        return instance;
    }

    /**
     * get方式請求
     */
    public void get(Context context, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
        mQueue = Volley.newRequestQueue(context);
        mQueue.add(new MyStringRequest(Request.Method.GET, url, listener, errorListener));
    }

    /**
     * get方式請求
     */
    public void get(Context context, String url, JSONObject jsonObject, Response.Listener<JSONObject> listener, Response.ErrorListener errorListener) {
        mQueue = Volley.newRequestQueue(context);
        mQueue.add(new JsonObjectRequest(Request.Method.GET, url, jsonObject, listener, errorListener));
    }

    /**
     * post方式請求
     */
    public void post(Context context, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
        mQueue = Volley.newRequestQueue(context);
        mQueue.add(new MyStringRequest(Request.Method.POST, url, listener, errorListener));
    }

    /**
     * post方式請求
     */
    public void put(Context context, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
        mQueue = Volley.newRequestQueue(context);
        mQueue.add(new MyStringRequest(Request.Method.PUT, url, listener, errorListener));
    }

    /**
     * post方式請求
     */
    public void delete(Context context, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
        mQueue = Volley.newRequestQueue(context);
        mQueue.add(new MyStringRequest(Request.Method.DELETE, url, listener, errorListener));
    }


    /**
     * get by tag方式請求
     */
    public void getByTag(Context context, String url, Response.Listener<String> listener, Response.ErrorListener errorListener, Object tag) {
        mQueue = Volley.newRequestQueue(context);
        MyStringRequest request = new MyStringRequest(Request.Method.GET, url, listener, errorListener);
        request.setTag(tag);
        mQueue.add(request);

    }

    /**
     * 根據tag取消請求
     * @param tag
     */
    public void cancleRequests(Object tag) {
        if (mQueue != null) {
            mQueue.cancelAll(tag);
        }
    }

    /**
     * 取消所有的請求
     */
    public void onStop() {
        if (mQueue != null) {
            mQueue.cancelAll(new RequestQueue.RequestFilter() {
                @Override
                public boolean apply(Request<?> request) {
                    // do I have to cancel this?
                    return true; // -> always yes
                }
            });
        }
    }

    public class MyStringRequest extends StringRequest {

        public MyStringRequest(int method, String url, Response.Listener<String> listener,Response.ErrorListener errorListener) {
            super(method, url, listener, errorListener);
        }

        /**
         * 重寫以解決亂碼問題
         */
        @Override
        protected Response<String> parseNetworkResponse(NetworkResponse response) {
            String str = null;
            try {
                str = new String(response.data, "utf-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return Response.success(str,  HttpHeaderParser.parseCacheHeaders(response));
        }
    }
}

以上也包含了一個填坑操作，我們使用StringRequest 時返回來的資料會亂碼，這邊我在網上查了別人的解決方案，重寫了一個類。

下面是我的二次封裝程式碼：VolleyNetManager.java


import android.content.Context;
import android.util.Log;

import com.android.volley.Response;
import com.android.volley.VolleyError;

import org.json.JSONObject;

import viviant.cn.weeklyplan.common.util.VolleyUtil;

/**
 * 作者：viviant on 2016/6/30 14:18
 * 描述：
 */
public class VolleyNetManager {

    /**
     * 根據標籤取消請求
     * @param tag
     */
    public static void cancleRequests (Object tag) {
        VolleyUtil.getInstance().cancleRequests(tag);
    }

    /**
     * 取消所有請求
     */
    public static void cancleAllRequests () {
        VolleyUtil.getInstance().onStop();
    }

    /**
     * Volley Get 方法測試方法
     */
    public static void TestVolleyGet(Context context, String url) {
        VolleyUtil.getInstance().get(context, url,new Response.Listener<String>() {

            @Override
            public void onResponse(String arg0) {
//                Toast.makeText(getActivity(), arg0, Toast.LENGTH_LONG).show();
                Log.d("weiwei", arg0);
            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError arg0) {
//                Toast.makeText(getActivity(), arg0.toString(), Toast.LENGTH_LONG).show();
                Log.d("weiwei", "error : " + arg0.toString());
            }
        });
    }

    /**
     * Volley Get JSONObject 方法測試方法
     */
    public static void TestVolley(Context context, String url) {
        VolleyUtil.getInstance().get(context, url, null, new Response.Listener<JSONObject>() {

            @Override
            public void onResponse(JSONObject jsonObject) {
//                Toast.makeText(getActivity(), arg0, Toast.LENGTH_LONG).show();
                Log.d("weiwei", jsonObject.toString());
            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError arg0) {
//                Toast.makeText(getActivity(), arg0.toString(), Toast.LENGTH_LONG).show();
                Log.d("weiwei", "error : " + arg0.toString());
            }
        });
    }


    /**
     * VolleyPost方法測試方法
     */
    public static void TestVolleyPost(Context context, String url) {

        VolleyUtil.getInstance().post(context, url, new Response.Listener<String>() {

            @Override
            public void onResponse(String arg0) {
//                Toast.makeText(getActivity(), arg0, Toast.LENGTH_LONG).show();
                Log.d("weiwei", arg0);
            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError arg0) {
//                Toast.makeText(getActivity(), arg0.toString(), Toast.LENGTH_LONG).show();
                Log.d("weiwei", "error : " + arg0.toString());
            }
        });
    }
}

我們在activity中可以呼叫：

private static final String URL = "http://www.baidu.com/";
VolleyNetManager.TestVolleyGet(getContext(), URL);

然後就可以在VolleyNetManager 得到我們返回來的資料。

3、總結：

這邊畫了個草圖，梳理下RequestQueue的主要方法：
這裡寫圖片描述

總得來說，volley是一個很優秀的框架，比較簡潔。好歹是谷歌自己出的。
以上是我對自己使用時做的一個小小的總結，有不好的地方歡迎提出意見。

相關推薦

Android中 網路框架Volley的用法

Volley是在Google I/O 2013上釋出的一框網路通訊http模組，新版本的Android已經廢除了HttpClient的使用，目前主流的android網路通訊庫有：Async-Http、NoHttp、xUtil等。本文就自己學習了Volley一些相

對Android官方網路框架——volley的封裝

使用場景 Android系統中主要提供了兩種方式來進行HTTP通訊，HttpURLConnection和HttpClient，幾乎在任何專案的程式碼中我們都能看到這兩個類的身影，使用率非常高。不過HttpURLConnection和HttpClient的用法還是稍微有些複雜

Android網路框架Volley

                Volley是Google I/O 2013推出的網路通訊庫，在volley推出之前我們一般會選擇比較成熟的第三方網路通訊庫，如：他們各有優劣，之前個人則比較喜歡用android-async-http, 如今Google推出了官方的針對Android平臺上的網路通訊庫，能使網路

Android網路框架Volley(實戰篇)

之前講了ym—— Android網路框架Volley(體驗篇)，大家應該瞭解了volley的使用，接下來我們要看看如何把volley使用到實戰專案裡面，我們先考慮下一些問題： 從上一篇來看 mQueue 只需要一個物件即可，new RequestQueue物件對資源一種浪費

android中Okhttp框架進行網路請求的工具類（）

package com.example.utils; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Iterat

Android 開源網路框架（Android-Async-Http、Volley、OkHttp3、Retrofit2.0）對比

思維導圖 一、為什麼要使用網路開源框架 1. Android系統自帶網路請求 Android系統自帶的網路請求模組有兩個，一個是HttpClient，另一個是HttpUrlConnection。 1.1. HttpUrlConnection HttpURLCon

Android網路框架volley學習(三)底層網路請求分析

相關文章 前面我們分析了一下volley的基本用法及總體工作流程，由於volley是一個網路請求框架，所以本篇我們分析一下它的底層網路請求。 volley原始碼說長不長，說短不短，也有幾十個類，該從哪裡開始分析呢？我們從最基本的開始分析，還記得一開始進行

轉載-ym—— Android網路框架Volley(體驗篇)

Volley是Google I/O 2013推出的網路通訊庫，在volley推出之前我們一般會選擇比較成熟的第三方網路通訊庫，如： 他們各有優劣，之前個人則比較喜歡用android-async-http, 如今Google推出了官方的針對Android平臺上的網路通訊庫，能使網路通訊更快

（轉）ym—— Android網路框架Volley(實戰篇)

從上一篇來看 mQueue 只需要一個物件即可，new RequestQueue物件對資源一種浪費，我們應該在application，以及可以把取消請求的方法也在application進行統一管理，看以下程式碼： [java] view plaincopyprint?

Android網絡框架-Volley實踐 使用Volley打造自己定義ListView

str android項目 chan hive link con data net dap 這篇文章翻譯自Ravi Tamada博客中的Android Custom ListView with Image and Text using Volley 終於效果

Android中Calendar類的用法總結

jsb ews 寫法 需要 key data- minute bar 來講 Calendar是Android開發中需要獲取時間時必不可少的一個工具類，通過這個類可以獲得的時間信息還是很豐富的，下面做一個總結，以後使用的時候就不用總是去翻書或者查資料了。 在獲取時間之前要先獲

Android中Xposed框架篇-微信實現本地視頻發布到朋友圈功能

快速定位 adb 本地 ref jad jadx mps 頁面 視頻 微信非常龐大，還好有一些強大的工具，下面就來總結收獲的知識。 一、使用adb shell dumpsys activity top命令快速定位頁面 二、使用Jadx進行方法跟蹤時候如果發現沒有結

（轉）Android中Parcelable接口用法

string date 場景 應用 用法 反序列化 數組 auth 序列化對象 1. Parcelable接口 Interface for classes whose instances can be written to and restored from a Parce

Android 圖片載入框架Glide用法

最近有個需求是，要將 url 地址傳過來的圖片載入到ImageView中，幾番折騰後找到 Glide，真的很好用，所以做下筆記 轉載：https://www.cnblogs.com/guilin-hu/p/5706916.html 在泰國舉行的谷歌開發者論壇上，谷歌為我們介紹了一個名叫&nb

Android中AsyncTask的簡單用法

在開發Android移動客戶端的時候往往要使用多執行緒來進行操作，我們通常會將耗時的操作放在單獨的執行緒執行，避免其佔用主執行緒而給使用者帶來不好的使用者體驗。但是在子執行緒中無法去操作主執行緒（UI 執行緒），在子執行緒中操作UI執行緒會出現錯誤。因此android提供

Android中Xposed框架篇-利用Xposed框架實現攔截系統方法

本文轉載自Android中Xposed框架篇—利用Xposed框架實現攔截系統方法 Xposed框架是Android中hook技術的一個著名的框架，免費而且開源，網上有很多文章介紹了Xposed框架的原理實現，不瞭解的同學可以自行查閱即可，本文主要介紹如何通過

Android圖片載入框架Glide用法

轉載地址： 在泰國舉行的谷歌開發者論壇上，谷歌為我們介紹了一個名叫 Glide 的圖片載入庫，作者是bumptech。這個庫被廣泛的運用在google的開源專案中，包括2014年google I/O大會上釋出的官方app。 它的成功讓我非常感興趣。我花了一整晚的時間把

Android 圖片載入框架 Volley框架原始碼 以及Picasso和Glide比較

首先了解一下，它是封裝了HTTPConnection和HTTPClient類的一個框架， 適用於資料量少但是通訊頻繁的情況，如載入圖片； 就拿StringRequest（用來請求字串的）舉例： Volley的順序是 ：  Http請求-------再接受響應   只

android 中layer-list的用法

1.可以將多個圖片按照順序層疊起來 2.在drawable下建立一個xml檔案 [xhtml:showcolumns] view plaincopyprint? <?xml version="1.0" encoding="UTF-8"?>    

Android中Xposed框架篇---修改系統位置資訊實現自身隱藏功能

一、前言前文已經介紹了Xposed框架的基本使用規則，本文主要來介紹一個實際案例就是如何通過這個框架來修改系統的地理位置資訊來實現隱藏功能，在如今社交工具的發展特別是微信，他有一個實時位置共享功能，那麼