Android網絡框架Volley

Volley 是Google I/O 2013推出的網絡通訊庫，在volley推出以前咱們通常會選擇比較成熟的第三方網絡通訊庫，如：

• android-async-http

• retrofit

• okhttp

他們各有優劣，以前我的則比較喜歡用android-async-http, 現在Google推出了官方的針對Android平臺上的網絡通訊庫，能使網絡通訊更快，更簡單，更健壯，Volley在提供了高性能網絡通信功能的同時，對網絡圖片加載也提供了良好的支持，徹底能夠知足簡單REST客戶端的需求, 咱們沒有理由不跟上時代的潮流

 

使用Volley

 

下載Volley源碼並build jar包。

$ git clone https://android.googlesource.com/platform/frameworks/volley
$ cd volley
$ android update project -p
$ ant jar

而後把生成的jar包引用到咱們的項目中，extras目錄下則包含了目前最新的volley源碼。

說明

此Demo主要介紹了平常網絡開發經常使用的基本功能，但volley的擴展性很強，能夠根據須要定製你本身的網絡請求。

volley視頻地址： http://www.youtube.com/watch?v=yhv8l9F44qo&feature=player_embedded

以上是在Google IO的演講上ppt的配圖，從上面這張圖咱們能夠看出，volley適合快速，簡單的請求（Json對象，圖片加載）。

volley的特性：

 

• JSON，圖像等的異步下載；
• 網絡請求的排序（scheduling）
• 網絡請求的優先級處理
• 緩存
• 多級別取消請求
• 和Activity和生命週期的聯動（Activity結束時同時取消全部網絡請求）

 

接下來，咱們來學習簡單的使用下volley給我提供的API吧。

1.首先拿到一個請求隊列（RequestQueue只須要一個實例便可，不像AsyncTask每次使用都要new一個）

 

// 初始化RequestQueue一個activity只須要一個
    private void initRequestQueue() {
        mQueue = Volley.newRequestQueue(getApplicationContext());
    }

2.實現volley的異步請求類（JsonObjectRequest,JsonArrayRequest,StringRequest,ImageRequest）

 

因爲用法都相差不大，我就不一一舉例了，舉幾個經常使用有表明性的例子：

如下代碼是StringRequest的get請求：

// get請求

private void loadGetStr(String url) {

    StringRequest srReq = new StringRequest(Request.Method.GET, url,
            new StrListener(), new StrErrListener()) {

        protected final String TYPE_UTF8_CHARSET = "charset=UTF-8";

        // 重寫parseNetworkResponse方法改變返回頭參數解決亂碼問題
        // 主要是看服務器編碼，若是服務器編碼不是UTF-8的話那麼就須要本身轉換，反之則不須要
        @Override
        protected Response<String> parseNetworkResponse(
                NetworkResponse response) {
            try {
                String type = response.headers.get(HTTP.CONTENT_TYPE);
                if (type == null) {
                    type = TYPE_UTF8_CHARSET;
                    response.headers.put(HTTP.CONTENT_TYPE, type);
                } else if (!type.contains("UTF-8")) {
                    type += ";" + TYPE_UTF8_CHARSET;
                    response.headers.put(HTTP.CONTENT_TYPE, type);
                }
            } catch (Exception e) {
            }
            return super.parseNetworkResponse(response);
        }
    };
    srReq.setShouldCache(true); // 控制是否緩存
    startVolley(srReq);
}

如下代碼是JsonObjectRequest的post請求：

// post請求
private void loadPostJson(String url) {
    // 第二個參數說明:
    // Constructor which defaults to GET if jsonRequest is null, POST
    // otherwise.
    // 默認狀況下設成null爲get方法,不然爲post方法。
    JsonObjectRequest srReq = new JsonObjectRequest(url, null,
            new JsonListener(), new StrErrListener()) {

        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> map = new HashMap<String, String>();
            map.put("w", "2459115");
            map.put("u", "f");
            return map;
        }
    };
    srReq.setShouldCache(false); // 控制是否緩存
    startVolley(srReq);
}

你們注意看的話，不管是JsonObjectReques的postt仍是StringRequest的get都須要傳入兩個監聽函數一個是成功一個是失敗，成功監聽他們會返回相應類型的數據：

 

// Str請求成功回調
private class StrListener implements Listener<String> {

    @Override
    public void onResponse(String arg0) {
        Log.e(Tag, arg0);

    }

}

// Gson請求成功回調
private class GsonListener implements Listener<ErrorRsp> {

    @Override
    public void onResponse(ErrorRsp arg0) {
        Toast.makeText(mContext, arg0.toString(), Toast.LENGTH_LONG).show();
    }

}
// 共用失敗回調
private class StrErrListener implements ErrorListener {

    @Override
    public void onErrorResponse(VolleyError arg0) {
        Toast.makeText(mContext,
                VolleyErrorHelper.getMessage(arg0, mContext),
                Toast.LENGTH_LONG).show();
    }

}

接下來是ImageRequest

/**
 * 第三第四個參數分別用於指定容許圖片最大的寬度和高度，若是指定的網絡圖片的寬度或高度大於這裏的最大值，則會對圖片進行壓縮，
 * 指定成0的話就表示無論圖片有多大，都不會進行壓縮。
 *
 * @param url
 *            圖片地址
 * @param listener
 * @param maxWidth
 *            指定容許圖片最大的寬度
 * @param maxHeight
 *            指定容許圖片最大的高度
 * @param decodeConfig
 *            指定圖片的顏色屬性，Bitmap.Config下的幾個常量.
 * @param errorListener
 */
private void getImageRequest(final ImageView iv, String url) {
    ImageRequest imReq = new ImageRequest(url, new Listener<Bitmap>() {

        @Override
        public void onResponse(Bitmap arg0) {
            iv.setImageBitmap(arg0);
        }
    }, 60, 60, Bitmap.Config.ARGB_8888, new StrErrListener());
    startVolley(imReq);
}

看到如今你們確定會疑惑寫了這麼多不一樣類型的Request到底如何運行？接下請看：

 

 

// 添加及開始請求
private void startVolley(Request req) {

    // 設置超時時間
    // req.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));
    // 將請求加入隊列
    mQueue.add(req);
    // 開始發起請求
    mQueue.start();
}

volley不只提供了這些請求的方式，還提供了加載圖片的一些方法和控件：

好比咱們一個列表須要加載不少圖片咱們可使用volley給咱們提供的ImageLoader（ ImageLoader比ImageRequest更加高效，由於它不只對圖片進行緩存，還能夠過濾掉重複的連接，避免重複發送請求。）

 

public class ImageAdapter extends ArrayAdapter<String> {

    private RequestQueue mQueue;
    private ImageLoader mImageLoader;

    public ImageAdapter(Context context, List<String> objects) {
        super(context, 0, objects);
        mQueue = Volley.newRequestQueue(getContext());
        mImageLoader = new ImageLoader(mQueue, new BitmapCache());
    }

    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        String url = getItem(position);
        ImageView imageView;
        if (convertView == null) {
            imageView = new ImageView(getContext());
        } else {
            imageView = (ImageView) convertView;
        }
        // getImageListener（imageView控件對象，默認圖片地址，失敗圖片地址）;
        ImageListener listener = ImageLoader.getImageListener(imageView, android.R.drawable.ic_menu_rotate, android.R.drawable.ic_delete);
        // get(圖片地址，listener，寬，高)；自動幫你處理圖片的寬高不再怕大圖片的oom了
        mImageLoader.get(url, listener,100,200);
        return imageView;
    }

}

固然還須要重寫ImageCache這個類 //使用LruCache不再用怕加載多張圖片oom了

 

 

public class <span style="font-family: Arial;">BitmapCache</span><span style="font-family: Arial;"> extends LruCache<String, Bitmap> implements ImageCache {</span>
    // LruCache 原理：Cache保存一個強引用來限制內容數量，每當Item被訪問的時候，此Item就會移動到隊列的頭部。 當cache已滿的時候加入新的item時，在隊列尾部的item會被回收。
    // 解釋：當超出指定內存值則移除最近最少用的圖片內存
    public static int getDefaultLruCacheSize() {
        // 拿到最大內存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        // 拿到內存的八分之一來作圖片內存緩存
        final int cacheSize = maxMemory / 8;

        return cacheSize;
    }

    public BitmapLruCache() {
        this(getDefaultLruCacheSize());
    }

    public BitmapLruCache(int sizeInKiloBytes) {
        super(sizeInKiloBytes);
    }

    @Override
    protected int sizeOf(String key, Bitmap value) {
        return value.getRowBytes() * value.getHeight() / 1024;
    }

    @Override
    public Bitmap getBitmap(String url) {
        return get(url);
    }

    @Override
    public void putBitmap(String url, Bitmap bitmap) {
        put(url, bitmap);
    }
}

Volley還提供的加載圖片的控件com.android.volley.NetworkImageView。（這個控件在被從父控件detach的時候，會自動取消網絡請求的，即徹底不用咱們擔憂相關網絡請求的生命週期問題，並且NetworkImageView還會根據你對圖片設置的width和heigh自動壓縮該圖片不會產生多的內存，還有NetworkImageView在列表中使用不會圖片錯誤）

 

 

<com.android.volley.toolbox.NetworkImageView
    android:id="@+id/network_image_view"
    android:layout_width="100dp"
    android:layout_height="100dp" />

使用方法：

 

 

private void networkImageViewUse(NetworkImageView iv, String url) {
        ImageLoader imLoader = new ImageLoader(mQueue, new BitmapLruCache());
        iv.setDefaultImageResId(R.drawable.ic_launcher);
        iv.setErrorImageResId(R.drawable.ic_launcher);
        iv.setImageUrl(url, imLoader);
    }

咱們說了這麼多都是請求，那麼如何取消請求呢？

 

1.activity自動銷燬時它會自定取消全部請求。

2.給請求設置標籤：

 

request.setTag("My Tag");

 

取消全部指定標記的請求：

 

request.cancelAll("My Tag");

Volley的架構設計：

 

其中藍色部分表明主線程，綠色部分表明緩存線程，橙色部分表明網絡線程。咱們在主線程中調用RequestQueue的add()方法來添加一條網絡請求，這條請求會先被加入到緩存隊列當中，若是發現能夠找到相應的緩存結果就直接讀取緩存並解析，而後回調給主線程。若是在緩存中沒有找到結果，則將這條請求加入到網絡請求隊列中，而後處理髮送HTTP請求，解析響應結果，寫入緩存，並回調主線程。

 

 

接下來咱們要看看如何把volley使用到實戰項目裏面，咱們先考慮下一些問題：

從上一篇來看 mQueue 只須要一個對象便可，new RequestQueue對象對資源一種浪費，咱們應該在application，以及能夠把取消請求的方法也在application進行統一管理，看如下代碼：

 

package com.chronocloud.lib.base;

import android.app.Application;
import android.text.TextUtils;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.VolleyLog;
import com.android.volley.toolbox.Volley;

public class ApplicationController extends Application {

    /**
     * Log or request TAG
     */
    public static final String TAG = "VolleyPatterns";

    /**
     * Global request queue for Volley
     */
    private RequestQueue mRequestQueue;

    /**
     * A singleton instance of the application class for easy access in other
     * places
     */
    private static ApplicationController sInstance;

    @Override
    public void onCreate() {
        super.onCreate();

        // initialize the singleton
        sInstance = this;
    }

    /**
     * @return ApplicationController singleton instance
     */
    public static synchronized ApplicationController getInstance() {
        return sInstance;
    }

    /**
     * @return The Volley Request queue, the queue will be created if it is null
     */
    public RequestQueue getRequestQueue() {
        // lazy initialize the request queue, the queue instance will be
        // created when it is accessed for the first time
        if (mRequestQueue == null) {
            // 1
            // 2
            synchronized (ApplicationController.class) {
                if (mRequestQueue == null) {
                    mRequestQueue = Volley
                            .newRequestQueue(getApplicationContext());
                }
            }
        }
        return mRequestQueue;
    }

    /**
     * Adds the specified request to the global queue, if tag is specified then
     * it is used else Default TAG is used.
     *
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req, String tag) {
        // set the default tag if tag is empty
        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        VolleyLog.d("Adding request to queue: %s", req.getUrl());

        getRequestQueue().add(req);
    }

    /**
     * Adds the specified request to the global queue using the Default TAG.
     *
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req) {
        // set the default tag if tag is empty
        req.setTag(TAG);

        getRequestQueue().add(req);
    }

    /**
     * Cancels all pending requests by the specified TAG, it is important to
     * specify a TAG so that the pending/ongoing requests can be cancelled.
     *
     * @param tag
     */
    public void cancelPendingRequests(Object tag) {
        if (mRequestQueue != null) {
            mRequestQueue.cancelAll(tag);
        }
    }
}

接下來就是Volley雖然給咱們提供了不少不一樣的Request（JsonObjectRequest,JsonArrayRequest,StringRequest,ImageRequest），可是仍是知足不了咱們實戰中的需求，咱們實戰開發中常常用到的是xml格式，Gson解析。

 

接下來咱們來看看，如何自定義Request

XmlRequest：

 

public class XMLRequest extends Request<XmlPullParser> {

    private final Listener<XmlPullParser> mListener;

    public XMLRequest(int method, String url, Listener<XmlPullParser> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

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

    @Override
    protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
        try {
            String xmlString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser xmlPullParser = factory.newPullParser();
            xmlPullParser.setInput(new StringReader(xmlString));
            return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (XmlPullParserException e) {
            return Response.error(new ParseError(e));
        }
    }

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

}

GsonRequest（注意須要自行導入gson.jar）：

 

 

public class GsonRequest<T> extends Request<T> {

    private final Listener<T> mListener;

    private Gson mGson;

    private Class<T> mClass;

    public GsonRequest(int method, String url, Class<T> clazz, Listener<T> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mGson = new Gson();
        mClass = clazz;
        mListener = listener;
    }

    public GsonRequest(String url, Class<T> clazz, Listener<T> listener,
            ErrorListener errorListener) {
        this(Method.GET, url, clazz, listener, errorListener);
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(mGson.fromJson(jsonString, mClass),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        }
    }

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

}

接下只差最後一步了就是封裝它的錯誤處理，使用過volley的都知道，volley的監聽錯誤提示都是NoConnectionError。。。等等，這類的錯誤提示，顯然這不是咱們想給用戶呈現的錯誤提示，由於就算提示了用戶也不明白什麼意思，因此咱們還要封裝一下，能讓用戶看的更清楚的理解這些錯誤提示。 ym—— Android網絡框架Volley(體驗篇)咱們講過每一個請求都須要設置一個失敗的監聽：

 

 

// 共用失敗回調
private class StrErrListener implements ErrorListener {

    @Override
    public void onErrorResponse(VolleyError arg0) {
        Toast.makeText(mContext,
                VolleyErrorHelper.getMessage(arg0, mContext),
                Toast.LENGTH_LONG).show();
    }

}

以上代碼有個VolleyError對象，咱們能夠從這個對象上下手：

 

 

package com.example.volley;

import java.util.HashMap;
import java.util.Map;

import android.content.Context;

import com.android.volley.AuthFailureError;
import com.android.volley.NetworkError;
import com.android.volley.NetworkResponse;
import com.android.volley.NoConnectionError;
import com.android.volley.ServerError;
import com.android.volley.TimeoutError;
import com.android.volley.VolleyError;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
//正如前面代碼看到的，在建立一個請求時，須要添加一個錯誤監聽onErrorResponse。若是請求發生異常，會返回一個VolleyError實例。
//如下是Volley的異常列表：
//AuthFailureError：若是在作一個HTTP的身份驗證，可能會發生這個錯誤。
//NetworkError：Socket關閉，服務器宕機，DNS錯誤都會產生這個錯誤。
//NoConnectionError：和NetworkError相似，這個是客戶端沒有網絡鏈接。
//ParseError：在使用JsonObjectRequest或JsonArrayRequest時，若是接收到的JSON是畸形，會產生異常。
//SERVERERROR：服務器的響應的一個錯誤，最有可能的4xx或5xx HTTP狀態代碼。
//TimeoutError：Socket超時，服務器太忙或網絡延遲會產生這個異常。默認狀況下，Volley的超時時間爲2.5秒。若是獲得這個錯誤可使用RetryPolicy。

public class VolleyErrorHelper {

    /**
     * Returns appropriate message which is to be displayed to the user against
     * the specified error object.
     *
     * @param error
     * @param context
     * @return
     */
    public static String getMessage(Object error, Context context) {
        if (error instanceof TimeoutError) {
            return context.getResources().getString(
                    R.string.generic_server_down);
        } else if (isServerProblem(error)) {
            return handleServerError(error, context);
        } else if (isNetworkProblem(error)) {
            return context.getResources().getString(R.string.no_internet);
        }
        return context.getResources().getString(R.string.generic_error);
    }

    /**
     * Determines whether the error is related to network
     *
     * @param error
     * @return
     */
    private static boolean isNetworkProblem(Object error) {
        return (error instanceof NetworkError)
                || (error instanceof NoConnectionError);
    }

    /**
     * Determines whether the error is related to server
     *
     * @param error
     * @return
     */
    private static boolean isServerProblem(Object error) {
        return (error instanceof ServerError)
                || (error instanceof AuthFailureError);
    }

    /**
     * Handles the server error, tries to determine whether to show a stock
     * message or to show a message retrieved from the server.
     *
     * @param err
     * @param context
     * @return
     */
    private static String handleServerError(Object err, Context context) {
        VolleyError error = (VolleyError) err;

        NetworkResponse response = error.networkResponse;

        if (response != null) {
            switch (response.statusCode) {
            case 404:
            case 422:
            case 401:
                try {
                    // server might return error like this { "error":
                    // "Some error occured" }
                    // Use "Gson" to parse the result
                    HashMap<String, String> result = new Gson().fromJson(
                            new String(response.data),
                            new TypeToken<Map<String, String>>() {
                            }.getType());

                    if (result != null && result.containsKey("error")) {
                        return result.get("error");
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
                // invalid request
                return error.getMessage();

            default:
                return context.getResources().getString(
                        R.string.generic_server_down);
            }
        }
        return context.getResources().getString(R.string.generic_error);
    }
}

以上代碼中引用的xml是：

 

 

<string name="no_internet">無網絡鏈接~！</string>
<string name="generic_server_down">鏈接服務器失敗~！</string>
<string name="generic_error">網絡異常,請稍後再試~！</string>

接下來，數據請求這一塊已經說完了，咱們來講下圖片這一塊，我我的喜歡使用universal-image-loader而不是volley本身提供的（我的認爲使用起來universal-image-loader更便捷一些）。

 

 

下面主要是講Volley在某些細節方面的選擇和實現.值得咱們學習的地方以及若是更好的使用Volley。

 

1.Volley本地緩存爲何有時候不會進行緩存？

緩存使用前提服務器必須支持，緩存，配置Cache-Control頭信息，

由於Volley須要從這些頭信息判斷緩存是否已通過期。若是已通過期Volley將會從新從網絡獲取數據。

本人用抓包工具抓了沒法緩存的返回頭信息

能夠支持緩存的頭信息

 

2.若是咱們本身寫一個網絡請求框架，咱們內部實現會選擇使用HttpURLConnection仍是HttpClient？

咱們經過源碼來看看Volley是如何選擇使用的

  

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);
    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
    queue.start();
    return queue;
}

這裏會判斷若是手機系統版本號是大於9（Android 2.3）的，則建立一個HurlStack的實例，不然就建立一個HttpClientStack的實例。實際上HurlStack的內部就是使用HttpURLConnection進行網絡通信的，而HttpClientStack的內部則是使用HttpClient進行網絡通信的，這裏爲何這樣選擇呢？參考文章： Android訪問網絡，使用HttpURLConnection仍是HttpClient？這就是它爲什麼這麼快的緣由。

 

從這點咱們能夠學習到，要針對不一樣SDK版本作去相應更優的處理方式，這樣才能達到最好的效果。

 

 3.Volley給咱們提供了ImageRrequest，ImageLoader，NetworkImageView，它們分別使用於什麼場景爲何？

單張圖片的加載能夠經過發起 ImageReuqst 請求來實現，但爲了應用內存緩存，推薦使用 ImageLoader 

NetwoekImageView專門用於批量圖片加載的場景：

 

public class NetworkImageView extends ImageView {
    private String mUrl;

    // 默認顯示的圖片
    private int mDefaultImageId;

    // 加載失敗時顯示的圖片
    private int mErrorImageId;

    // 主方法入口
    public void setImageUrl(String url, ImageLoader imageLoader) {
        mUrl = url;
        mImageLoader = imageLoader;
        // 這個方法將會對ImageView的尺寸是否有效、是否爲同一張圖片進行判斷
        // 在執行新請求前，也會取消上一次在這個View裏啓動的另外一個已經失效的請求
        // 因爲篇幅的限制以及代碼行數太多，這裏不貼出具體實現的代碼
        loadImageIfNecessary(false);
    }

    // 若是圖片已經滑離屏幕，變爲不可見，將執行取消請求的操做
    @Override
    protected void onDetachedFromWindow() {
        if (mImageContainer != null) mImageContainer.cancelRequest();
        super.onDetachedFromWindow();
    }
}

在ListView加載多張圖片的時候，NetworkImageView能夠防止出現圖片錯誤的現象，以及當NetworkImageView滑出屏幕的時候會取消加載圖片請求，這樣就保證加載多張圖片的時候用戶快速滑動列表的流暢性。給用戶帶來更優的體驗。

 

• 上一篇Android仿QQ5.0側滑菜單ResideMenu源碼分析
• 下一篇Android開發--WIFI輸入密碼Dialog的實現