Volley解析（一）--Volley的使用
Volley解析（一）--Volley的使用
Volley 是一个HTTP协议的网络请求框架
Volley的优势：
- 自动安排网络请求
- 支持多个并发网络连接
- 具有标准HTTP缓存一致性的透明磁盘和内存响应缓存
- 支持请求优先级
- 支持取消请求api。可以取消单个请求，也可以设置要取消的请求的块或范围。
- 定制方便，支持失败重试和回退
- 强排序，可以轻松地从网络异步获取的数据中正确填充UI。
- 具有调试和跟踪工具
它易于与任何协议集成，支持原始字符串、图像和JSON的解析。通过提供你需要的功能的内置支持，Volley使你从写样板代码脱身，可以让你专注于特定于应用程序的逻辑。
Volley的优势劣势都在于使用内存缓存！！
Volley擅长的场景：
Volley擅长用于填充UI的RPC类型操作，如将搜索结果页作为结构化数据抓取。适合短小，频繁的请求。因为解析过程结果会保留在内存。
Volley不擅长的场景：
Volley不适合大型下载或流媒体操作，因为在解析过程中保留了内存中的所有响应。
使用newRequestQueue简单发送请求
三步完成发送请求：
- 初始化请求队列
- 构造请求对象
- 请求对象加入请求队列
Volley提供了一个方便的方法volley.newrequestqueue为用户配置一个请求队列.设置使用默认值，并启动队列。
final TextView mTextView = (TextView) findViewById(R.id.text);
...
// Instantiate the RequestQueue. 初始化请求队列
RequestQueue queue = Volley.newRequestQueue(this);
String url ="http://www.google.com";
// Request a string response from the provided URL.构造请求对象
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Display the first 500 characters of the response string.
mTextView.setText("Response is: "+ response.substring(0,500));
//UI线程
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
mTextView.setText("That didn't work!");
//UI线程
}
});
// Add the request to the RequestQueue.
queue.add(stringRequest);
Volley总是在主线上传递解析的响应。在主线程中运行可以方便与接收的数据填充的UI控件，你可以直接从响应随意修改UI控件。但是它对库提供的许多重要语义尤其重要，特别是与取消请求相关的。
一旦添加请求，它就通过管道移动，得到服务，并对其原始响应进行解析。
当调用add，Volley就会跑一个cache线程和一个网络分发线程池（默认是4个线程的线程池）。
当你添加一个请求队列，它会进缓存的线程：
如果请求可以从高速缓存中得到服务，缓存响应将在高速缓存线程上解析，解析后的响应将在主线程上传递。
如果请求不能从缓存中进行服务，那么它就被放置在网络队列中。第一个可用的网络线程接收来自队列的请求，执行HTTP事务，解析工作线程上的响应，将响应写入高速缓存，并将解析后的响应返回到主线程进行传输。
注意，诸如阻塞I/O和解析/解码等昂贵的操作是在工作线程上完成的。可以从任何线程添加请求，但响应总是在主线程上传递。
取消一个请求
这种场景是比较常见的。比如在界面销毁之前，请求就需要取消。
1 最简单的一个方式就是在请求的对象上直接调cancel()方法：
stringRequest.cancel();
一旦取消，Volley保证的响应Response处理程序将永远不会被调用。这意味着你可以取消你所有的请求在onstop()方法。而且在响应处理方法里不用检查getActivity() == null，也不用关心onSaveInstanceState()有没有被调用，或者去有意其他的一些防御性代码。
这样带来的好处是巨大的，意味着Rrsponse中的任何操作在cancel以后不会执行，那就不会有意外发生。
要利用这种行为，通常需要跟踪所有正在执行的请求，以便在适当的时候取消它们。
有一个更简单的方法：可以将标记对象与每个请求关联起来。然后可以使用此标记来提供取消请求的范围。
可以将所有请求标记为正在进行的界面。然后再onStop中调requestQueue.cancelAll(this)。同样，你也可以用tag标记把所有的缩略图图片请求和ViewPager中各个相关的tab页关联起来。在切换的时候就取消前一个tab的请求们
2 批量范围取消请求
//先标记
public static final String TAG = "MyTag";
StringRequest stringRequest; // Assume this exists.
RequestQueue mRequestQueue; // Assume this exists.
// Set the tag on the request.
stringRequest.setTag(TAG);
// Add the request to the RequestQueue.
mRequestQueue.add(stringRequest);
//再在onStop方法中取消
@Override
protected void onStop () {
super.onStop();
if (mRequestQueue != null) {
mRequestQueue.cancelAll(TAG);
}
}
注意：要谨慎嗲用cancel方法.假设这样一个场景：你要根据请求的返回结果做下一步工作。而这步的工作在成功或者失败的时候都要执行。那如果取消掉了请求。这段必须执行的逻辑就永远执行不到了。
再次说明：cancel后 ，response处理程序将不会被调用
脱离newRequestQueue自己配置一个请求队列
Volley.newRequestQueue 简化了请求队列的构造。但如果要自定义请求队列就要自己配置。一个网络请求队列需要两个工具：网络执行请求的运输，和缓存处理缓存。
Volley toolbox有标准的实现。diskbasedcache采用文件/响应缓存一一对应的方式提供一个内存索引。
BasicNetwork提供了一个基于首选的HTTP客户端的网络传输。默认是HttpUrlConnection API9一下是HttpClient
RequestQueue mRequestQueue;
// Instantiate the cache
Cache cache = new DiskBasedCache(getCacheDir(), 1024 * 1024); // 1MB cap
// Set up the network to use HttpURLConnection as the HTTP client.
Network network = new BasicNetwork(new HurlStack());
// Instantiate the RequestQueue with the cache and network.
mRequestQueue = new RequestQueue(cache, network);
// Start the queue
mRequestQueue.start();
String url ="http://www.example.com";
// Formulate the request and handle the response.
StringRequest stringRequest = new StringRequest(Request.Method.GET, url,
new Response.Listener<String>() {
@Override
public void onResponse(String response) {
// Do something with the response
}
},
new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// Handle error
}
});
// Add the request to the RequestQueue.
mRequestQueue.add(stringRequest);
// ...
如果支持做一次性的请求操作那用Volley.newRequestQueue就行了。然后再相应返回或者错误以后调用RequestQueue的stop把请求的线程池停掉就行了。
但是通常情况的场景是在app的整个运行期内都要维持这个队列，把RequestQueue作为一个单例用。
单例模式的RequestQueue
最直接的方式就是在Application的onCreate中构建RequestQueue对象。但是这样做并不是最好的。
最好的方式就是用静态单例更模块化的方式提供相同的功能
一个关键的概念是，所以必须实例化时使用ApplicationContext，不是一个ActivityContext。这样是为了保证RequestQueue的生命周期和app存货的时间是一样的。
public class MySingleton {
private static MySingleton mInstance;
private RequestQueue mRequestQueue;
private ImageLoader mImageLoader;
private static Context mCtx;
private MySingleton(Context context) {
mCtx = context;
mRequestQueue = getRequestQueue();
mImageLoader = new ImageLoader(mRequestQueue,
new ImageLoader.ImageCache() {
private final LruCache<String, Bitmap>
cache = new LruCache<String, Bitmap>(20);
@Override
public Bitmap getBitmap(String url) {
return cache.get(url);
}
@Override
public void putBitmap(String url, Bitmap bitmap) {
cache.put(url, bitmap);
}
});
}
public static synchronized MySingleton getInstance(Context context) {
if (mInstance == null) {
mInstance = new MySingleton(context);
}
return mInstance;
}
public RequestQueue getRequestQueue() {
if (mRequestQueue == null) {
// getApplicationContext() is key, it keeps you from leaking the
// Activity or BroadcastReceiver if someone passes one in.
mRequestQueue = Volley.newRequestQueue(mCtx.getApplicationContext());
}
return mRequestQueue;
}
public <T> void addToRequestQueue(Request<T> req) {
getRequestQueue().add(req);
}
public ImageLoader getImageLoader() {
return mImageLoader;
}
}
这个单例中发送请求的用法：
// Get a RequestQueue
RequestQueue queue = MySingleton.getInstance(this.getApplicationContext()).
getRequestQueue();
// ...
// Add a request (in this example, called stringRequest) to your RequestQueue.
MySingleton.getInstance(this).addToRequestQueue(stringRequest);
实现自定义的请求对象
大多数请求已经准备好在工具箱中使用实现；如果响应是字符串、图像或JSON，则可能不需要实现自定义请求。
对于需要实现自定义请求的情况，这是需要做的全部工作：
- 继承Request
类， 表示请求之后解析响应的类型。如果解析后的响应是String,那T就应该是String. - 实现 parseNetworkResponse() 和deliverResponse()方法。
parseNetworkResponse
Response会按照指定的类型去封装解析过的响应。
@Override
protected Response<T> parseNetworkResponse(
NetworkResponse response) {
try {
String json = new String(response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(gson.fromJson(json, clazz),
HttpHeaderParser.parseCacheHeaders(response));
}
// handle errors
...
}
NetworkResponse参数包含了返回的所有数据。包括byte[]形式的返回响应，HTTP状态码，响应头。
注意： 实现必须返回一个Response
如果请求协议不是标准的缓存语法，可以自己构筑一个Cache.Entry
return Response.success(myDecodedObject,HttpHeaderParser.parseCacheHeaders(response));
Volley在工作线程调用parseNetworkResponse（）方法。确保了昂贵的解析操作，例如将jpeg解码成位图，不会阻止UI线程。
deliverResponse
Volley从主线程中回调parseNetworkResponse（）方法返回的对象。请求用回调接口回调回来这个对象：
protected void deliverResponse(T response) { listener.onResponse(response);
一个完整的自定义请求例子 GsonRequest
public class GsonRequest<T> extends Request<T> {
private final Gson gson = new Gson();
private final Class<T> clazz;
private final Map<String, String> headers;
private final Listener<T> listener;
/**
* Make a GET request and return a parsed object from JSON.
*
* @param url URL of the request to make
* @param clazz Relevant class object, for Gson's reflection
* @param headers Map of request headers
*/
public GsonRequest(String url, Class<T> clazz, Map<String, String> headers,
Listener<T> listener, ErrorListener errorListener) {
super(Method.GET, url, errorListener);
this.clazz = clazz;
this.headers = headers;
this.listener = listener;
}
@Override
public Map<String, String> getHeaders() throws AuthFailureError {
return headers != null ? headers : super.getHeaders();
}
@Override
protected void deliverResponse(T response) {
listener.onResponse(response);
}
@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
try {
String json = new String(
response.data,
HttpHeaderParser.parseCharset(response.headers));
return Response.success(
gson.fromJson(json, clazz),
HttpHeaderParser.parseCacheHeaders(response));
} catch (UnsupportedEncodingException e) {
return Response.error(new ParseError(e));
} catch (JsonSyntaxException e) {
return Response.error(new ParseError(e));
}
}
}
