Android Volley框架全面解析
Volley簡介
我們平時在開發(fā)Android應(yīng)用的時候不可避免地都需要用到網(wǎng)絡(luò)技術(shù),而多數(shù)情況下應(yīng)用程序都會使用HTTP協(xié)議來發(fā)送和接收網(wǎng)絡(luò)數(shù)據(jù)。Android系統(tǒng)中主要提供了兩種方式來進(jìn)行HTTP通信,HttpURLConnection和HttpClient,幾乎在任何項(xiàng)目的代碼中我們都能看到這兩個類的身影,使用率非常高。
不過HttpURLConnection和HttpClient的用法還是稍微有些復(fù)雜的,如果不進(jìn)行適當(dāng)封裝的話,很容易就會寫出不少重復(fù)代碼。于是乎,一些Android網(wǎng)絡(luò)通信框架也就應(yīng)運(yùn)而生,比如說AsyncHttpClient,它把HTTP所有的通信細(xì)節(jié)全部封裝在了內(nèi)部,我們只需要簡單調(diào)用幾行代碼就可以完成通信操作了。再比如Universal-Image-Loader,它使得在界面上顯示網(wǎng)絡(luò)圖片的操作變得極度簡單,開發(fā)者不用關(guān)心如何從網(wǎng)絡(luò)上獲取圖片,也不用關(guān)心開啟線程、回收圖片資源等細(xì)節(jié),Universal-Image-Loader已經(jīng)把一切都做好了。
Android開發(fā)團(tuán)隊(duì)也是意識到了有必要將HTTP的通信操作再進(jìn)行簡單化,于是在2013年Google I/O大會上推出了一個新的網(wǎng)絡(luò)通信框架——Volley。Volley可是說是把AsyncHttpClient和Universal-Image-Loader的優(yōu)點(diǎn)集于了一身,既可以像AsyncHttpClient一樣非常簡單地進(jìn)行HTTP通信,也可以像Universal-Image-Loader一樣輕松加載網(wǎng)絡(luò)上的圖片。除了簡單易用之外,Volley在性能方面也進(jìn)行了大幅度的調(diào)整,它的設(shè)計目標(biāo)就是非常適合去進(jìn)行數(shù)據(jù)量不大,但通信頻繁的網(wǎng)絡(luò)操作,而對于大數(shù)據(jù)量的網(wǎng)絡(luò)操作,比如說下載文件等,Volley的表現(xiàn)就會非常糟糕。
準(zhǔn)備工作
導(dǎo)入JAR包(下載地址),申請網(wǎng)絡(luò)權(quán)限
<uses-permission android:name="android.permission.INTERNET" />
HTTP請求與響應(yīng)
1. 使用StringRequest接收String類型的響應(yīng)
一個最基本的HTTP請求與響應(yīng)主要就是進(jìn)行以下三步操作:
創(chuàng)建一個RequestQueue對象。
創(chuàng)建一個StringRequest對象(以StringRequest為例,后面還會介紹其他Request)。
將StringRequest對象添加到RequestQueue里面。
(1)初始化請求隊(duì)列對象——RequestQueue
RequestQueue mQueue = Volley.newRequestQueue(context);
RequestQueue是一個請求隊(duì)列對象,它可以緩存所有的HTTP請求,然后按照一定的算法并發(fā)地發(fā)出這些請求。RequestQueue內(nèi)部的設(shè)計就是非常合適高并發(fā)的,因此我們不必為每一次HTTP請求都創(chuàng)建一個RequestQueue對象,這是非常浪費(fèi)資源的。所以這里建議用單例模式定義這個對象。當(dāng)然,你可以選擇在一個activity中定義一個RequestQueue對象,但這樣可能會比較麻煩,而且還可能出現(xiàn)請求隊(duì)列包含activity強(qiáng)引用的問題。
(2)使用StringRequest接收String類型的響應(yīng)
前面定義了請求對象,那么自然就有接收響應(yīng)的對象了,這個框架中有多個響應(yīng)對象,像StringRequest接受到的響應(yīng)就是string類型的;JsonRequest接收的響應(yīng)就是Json類型對象。其實(shí)它們都是繼承自Request<\T>,然后根據(jù)不同的響應(yīng)數(shù)據(jù)來進(jìn)行特殊的處理。
來看StringRequest的兩個構(gòu)造函數(shù)
/** method:請求方法 url:請求的地址 listener:響應(yīng)成功的監(jiān)聽器 errorListener:出錯時的監(jiān)聽器 **/ public StringRequest(int method, String url, Listener<String> listener, ErrorListener errorListener) /**不傳入method,默認(rèn)會調(diào)用GET方式進(jìn)行請求**/ public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) { this(Method.GET, url, listener, errorListener); }
GET方式請求網(wǎng)絡(luò),代碼如下:
StringRequest stringRequest = new StringRequest("http://www.baidu.com", new Response.Listener<String>() { @Override public void onResponse(String response) { Toast.makeText(MainActivity.this, response, Toast.LENGTH_SHORT).show(); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { showlog(error.getMessage()); } });
POST方式請求網(wǎng)絡(luò),一般我們的POST都是要帶一些參數(shù)的,Volley沒有提供附加參數(shù)的方法,所以我們必須要在StringRequest的匿名類中重寫getParams()方法,代碼如下所示:
StringRequest stringRequest = new StringRequest(Method.POST, url, listener, errorListener) { @Override protected Map<String, String> getParams() throws AuthFailureError { Map<String, String> map = new HashMap<String, String>(); map.put("params1", "value1"); map.put("params2", "value2"); return map; } };
這樣就傳入了value1和value2兩個參數(shù)了。現(xiàn)在可能有人會問為啥這個框架不提供這個傳參的方法,還非得讓我們重寫。個人覺得這個框架本身的目的就是執(zhí)行頻繁的網(wǎng)絡(luò)請求,比如下載圖片,解析json數(shù)據(jù)什么的,用GET就能很好的實(shí)現(xiàn)了,所以就沒有提供傳參的POST方法。
(3)發(fā)送請求
發(fā)送請求很簡單,將StringRequest對象添加到RequestQueue里面即可。
mQueue.add(stringRequest);
運(yùn)行一下程序,發(fā)出一條HTTP請求,把服務(wù)器返回的string用Toast展示出來:
沒錯,百度返回給我們的就是這樣一長串的HTML代碼,雖然我們看起來會有些吃力,但是瀏覽器卻可以輕松地對這段HTML代碼進(jìn)行解析,然后將百度的首頁展現(xiàn)出來。
2. 使用JsonObjectRequest接收J(rèn)son類型的響應(yīng)
類似于StringRequest,JsonRequest也是繼承自Request類的,不過由于JsonRequest是一個抽象類,因此我們無法直接創(chuàng)建它的實(shí)例,那么只能從它的子類入手了。JsonRequest有兩個直接的子類,JsonObjectRequest和JsonArrayRequest,從名字上你應(yīng)該能就看出它們的區(qū)別了吧?一個是用于請求一段JSON數(shù)據(jù)的,一個是用于請求一段JSON數(shù)組的。
這里看一下JsonObjectRequest的構(gòu)造函數(shù):
//jsonRequest:POST請求攜帶的參數(shù),可以為空,表示不攜帶參數(shù) public JsonObjectRequest(int method, String url, JSONObject jsonRequest, Listener<JSONObject> listener, ErrorListener errorListener) { super(method, url, (jsonRequest == null) ? null : jsonRequest.toString(), listener, errorListener); } //如果jsonRequest為空,默認(rèn)使用GET請求,否則使用POST public JsonObjectRequest(String url, JSONObject jsonRequest, Listener<JSONObject> listener, ErrorListener errorListener) { this(jsonRequest == null ? Method.GET : Method.POST, url, jsonRequest, listener, errorListener); }
和StringRequest一樣,遵循三步走原則:
RequestQueue mQueue = Volley.newRequestQueue(context); JsonObjectRequest jsonObjectRequest = new JsonObjectRequest("http://weather.51wnl.com/weatherinfo/GetMoreWeather?cityCode=101020100&weatherType=0", null, new Response.Listener<JSONObject>() { @Override public void onResponse(JSONObject response) { Toast.makeText(MainActivity.this, response.toString(), Toast.LENGTH_SHORT).show(); try { response = response.getJSONObject("weatherinfo"); showlog("city = " + response.getString("city")); showlog("weather1 = " + response.getString("weather1")); } catch (JSONException e) { e.printStackTrace(); } } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { showlog(error.getMessage()); } }); mQueue.add(jsonObjectRequest);
注意JsonObjectRequest的POST方式攜帶參數(shù)和StringRequest有些不同,上面StringRequest的方式在這里不起作用。需要下面方式實(shí)現(xiàn):
Map<String, String> params = new HashMap<String, String>(); params.put("name1", "value1"); params.put("name2", "value2"); JSONObject jsonRequest= new JSONObject(params); JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(Method.POST, url, jsonRequest, listener, errorListener)
上面我們請求的地址是中央天氣預(yù)報的上海天氣,看一下運(yùn)行效果:
可以看出,服務(wù)器返回給我們的數(shù)據(jù)確實(shí)是JSON格式的,并且onResponse()方法中攜帶的參數(shù)也正是一個JSONObject對象,之后只需要從JSONObject對象取出我們想要得到的那部分?jǐn)?shù)據(jù)就可以了。
3. 使用ImageRequest來請求圖片
首先來看一下ImageRequest的構(gòu)造函數(shù)
public ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight, Config decodeConfig, Response.ErrorListener errorListener) { super(Method.GET, url, errorListener); setRetryPolicy(new DefaultRetryPolicy(IMAGE_TIMEOUT_MS, IMAGE_MAX_RETRIES, IMAGE_BACKOFF_MULT)); mListener = listener; mDecodeConfig = decodeConfig; mMaxWidth = maxWidth; mMaxHeight = maxHeight; }
默認(rèn)的請求方式是GET,初始化方法需要傳入:圖片的url,一個響應(yīng)結(jié)果監(jiān)聽器,圖片的最大寬度,圖片的最大高度,圖片的顏色屬性,出錯響應(yīng)的監(jiān)聽器。
第三第四個參數(shù)分別用于指定允許圖片最大的寬度和高度,如果指定的網(wǎng)絡(luò)圖片的寬度或高度大于這里的最大值,則會對圖片“等比例”進(jìn)行壓縮,指定成0的話就表示不管圖片有多大,都不會進(jìn)行壓縮。第五個參數(shù)用于指定圖片的顏色屬性,Bitmap.Config下的幾個常量都可以在這里使用,其中ARGB_8888可以展示最好的顏色屬性,每個圖片像素占據(jù)4個字節(jié)的大小,而RGB_565則表示每個圖片像素占據(jù)2個字節(jié)大小。
三步走開始:
RequestQueue mQueue = Volley.newRequestQueue(context); ImageRequest imageRequest = new ImageRequest( "http://img.my.csdn.net/uploads/201308/31/1377949454_6367.jpg", new Response.Listener<Bitmap>() { @Override public void onResponse(Bitmap response) { image.setImageBitmap(response); } }, 0, 0, Config.RGB_565, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { image.setImageResource(R.drawable.default_image); } }); mQueue.add(imageRequest);
看運(yùn)行效果圖:
加載圖片— ImageLoader & NetworkImageView
Volley有沒有其他的,更好的方式來獲取圖片呢?當(dāng)然有的,比如ImageLoader、NetworkImageView這樣的對象,它們可以更加方便的獲取圖片。值得一提的是這兩個對象的內(nèi)部都是使用了ImageRequest進(jìn)行操作的,也就是說ImageRequest是本質(zhì)。
1. ImageLoader加載圖片
ImageLoader也可以用于加載網(wǎng)絡(luò)上的圖片,不過ImageLoader明顯要比ImageRequest更加高效,因?yàn)樗粌H可以幫我們對圖片進(jìn)行緩存,還可以過濾掉重復(fù)的鏈接,避免重復(fù)發(fā)送請求。
由于ImageLoader已經(jīng)不是繼承自Request的了,所以它的用法也和我們之前學(xué)到的內(nèi)容有所不同,總結(jié)起來大致可以分為以下四步:
創(chuàng)建一個RequestQueue對象。
創(chuàng)建一個ImageLoader對象。
獲取一個ImageListener對象。
調(diào)用ImageLoader的get()方法加載網(wǎng)絡(luò)上的圖片。
(1)創(chuàng)建一個RequestQueue對象
我們前面已經(jīng)寫過很多遍了,不再重復(fù)介紹了
(2)創(chuàng)建一個ImageLoader對象
示例代碼如下所示:
ImageLoader imageLoader = new ImageLoader(mQueue, new ImageCache() { @Override public void putBitmap(String url, Bitmap bitmap) { } @Override public Bitmap getBitmap(String url) { return null; } });
可以看到,ImageLoader的構(gòu)造函數(shù)接收兩個參數(shù),第一個參數(shù)就是RequestQueue對象,第二個參數(shù)是一個ImageCache對象(不能傳null?。?,這里的ImageCache就是為我們做內(nèi)存緩存用的,我們可以定制自己的實(shí)現(xiàn)方式,現(xiàn)在主流的實(shí)現(xiàn)是LruCache,關(guān)于LruCache可以參考我之前寫的一篇文章Android的緩存技術(shù):LruCache和DiskLruCache。
ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache()); //BitmapCache的實(shí)現(xiàn)類 public class BitmapCache implements ImageCache { private LruCache<String, Bitmap> mCache; public BitmapCache() { int maxSize = 10 * 1024 * 1024; mCache = new LruCache<String, Bitmap>(maxSize) { @Override protected int sizeOf(String key, Bitmap value) { return value.getRowBytes() * value.getHeight(); } }; @Override public Bitmap getBitmap(String url) { return mCache.get(url); } @Override public void putBitmap(String url, Bitmap bitmap) { mCache.put(url, bitmap); } }
(3)獲取一個ImageListener對象
ImageListener listener = ImageLoader.getImageListener(imageView, R.drawable.default_image, R.drawable.fail_image);
我們通過調(diào)用ImageLoader的getImageListener()方法能夠獲取到一個ImageListener對象,getImageListener()方法接收三個參數(shù),第一個參數(shù)指定用于顯示圖片的ImageView控件,第二個參數(shù)指定加載圖片的過程中顯示的圖片,第三個參數(shù)指定加載圖片失敗的情況下顯示的圖片。
(4)調(diào)用ImageLoader的get()方法加載網(wǎng)絡(luò)上的圖片
imageLoader.get("http://img.my.csdn.net/uploads/201309/01/1378037128_5291.jpg", listener);
get()方法接收兩個參數(shù),第一個參數(shù)就是圖片的URL地址,第二個參數(shù)則是剛剛獲取到的ImageListener對象。當(dāng)然,如果你想對圖片的大小進(jìn)行限制,也可以使用get()方法的重載,指定圖片允許的最大寬度和高度,如下所示:
imageLoader.get("http://img.my.csdn.net/uploads/201309/01/1378037128_5291.jpg", listener, 600, 600);
運(yùn)行一下程序點(diǎn)擊加載圖片,你將看到ImageView會先顯示一張默認(rèn)的加載過程中圖片,等到網(wǎng)絡(luò)上的圖片加載完成后,ImageView則會自動顯示該圖。如果我們用ImageLoader再次加載該圖片,會很快顯示出來而看不到默認(rèn)的加載過程中圖片,這是因?yàn)檫@次的圖片是從緩存中取的,速度很快。效果如下圖所示。
注:上面我們只是定制了內(nèi)存緩存,查看源碼,可以發(fā)現(xiàn)ImageLoader對圖片也進(jìn)行了硬盤緩存,我們在執(zhí)行g(shù)et()方法前可以通過imageLoader.setShouldCache(false);來取消硬盤緩存,如果你不進(jìn)行設(shè)置的話默認(rèn)是執(zhí)行硬盤緩存的。看看控制硬盤緩存的幾個方法:
public final boolean shouldCache() //查看是否已經(jīng)做了磁盤緩存。 void setShouldCache(boolean shouldCache)//設(shè)置是否運(yùn)行磁盤緩存,此方法需要在get方法前使用 public boolean isCached(String requestUrl, int maxWidth, int maxHeight)//判斷對象是否已經(jīng)被緩存,傳入url,還有圖片的最大寬高
2. NetworkImageView加載圖片
NetworkImageView繼承自ImageView,你可以認(rèn)為它是一個可以實(shí)現(xiàn)加載網(wǎng)絡(luò)圖片的imageview,十分簡單好用。這個控件在被從父控件分離的時候,會自動取消網(wǎng)絡(luò)請求的,即完全不用我們擔(dān)心相關(guān)網(wǎng)絡(luò)請求的生命周期問題。
NetworkImageView控件的用法大致可以分為以下五步:
創(chuàng)建一個RequestQueue對象。 創(chuàng)建一個ImageLoader對象。 在布局文件中添加一個NetworkImageView控件。 在代碼中獲取該控件的實(shí)例。 設(shè)置要加載的圖片地址。 <com.android.volley.toolbox.NetworkImageView android:id="@+id/network_image_view" android:layout_width="200dp" android:layout_height="200dp" android:layout_gravity="center_horizontal" /> /**創(chuàng)建RequestQueue以及ImageLoader對象**/ RequestQueue mQueue = Volley.newRequestQueue(context); ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache()); /**獲取NetworkImageView控件**/ NetworkImageView networkImageView = (NetworkImageView) findViewById(R.id.network_image_view); /**設(shè)置加載中顯示的圖片**/ networkImageView.setDefaultImageResId(R.drawable.default_image); /**加載失敗時顯示的圖片**/ networkImageView.setErrorImageResId(R.drawable.fail_image); /**設(shè)置目標(biāo)圖片的URL地址**/ networkImageView.setImageUrl("http://img.my.csdn.net/uploads/201309/01/1378037151_7904.jpg", imageLoader);
好了,就是這么簡單,現(xiàn)在重新運(yùn)行一下程序,你將看到和使用ImageLoader來加載圖片一模一樣的效果,這里我就不再截圖了。
NetworkImageView沒有提供任何設(shè)置圖片寬高的方法,這是由于它是一個控件,在加載圖片的時候它會自動獲取自身的寬高,然后對比網(wǎng)絡(luò)圖片的寬度,再決定是否需要對圖片進(jìn)行壓縮。也就是說,壓縮過程是在內(nèi)部完全自動化的,并不需要我們關(guān)心。
NetworkImageView最終會始終呈現(xiàn)給我們一張大小比控件尺寸略大的網(wǎng)絡(luò)圖片,因?yàn)樗鼤鶕?jù)控件寬高來等比縮放原始圖片,不會多占用任何一點(diǎn)內(nèi)存,這也是NetworkImageView最簡單好用的一點(diǎn)吧。
如果你不想對圖片進(jìn)行壓縮的話,只需要在布局文件中把NetworkImageView的layout_width和layout_height都設(shè)置成wrap_content就可以了,這樣它就會將該圖片的原始大小展示出來,不會進(jìn)行任何壓縮。
自定義Request
Volley中提供了幾個常用Request(StringRequest、JsonObjectRequest、JsonArrayRequest、ImageRequest),如果我們有自己特殊的需求,其實(shí)完全可以自定義自己的Request。
自定義Request之前,我們先來看看StringRequest的源碼實(shí)現(xiàn):
package com.android.volley.toolbox; public class StringRequest extends Request<String> { // 建立監(jiān)聽器來獲得響應(yīng)成功時返回的結(jié)果 private final Listener<String> mListener; // 傳入請求方法,url,成功時的監(jiān)聽器,失敗時的監(jiān)聽器 public StringRequest(int method, String url, Listener<String> listener, ErrorListener errorListener) { super(method, url, errorListener); // 初始化成功時的監(jiān)聽器 mListener = listener; } /** * Creates a new GET request. * 建立一個默認(rèn)的GET請求,調(diào)用了上面的構(gòu)造函數(shù) */ public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) { this(Method.GET, url, listener, errorListener); } @Override protected void deliverResponse(String response) { // 用監(jiān)聽器的方法來傳遞下響應(yīng)的結(jié)果 mListener.onResponse(response); } @Override protected Response<String> parseNetworkResponse(NetworkResponse response) { String parsed; try { // 調(diào)用了new String(byte[] data, String charsetName) 這個構(gòu)造函數(shù)來構(gòu)建String對象,將byte數(shù)組按照特定的編碼方式轉(zhuǎn)換為String對象,主要部分是data parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); } catch (UnsupportedEncodingException e) { parsed = new String(response.data); } return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response)); } }
首先StringRequest是繼承自Request類的,Request可以指定一個泛型類,這里指定的當(dāng)然就是String了,接下來StringRequest中提供了兩個有參的構(gòu)造函數(shù),參數(shù)包括請求類型,請求地址,以及響應(yīng)回調(diào)等。但需要注意的是,在構(gòu)造函數(shù)中一定要調(diào)用super()方法將這幾個參數(shù)傳給父類,因?yàn)镠TTP的請求和響應(yīng)都是在父類中自動處理的。
另外,由于Request類中的deliverResponse()和parseNetworkResponse()是兩個抽象方法,因此StringRequest中需要對這兩個方法進(jìn)行實(shí)現(xiàn)。deliverResponse()方法中的實(shí)現(xiàn)很簡單,僅僅是調(diào)用了mListener中的onResponse()方法,并將response內(nèi)容傳入即可,這樣就可以將服務(wù)器響應(yīng)的數(shù)據(jù)進(jìn)行回調(diào)了。parseNetworkResponse()方法中則是對服務(wù)器響應(yīng)的數(shù)據(jù)進(jìn)行解析,其中數(shù)據(jù)是以字節(jié)的形式存放在NetworkResponse的data變量中的,這里將數(shù)據(jù)取出然后組裝成一個String,并傳入Response的success()方法中即可。
1. 自定義XMLRequest
了解了StringRequest的實(shí)現(xiàn)原理,下面我們就可以動手來嘗試實(shí)現(xiàn)一下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); } }
可以看到,其實(shí)并沒有什么太多的邏輯,基本都是仿照StringRequest寫下來的,XMLRequest也是繼承自Request類的,只不過這里指定的泛型類是XmlPullParser,說明我們準(zhǔn)備使用Pull解析的方式來解析XML。在parseNetworkResponse()方法中,先是將服務(wù)器響應(yīng)的數(shù)據(jù)解析成一個字符串,然后設(shè)置到XmlPullParser對象中,在deliverResponse()方法中則是將XmlPullParser對象進(jìn)行回調(diào)。
下面我們嘗試使用這個XMLRequest來請求一段XML格式的數(shù)據(jù),http://flash.weather.com.cn/wmaps/xml/china.xml這個接口會將中國所有的省份數(shù)據(jù)以XML格式進(jìn)行返回,如下所示:
XMLRequest xmlRequest = new XMLRequest("http://flash.weather.com.cn/wmaps/xml/china.xml", new Response.Listener<XmlPullParser>() { @Override public void onResponse(XmlPullParser response) { try { int eventType = response.getEventType(); while (eventType != XmlPullParser.END_DOCUMENT) { switch (eventType) { case XmlPullParser.START_TAG: String nodeName = response.getName(); if ("city".equals(nodeName)) { String pName = response.getAttributeValue(0); String cName = response.getAttributeValue(2); showlog("省份:" + pName + " 城市:" + cName); } break; } eventType = response.next(); } } catch (XmlPullParserException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { showlog(error.getMessage()); } }); mQueue.add(xmlRequest);
2. 自定義GsonRequest
JsonRequest的數(shù)據(jù)解析是利用Android本身自帶的JSONObject和JSONArray來實(shí)現(xiàn)的,配合使用JSONObject和JSONArray就可以解析出任意格式的JSON數(shù)據(jù)。不過也許你會覺得使用JSONObject還是太麻煩了,還有很多方法可以讓JSON數(shù)據(jù)解析變得更加簡單,比如說GSON對象。遺憾的是,Volley中默認(rèn)并不支持使用自家的GSON來解析數(shù)據(jù),不過沒有關(guān)系,通過上面的學(xué)習(xí),相信你已經(jīng)知道了自定義一個Request是多么的簡單,那么下面我們就來舉一反三一下,自定義一個GsonRequest。
首先我們需要把GSON的jar包導(dǎo)入到項(xiàng)目當(dāng)中,接著定義一個GsonRequest繼承自Request,代碼如下所示:
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); } }
GsonRequest是繼承自Request類的,并且同樣提供了兩個構(gòu)造函數(shù)。在parseNetworkResponse()方法中,先是將服務(wù)器響應(yīng)的數(shù)據(jù)解析出來,然后通過調(diào)用Gson的fromJson方法將數(shù)據(jù)組裝成對象。在deliverResponse方法中仍然是將最終的數(shù)據(jù)進(jìn)行回調(diào)。
下面我們就來測試一下這個GsonRequest能不能夠正常工作吧,同樣調(diào)用http://www.weather.com.cn/data/sk/101020100.html這個接口可以得到一段JSON格式的天氣數(shù)據(jù),如下所示:
{"weatherinfo":{"city":"上海","city_en":"","cityid":101020100,"date":"","date_y":"2016年09月20日","fchh":0,"fl1":"","fl2":"","fl3":"","fl4":"","fl5":"","fl6":"","fx1":"","fx2":"","img1":"1","img10":"1","img11":"1","img12":"1","img2":"1","img3":"1","img4":"1","img5":"1","img6":"1","img7":"1","img8":"1","img9":"1","img_single":0,"img_title1":"","img_title10":"","img_title11":"","img_title12":"","img_title2":"","img_title3":"","img_title4":"","img_title5":"","img_title6":"","img_title7":"","img_title8":"","img_title9":"","img_title_single":"","index":"","index48":"","index48_d":"","index48_uv":"","index_ag":"","index_cl":"","index_co":"","index_d":"","index_ls":"","index_tr":"","index_uv":"","index_xc":"","st1":0,"st2":0,"st3":0,"st4":0,"st5":0,"st6":0,"temp1":"20℃~28℃","temp2":"20℃~26℃","temp3":"19℃~26℃","temp4":"21℃~26℃","temp5":"23℃~28℃","temp6":"22℃~27℃","tempF1":"","tempF2":"","tempF3":"","tempF4":"","tempF5":"","tempF6":"","weather1":"多云","weather2":"多云","weather3":"多云","weather4":"多云","weather5":"多云","weather6":"多云","week":"","wind1":"","wind2":"","wind3":"","wind4":"","wind5":"","wind6":""}}
我們需要使用對象的方式將這段JSON字符串表示出來。下面新建兩個Bean文件:
public class Weather { public WeatherInfo weatherinfo; } public class WeatherInfo { public String city; public String cityid; public String date_y; public String temp1; public String weather1; }
下面就是用GsonRequest請求json數(shù)據(jù)了
GsonRequest<Weather> gsonRequest = new GsonRequest<Weather>( "http://weather.51wnl.com/weatherinfo/GetMoreWeather?cityCode=101020100&weatherType=0", Weather.class, new Response.Listener<Weather>() { @Override public void onResponse(Weather weather) { WeatherInfo weatherInfo = weather.weatherinfo; showlog("city is " + weatherInfo.city); showlog("cityid is " + weatherInfo.cityid); showlog("date_y is " + weatherInfo.date_y); showlog("temp1 is " + weatherInfo.temp1); showlog("weather1 is " + weatherInfo.weather1); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { showlog(error.getMessage()); } }); mQueue.add(gsonRequest);
這里onResponse()方法的回調(diào)中直接返回了一個Weather對象,我們通過它就可以得到WeatherInfo對象,接著就能從中取出JSON中的相關(guān)數(shù)據(jù)了。運(yùn)行一下程序,打印Log如下:
3. 自定義GsonRequestWithAuth
上面自定義的Request并沒有攜帶參數(shù),如果我們訪問服務(wù)器時需要傳參呢?譬如通過客戶端訪問服務(wù)器,服務(wù)器對客戶端進(jìn)行身份校驗(yàn)后,返回用戶信息,客戶端直接拿到對象。
先寫B(tài)ean文件:
public class User { private String name; private int age; }
自定義GsonRequestWithAuth:
public class GsonRequestWithAuth<T> extends Request<T> { private final Gson gson = new Gson(); private final Class<T> clazz; private final Listener<T> listener; private Map<String, String> mHeader = new HashMap<String, String>(); private String mBody; /** http請求編碼方式 */ private static final String PROTOCOL_CHARSET = "utf-8"; /** 設(shè)置訪問自己服務(wù)器時必須傳遞的參數(shù),密鑰等 */ static { mHeader.put("APP-Key", "Key"); mHeader.put("APP-Secret", "Secret"); } /** * @param url * @param clazz 我們最終的轉(zhuǎn)化類型 * @param listener * @param appendHeader 附加頭數(shù)據(jù) * @param body 請求附帶消息體 * @param errorListener */ public GsonRequestWithAuth(String url, Class<T> clazz, Listener<T> listener, Map<String, String> appendHeader, String body, ErrorListener errorListener) { super(Method.POST, url, errorListener); this.clazz = clazz; this.listener = listener; mHeader.putAll(appendHeader); mBody = body; } @Override public Map<String, String> getHeaders() throws AuthFailureError { // 默認(rèn)返回 return Collections.emptyMap(); return mHeader; } @Override public byte[] getBody() { try { return mBody == null ? null : mBody.getBytes(PROTOCOL_CHARSET); } catch (UnsupportedEncodingException uee) { VolleyLog.wtf("Unsupported Encoding while trying to get the bytes of %s using %s", mUserName, PROTOCOL_CHARSET); return null; } } @Override protected void deliverResponse(T response) { listener.onResponse(response); } @Override protected Response<T> parseNetworkResponse(NetworkResponse response) { try { /** 得到返回的數(shù)據(jù) */ String jsonStr = new String(response.data, HttpHeaderParser.parseCharset(response.headers)); /** 轉(zhuǎn)化成對象 */ return Response.success(gson.fromJson(jsonStr, clazz), HttpHeaderParser.parseCacheHeaders(response)); } catch (UnsupportedEncodingException e) { return Response.error(new ParseError(e)); } catch (JsonSyntaxException e) { return Response.error(new ParseError(e)); } } }
服務(wù)器代碼:
public class TestServlet extends HttpServlet { public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { this.doPost(request, response); } public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setCharacterEncoding("utf-8"); /**獲取APP-Key和APP-Secret */ String appKey = request.getHeader("APP-Key"); String appSecret = request.getHeader("APP-Secret"); /**獲取用戶名、密碼 */ String username = request.getHeader("username"); String password = request.getHeader("password"); /**獲取消息體 */ int size = request.getContentLength(); InputStream is = request.getInputStream(); byte[] reqBodyBytes = readBytes(is, size); String body = new String(reqBodyBytes); if ("admin".equals(username) && "123".equals(password) && "getUserInfo".equals(body)) { response.setContentType("text/plain;charset=utf-8"); PrintWriter out = response.getWriter(); out.print("{\"name\":\"Watson\",\"age\":28}"); out.flush(); } } }
使用GsonRequestWithAuth和服務(wù)器交互請求信息:
Map<String, String> appendHeader = new HashMap<String, String>(); appendHeader.put("username", "admin"); appendHeader.put("password", "123"); String url = "http://172.27.35.1:8080/webTest/TestServlet"; GsonRequestWithAuth<User> userRequest = new GsonRequestWithAuth<User>(url, User.class, new Listener<User>() { @Override public void onResponse(User response) { Log.e("TAG", response.toString()); } }, appendHeader, "getUserInfo", null); mQueue.add(userRequest);
延伸:
看到?jīng)]有,我們上面寫服務(wù)器端代碼時,有一句代碼是設(shè)置服務(wù)器返回數(shù)據(jù)的字符集為UTF-8
response.setContentType("text/plain;charset=utf-8");
大部分服務(wù)器端都會在返回數(shù)據(jù)的header中指定字符集,如果在服務(wù)器端沒有指定字符集那么就會默認(rèn)使用 ISO-8859-1 字符集。
ISO-8859-1的別名叫做Latin1。這個字符集支持部分是用于歐洲的語言,不支持中文,這就會導(dǎo)致服務(wù)器返回的中文數(shù)據(jù)亂碼,很不能理解為什么將這個字符集作為默認(rèn)的字符集。Volley這個框架可是要用在網(wǎng)絡(luò)通信的環(huán)境中的。吐槽也沒有用,我們來看一下如何來解決中文亂碼的問題。有以下幾種解決方式:
在服務(wù)器的返回的數(shù)據(jù)的header的中contentType加上charset=UTF-8的聲明。
當(dāng)你無法修改服務(wù)器程序的時候,可以定義一個新的子類。覆蓋parseNetworkResponse這個方法,直接使用UTF-8對服務(wù)器的返回數(shù)據(jù)進(jìn)行轉(zhuǎn)碼。
public class CharsetStringRequest extends StringRequest { public CharsetStringRequest(String url, Listener<String> listener, ErrorListener errorListener) { super(url, listener, errorListener); } public CharsetStringRequest(int method, String url, Listener<String> listener, 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"); //在此處強(qiáng)制utf-8編碼 } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return Response.success(str, HttpHeaderParser.parseCacheHeaders(response)); } }
使用CharsetStringRequest請求數(shù)據(jù):
CharsetStringRequest stringRequest = new CharsetStringRequest("http://www.weather.com.cn/data/sk/101010100.html", new Response.Listener<String>() { @Override public void onResponse(String response) { showlog(response); } }, new Response.ErrorListener() { @Override public void onErrorResponse(VolleyError error) { showlog(error.getMessage()); } }); mQueue.add(userRequest);
Volley架構(gòu)解析
1. 總體設(shè)計圖
上面是 Volley 的總體設(shè)計圖,主要是通過兩種Diapatch Thread不斷從RequestQueue中取出請求,根據(jù)是否已緩存調(diào)用Cache或Network這兩類數(shù)據(jù)獲取接口之一,從內(nèi)存緩存或是服務(wù)器取得請求的數(shù)據(jù),然后交由ResponseDelivery去做結(jié)果分發(fā)及回調(diào)處理。
2. Volley中的概念
簡單介紹一些概念,在詳細(xì)設(shè)計中會仔細(xì)介紹。
Volley 的調(diào)用比較簡單,通過 newRequestQueue(…) 函數(shù)新建并啟動一個請求隊(duì)列RequestQueue后,只需要往這個RequestQueue不斷 add Request 即可。
Volley:Volley 對外暴露的 API,通過 newRequestQueue(…) 函數(shù)新建并啟動一個請求隊(duì)列RequestQueue。
Request:表示一個請求的抽象類。StringRequest、JsonRequest、ImageRequest都是它的子類,表示某種類型的請求。
RequestQueue:表示請求隊(duì)列,里面包含一個CacheDispatcher(用于處理走緩存請求的調(diào)度線程)、NetworkDispatcher數(shù)組(用于處理走網(wǎng)絡(luò)請求的調(diào)度線程),一個ResponseDelivery(返回結(jié)果分發(fā)接口),通過 start() 函數(shù)啟動時會啟動CacheDispatcher和NetworkDispatchers。
CacheDispatcher:一個線程,用于調(diào)度處理走緩存的請求。啟動后會不斷從緩存請求隊(duì)列中取請求處理,隊(duì)列為空則等待,請求處理結(jié)束則將結(jié)果傳遞給ResponseDelivery去執(zhí)行后續(xù)處理。當(dāng)結(jié)果未緩存過、緩存失效或緩存需要刷新的情況下,該請求都需要重新進(jìn)入NetworkDispatcher去調(diào)度處理。
NetworkDispatcher:一個線程,用于調(diào)度處理走網(wǎng)絡(luò)的請求。啟動后會不斷從網(wǎng)絡(luò)請求隊(duì)列中取請求處理,隊(duì)列為空則等待,請求處理結(jié)束則將結(jié)果傳遞給ResponseDelivery去執(zhí)行后續(xù)處理,并判斷結(jié)果是否要進(jìn)行緩存。
ResponseDelivery:返回結(jié)果分發(fā)接口,目前只有基于ExecutorDelivery的在入?yún)?handler 對應(yīng)線程內(nèi)進(jìn)行分發(fā)。
HttpStack:處理 Http 請求,返回請求結(jié)果。目前 Volley 中有基于 HttpURLConnection 的HurlStack和 基于 Apache HttpClient 的HttpClientStack。
Network:調(diào)用HttpStack處理請求,并將結(jié)果轉(zhuǎn)換為可被ResponseDelivery處理的NetworkResponse。
Cache:緩存請求結(jié)果,Volley 默認(rèn)使用的是基于 sdcard 的DiskBasedCache。NetworkDispatcher得到請求結(jié)果后判斷是否需要存儲在 Cache,CacheDispatcher會從 Cache 中取緩存結(jié)果。
3. 流程圖
Volley 請求流程圖
其中藍(lán)色部分代表主線程,綠色部分代表緩存線程,橙色部分代表網(wǎng)絡(luò)線程。我們在主線程中調(diào)用RequestQueue的add()方法來添加一條網(wǎng)絡(luò)請求,這條請求會先被加入到緩存隊(duì)列當(dāng)中,如果發(fā)現(xiàn)可以找到相應(yīng)的緩存結(jié)果就直接讀取緩存并解析,然后回調(diào)給主線程。如果在緩存中沒有找到結(jié)果,則將這條請求加入到網(wǎng)絡(luò)請求隊(duì)列中,然后處理發(fā)送HTTP請求,解析響應(yīng)結(jié)果,寫入緩存,并回調(diào)主線程。
4. 源碼分析
使用Volley的第一步,首先要調(diào)用Volley.newRequestQueue(context)方法來獲取一個RequestQueue對象,那么我們自然要從這個方法開始看起了,代碼如下所示:
public static RequestQueue newRequestQueue(Context context) { return newRequestQueue(context, null); } 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) { } //如果stack是等于null的,則去創(chuàng)建一個HttpStack對象,手機(jī)系統(tǒng)版本號是大于9的,則創(chuàng)建一個HurlStack的實(shí)例,否則就創(chuàng)建一個HttpClientStack的實(shí)例,HurlStack的內(nèi)部就是使用HttpURLConnection進(jìn)行網(wǎng)絡(luò)通訊的,而HttpClientStack的內(nèi)部則是使用HttpClient進(jìn)行網(wǎng)絡(luò)通訊的 if (stack == null) { if (Build.VERSION.SDK_INT >= 9) { stack = new HurlStack(); } else { stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent)); } } //創(chuàng)建了一個Network對象,它是用于根據(jù)傳入的HttpStack對象來處理網(wǎng)絡(luò)請求的 Network network = new BasicNetwork(stack); RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network); queue.start(); return queue; }
最終會走到RequestQueue的start()方法,然后將RequestQueue返回。去看看RequestQueue的start()方法內(nèi)部到底執(zhí)行了什么?
public void start() { stop(); // Make sure any currently running dispatchers are stopped. //先是創(chuàng)建了一個CacheDispatcher的實(shí)例,然后調(diào)用了它的start()方法 mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery); mCacheDispatcher.start(); //for循環(huán)創(chuàng)建NetworkDispatcher的實(shí)例,并分別調(diào)用它們的start()方法 for (int i = 0; i < mDispatchers.length; i++) { NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork, mCache, mDelivery); mDispatchers[i] = networkDispatcher; networkDispatcher.start(); } }
CacheDispatcher和NetworkDispatcher都是繼承自Thread的,而默認(rèn)情況下for循環(huán)會執(zhí)行四次,也就是說當(dāng)調(diào)用了Volley.newRequestQueue(context)之后,就會有五個線程一直在后臺運(yùn)行,不斷等待網(wǎng)絡(luò)請求的到來,其中CacheDispatcher是緩存線程,NetworkDispatcher是網(wǎng)絡(luò)請求線程。
得到了RequestQueue之后,我們只需要構(gòu)建出相應(yīng)的Request,然后調(diào)用RequestQueue的add()方法將Request傳入就可以完成網(wǎng)絡(luò)請求操作了,來看看add()方法吧:
public <T> Request<T> add(Request<T> 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"); //判斷當(dāng)前的請求是否可以緩存,如果不能緩存則直接將這條請求加入網(wǎng)絡(luò)請求隊(duì)列 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 { //當(dāng)前的請求可以緩存的話則將這條請求加入緩存隊(duì)列 mWaitingRequests.put(cacheKey, null); mCacheQueue.add(request); } return request; } }
在默認(rèn)情況下,每條請求都是可以緩存的,當(dāng)然我們也可以調(diào)用Request的setShouldCache(false)方法來改變這一默認(rèn)行為。既然默認(rèn)每條請求都是可以緩存的,自然就被添加到了緩存隊(duì)列中,于是一直在后臺等待的緩存線程就要開始運(yùn)行起來了,我們看下CacheDispatcher中的run()方法
public class CacheDispatcher extends Thread { …… @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(); while (true) { try { // Get a request from the cache triage queue, blocking until // at least one is available. final Request<?> request = mCacheQueue.take(); 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; } //嘗試從緩存當(dāng)中取出響應(yīng)結(jié)果 Cache.Entry entry = mCache.get(request.getCacheKey()); if (entry == null) { request.addMarker("cache-miss"); // 如何為空的話則把這條請求加入到網(wǎng)絡(luò)請求隊(duì)列中 mNetworkQueue.put(request); continue; } // 如果不為空的話再判斷該緩存是否已過期,如果已經(jīng)過期了則同樣把這條請求加入到網(wǎng)絡(luò)請求隊(duì)列中 if (entry.isExpired()) { request.addMarker("cache-hit-expired"); request.setCacheEntry(entry); mNetworkQueue.put(request); continue; } //沒有過期就認(rèn)為不需要重發(fā)網(wǎng)絡(luò)請求,直接使用緩存中的數(shù)據(jù)即可 request.addMarker("cache-hit"); //對數(shù)據(jù)進(jìn)行解析 Response<?> response = request.parseNetworkResponse( new NetworkResponse(entry.data, entry.responseHeaders)); request.addMarker("cache-hit-parsed"); if (!entry.refreshNeeded()) { // Completely unexpired cache hit. Just deliver the response. mDelivery.postResponse(request, response); } else { // Soft-expired cache hit. We can deliver the cached response, // but we need to also send the request to the network for // refreshing. 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. mDelivery.postResponse(request, response, new Runnable() { @Override public void run() { try { mNetworkQueue.put(request); } catch (InterruptedException e) { // Not much we can do about this. } } }); } } catch (InterruptedException e) { // We may have been interrupted because it was time to quit. if (mQuit) { return; } continue; } } } }
來看一下NetworkDispatcher中是怎么處理網(wǎng)絡(luò)請求隊(duì)列的
public class NetworkDispatcher extends Thread { …… @Override public void run() { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); Request<?> request; while (true) { try { // Take a request from the queue. 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); //調(diào)用Network的performRequest()方法來去發(fā)送網(wǎng)絡(luò)請求 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()) { request.finish("not-modified"); continue; } // Parse the response here on the worker thread. 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) { 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)); } } } }
調(diào)用Network的performRequest()方法來去發(fā)送網(wǎng)絡(luò)請求 ,而Network是一個接口,這里具體的實(shí)現(xiàn)是BasicNetwork,我們來看下它的performRequest()方法
public class BasicNetwork implements Network { …… @Override public NetworkResponse performRequest(Request<?> request) throws VolleyError { long requestStart = SystemClock.elapsedRealtime(); while (true) { HttpResponse httpResponse = null; byte[] responseContents = null; Map<String, String> responseHeaders = new HashMap<String, String>(); try { // Gather headers. Map<String, String> headers = new HashMap<String, String>(); addCacheHeaders(headers, request.getCacheEntry()); //調(diào)用了HttpStack的performRequest()方法,這里的HttpStack就是在一開始調(diào)用newRequestQueue()方法是創(chuàng)建的實(shí)例,默認(rèn)情況下如果系統(tǒng)版本號大于9就創(chuàng)建的HurlStack對象,否則創(chuàng)建HttpClientStack對象 httpResponse = mHttpStack.performRequest(request, headers); StatusLine statusLine = httpResponse.getStatusLine(); int statusCode = statusLine.getStatusCode(); responseHeaders = convertHeaders(httpResponse.getAllHeaders()); // Handle cache validation. if (statusCode == HttpStatus.SC_NOT_MODIFIED) { //將服務(wù)器返回的數(shù)據(jù)組裝成一個NetworkResponse對象進(jìn)行返回 return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, request.getCacheEntry() == null ? null : request.getCacheEntry().data, responseHeaders, true); } // Some responses such as 204s do not have content. We must check. if (httpResponse.getEntity() != null) { 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); } catch (Exception e) { …… } } } }
在NetworkDispatcher中收到了NetworkResponse這個返回值后又會調(diào)用Request的parseNetworkResponse()方法來解析NetworkResponse中的數(shù)據(jù),以及將數(shù)據(jù)寫入到緩存,這個方法的實(shí)現(xiàn)是交給Request的子類來完成的,因?yàn)椴煌N類的Request解析的方式也肯定不同。還記得自定義Request的方式嗎?其中parseNetworkResponse()這個方法就是必須要重寫的。
在解析完了NetworkResponse中的數(shù)據(jù)之后,又會調(diào)用ExecutorDelivery的postResponse()方法來回調(diào)解析出的數(shù)據(jù)
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) { request.markDelivered(); request.addMarker("post-response"); mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable)); }
在mResponsePoster的execute()方法中傳入了一個ResponseDeliveryRunnable對象,就可以保證該對象中的run()方法就是在主線程當(dāng)中運(yùn)行的了,我們看下run()方法中的代碼是什么樣的:
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() { // If this request has canceled, finish it and don't deliver. if (mRequest.isCanceled()) { mRequest.finish("canceled-at-delivery"); return; } // Deliver a normal response or error, depending. if (mResponse.isSuccess()) { mRequest.deliverResponse(mResponse.result); } 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(); } } }
其中在第22行調(diào)用了Request的deliverResponse()方法,有沒有感覺很熟悉?沒錯,這個就是我們在自定義Request時需要重寫的另外一個方法,每一條網(wǎng)絡(luò)請求的響應(yīng)都是回調(diào)到這個方法中,最后我們再在這個方法中將響應(yīng)的數(shù)據(jù)回調(diào)到Response.Listener的onResponse()方法中就可以了。
- Android 中Volley二次封裝并實(shí)現(xiàn)網(wǎng)絡(luò)請求緩存
- Android中volley封裝實(shí)踐記錄
- Android Volley框架使用方法詳解
- Android的HTTP類庫Volley入門學(xué)習(xí)教程
- Android Volley框架使用源碼分享
- Android中Volley框架下保持會話方法
- Android 開發(fā)中Volley詳解及實(shí)例
- android 網(wǎng)絡(luò)請求庫volley方法詳解
- Android 網(wǎng)絡(luò)請求框架Volley實(shí)例詳解
- Android中volley封裝實(shí)踐記錄(二)
相關(guān)文章
Android中通過AsyncTask類來制作炫酷進(jìn)度條的實(shí)例教程
這篇文章主要介紹了Android中通過AsyncTask來制作炫酷進(jìn)度條的實(shí)例教程,借助AsyncTask類的線程操作方法來管理異步任務(wù),需要的朋友可以參考下2016-05-05Android AIDL實(shí)現(xiàn)兩個APP間的跨進(jìn)程通信實(shí)例
這篇文章主要為大家詳細(xì)介紹了Android AIDL實(shí)現(xiàn)兩個APP間的跨進(jìn)程通信實(shí)例,具有一定的參考價值,感興趣的小伙伴們可以參考一下2018-04-04詳解Android中ViewPager的PagerTabStrip子控件的用法
這篇文章主要介紹了Android中ViewPager的PagerTabStrip子控件的用法,PagerTabStrip與PagerTitleStrip的用法基本相同,文中舉了兩個詳細(xì)的例子,需要的朋友可以參考下2016-03-03深入解讀Android的內(nèi)部進(jìn)程通信接口AIDL
這篇文章主要介紹了Android的內(nèi)部進(jìn)程通信接口AIDL,重點(diǎn)講解了進(jìn)程間的通信與AIDL內(nèi)存使用方面的parcelable接口的實(shí)現(xiàn),需要的朋友可以參考下2016-04-04Android 開機(jī)充電圖標(biāo)和充電動畫效果
這篇文章主要介紹了Android 開機(jī)充電圖標(biāo)和充電動畫效果,本文通過實(shí)例代碼給大家介紹的非常詳細(xì),具有一定的參考借鑒價值,需要的朋友可以參考下2019-12-12Android8.1 通過黑名單屏蔽系統(tǒng)短信和來電功能
最近小編接到一個新的需求,需要將8.1 設(shè)備的來電功能和短信功能都屏蔽掉,特殊產(chǎn)品就是特殊定制。接下來通過本文給大家介紹Android8.1 通過黑名單屏蔽系統(tǒng)短信和來電功能,需要的朋友參考下吧2019-05-05