Volley 网络请求

最新推荐文章于 2023-04-03 19:03:08 发布
最新推荐文章于 2023-04-03 19:03:08 发布
阅读量438 收藏
点赞数
分类专栏： android

转载自郭霖大大博客：http://blog.csdn.net/guolin_blog/article/details/17482095

1. Volley简介


我们平时在开发Android应用的时候不可避免地都需要用到网络技术，而多数情况下应用程序都会使用HTTP协议来发送和接收网络数据。Android系统中主要提供了两种方式来进行HTTP通信，HttpURLConnection和HttpClient，几乎在任何项目的代码中我们都能看到这两个类的身影，使用率非常高。


不过HttpURLConnection和HttpClient的用法还是稍微有些复杂的，如果不进行适当封装的话，很容易就会写出不少重复代码。于是乎，一些Android网络通信框架也就应运而生，比如说AsyncHttpClient，它把HTTP所有的通信细节全部封装在了内部，我们只需要简单调用几行代码就可以完成通信操作了。再比如Universal-Image-Loader，它使得在界面上显示网络图片的操作变得极度简单，开发者不用关心如何从网络上获取图片，也不用关心开启线程、回收图片资源等细节，Universal-Image-Loader已经把一切都做好了。


Android开发团队也是意识到了有必要将HTTP的通信操作再进行简单化，于是在2013年Google I/O大会上推出了一个新的网络通信框架——Volley。Volley可是说是把AsyncHttpClient和Universal-Image-Loader的优点集于了一身，既可以像AsyncHttpClient一样非常简单地进行HTTP通信，也可以像Universal-Image-Loader一样轻松加载网络上的图片。除了简单易用之外，Volley在性能方面也进行了大幅度的调整，它的设计目标就是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕。


下图所示的这些应用都是属于数据量不大，但网络通信频繁的，因此非常适合使用Volley。



2. 下载Volley


介绍了这么多理论的东西，下面我们就准备开始进行实战了，首先需要将Volley的jar包准备好，如果你的电脑上装有Git，可以使用如下命令下载Volley的源码：

[plain] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. git clone https://android.googlesource.com/platform/frameworks/volley  

下载完成后将它导入到你的Eclipse工程里，然后再导出一个jar包就可以了。如果你的电脑上没有Git，那么也可以直接使用我导出好的jar包，下载地址是：http://download.csdn.net/detail/sinyu890807/7152015 。


新建一个Android项目，将volley.jar文件复制到libs目录下，这样准备工作就算是做好了。


3. StringRequest的用法


前面已经说过，Volley的用法非常简单，那么我们就从最基本的HTTP通信开始学习吧，即发起一条HTTP请求，然后接收HTTP响应。首先需要获取到一个RequestQueue对象，可以调用如下方法获取到：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. RequestQueue mQueue = Volley.newRequestQueue(context);  

注意这里拿到的RequestQueue是一个请求队列对象，它可以缓存所有的HTTP请求，然后按照一定的算法并发地发出这些请求。RequestQueue内部的设计就是非常合适高并发的，因此我们不必为每一次HTTP请求都创建一个RequestQueue对象，这是非常浪费资源的，基本上在每一个需要和网络交互的Activity中创建一个RequestQueue对象就足够了。


接下来为了要发出一条HTTP请求，我们还需要创建一个StringRequest对象，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. StringRequest stringRequest = new StringRequest("http://www.baidu.com",  
  2.                         new Response.Listener<String>() {  
  3.                             @Override  
  4.                             public void onResponse(String response) {  
  5.                                 Log.d("TAG", response);  
  6.                             }  
  7.                         }, new Response.ErrorListener() {  
  8.                             @Override  
  9.                             public void onErrorResponse(VolleyError error) {  
  10.                                 Log.e("TAG", error.getMessage(), error);  
  11.                             }  
  12.                         });  

可以看到，这里new出了一个StringRequest对象，StringRequest的构造函数需要传入三个参数，第一个参数就是目标服务器的URL地址，第二个参数是服务器响应成功的回调，第三个参数是服务器响应失败的回调。其中，目标服务器地址我们填写的是百度的首页，然后在响应成功的回调里打印出服务器返回的内容，在响应失败的回调里打印出失败的详细信息。


最后，将这个StringRequest对象添加到RequestQueue里面就可以了，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mQueue.add(stringRequest);  

另外，由于Volley是要访问网络的，因此不要忘记在你的AndroidManifest.xml中添加如下权限：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <uses-permission android:name="android.permission.INTERNET" />  

好了，就是这么简单，如果你现在运行一下程序，并发出这样一条HTTP请求，就会看到LogCat中会打印出如下图所示的数据。




没错，百度返回给我们的就是这样一长串的HTML代码，虽然我们看起来会有些吃力，但是浏览器却可以轻松地对这段HTML代码进行解析，然后将百度的首页展现出来。

这样的话，一个最基本的HTTP发送与响应的功能就完成了。你会发现根本还没写几行代码就轻易实现了这个功能，主要就是进行了以下三步操作：


1. 创建一个RequestQueue对象。

2. 创建一个StringRequest对象。

3. 将StringRequest对象添加到RequestQueue里面。


不过大家都知道，HTTP的请求类型通常有两种，GET和POST，刚才我们使用的明显是一个GET请求，那么如果想要发出一条POST请求应该怎么做呢？StringRequest中还提供了另外一种四个参数的构造函数，其中第一个参数就是指定请求类型的，我们可以使用如下方式进行指定：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. StringRequest stringRequest = new StringRequest(Method.POST, url,  listener, errorListener);  
可是这只是指定了HTTP请求方式是POST，那么我们要提交给服务器的参数又该怎么设置呢？很遗憾，StringRequest中并没有提供设置POST参数的方法，但是当发出POST请求的时候，Volley会尝试调用StringRequest的父类——Request中的getParams()方法来获取POST参数，那么解决方法自然也就有了，我们只需要在StringRequest的匿名类中重写getParams()方法，在这里设置POST参数就可以了，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. StringRequest stringRequest = new StringRequest(Method.POST, url,  listener, errorListener) {  
  2.     @Override  
  3.     protected Map<String, String> getParams() throws AuthFailureError {  
  4.         Map<String, String> map = new HashMap<String, String>();  
  5.         map.put("params1", "value1");  
  6.         map.put("params2", "value2");  
  7.         return map;  
  8.     }  
  9. };  

你可能会说，每次都这样用起来岂不是很累？连个设置POST参数的方法都没有。但是不要忘记，Volley是开源的，只要你愿意，你可以自由地在里面添加和修改任何的方法，轻松就能定制出一个属于你自己的Volley版本。


4. JsonRequest的用法


学完了最基本的StringRequest的用法，我们再来进阶学习一下JsonRequest的用法。类似于StringRequest，JsonRequest也是继承自Request类的，不过由于JsonRequest是一个抽象类，因此我们无法直接创建它的实例，那么只能从它的子类入手了。JsonRequest有两个直接的子类，JsonObjectRequest和JsonArrayRequest，从名字上你应该能就看出它们的区别了吧？一个是用于请求一段JSON数据的，一个是用于请求一段JSON数组的。


至于它们的用法也基本上没有什么特殊之处，先new出一个JsonObjectRequest对象，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. JsonObjectRequest jsonObjectRequest = new JsonObjectRequest("http://m.weather.com.cn/data/101010100.html", null,  
  2.         new Response.Listener<JSONObject>() {  
  3.             @Override  
  4.             public void onResponse(JSONObject response) {  
  5.                 Log.d("TAG", response.toString());  
  6.             }  
  7.         }, new Response.ErrorListener() {  
  8.             @Override  
  9.             public void onErrorResponse(VolleyError error) {  
  10.                 Log.e("TAG", error.getMessage(), error);  
  11.             }  
  12.         });  
可以看到，这里我们填写的URL地址是http://m.weather.com.cn/data/101010100.html，这是中国天气网提供的一个查询天气信息的接口，响应的数据就是以JSON格式返回的，然后我们在onResponse()方法中将返回的数据打印出来。


最后再将这个JsonObjectRequest对象添加到RequestQueue里就可以了，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mQueue.add(jsonObjectRequest);  

这样当HTTP通信完成之后，服务器响应的天气信息就会回调到onResponse()方法中，并打印出来。现在运行一下程序，发出这样一条HTTP请求，就会看到LogCat中会打印出如下图所示的数据。




由此可以看出，服务器返回给我们的数据确实是JSON格式的，并且onResponse()方法中携带的参数也正是一个JSONObject对象，之后只需要从JSONObject对象取出我们想要得到的那部分数据就可以了。


你应该发现了吧，JsonObjectRequest的用法和StringRequest的用法基本上是完全一样的，Volley的易用之处也在这里体现出来了，会了一种就可以让你举一反三，因此关于JsonArrayRequest的用法相信已经不需要我再去讲解了吧。



在上一篇文章中，我们了解了Volley到底是什么，以及它的基本用法。本篇文章中我们即将学习关于Volley更加高级的用法，如何你还没有看过我的上一篇文章的话，建议先去阅读Android Volley完全解析(一)，初识Volley的基本用法。


在上篇文章中有提到过，Volley是将AsyncHttpClient和Universal-Image-Loader的优点集成于一身的一个框架。我们都知道，Universal-Image-Loader具备非常强大的加载网络图片的功能，而使用Volley，我们也可以实现基本类似的效果，并且在性能上也豪不逊色于Universal-Image-Loader，下面我们就来具体学习一下吧。


1. ImageRequest的用法


前面我们已经学习过了StringRequest和JsonRequest的用法，并且总结出了它们的用法都是非常类似的，基本就是进行以下三步操作即可：


1. 创建一个RequestQueue对象。

2. 创建一个Request对象。

3. 将Request对象添加到RequestQueue里面。


其中，StringRequest和JsonRequest都是继承自Request的，所以它们的用法才会如此类似。那么不用多说，今天我们要学习的ImageRequest，相信你从名字上就已经猜出来了，它也是继承自Request的，因此它的用法也是基本相同的，首先需要获取到一个RequestQueue对象，可以调用如下方法获取到：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. RequestQueue mQueue = Volley.newRequestQueue(context);  
接下来自然要去new出一个ImageRequest对象了，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ImageRequest imageRequest = new ImageRequest(  
  2.         "http://developer.android.com/images/home/aw_dac.png",  
  3.         new Response.Listener<Bitmap>() {  
  4.             @Override  
  5.             public void onResponse(Bitmap response) {  
  6.                 imageView.setImageBitmap(response);  
  7.             }  
  8.         }, 0, 0, Config.RGB_565, new Response.ErrorListener() {  
  9.             @Override  
  10.             public void onErrorResponse(VolleyError error) {  
  11.                 imageView.setImageResource(R.drawable.default_image);  
  12.             }  
  13.         });  

可以看到，ImageRequest的构造函数接收六个参数，第一个参数就是图片的URL地址，这个没什么需要解释的。第二个参数是图片请求成功的回调，这里我们把返回的Bitmap参数设置到ImageView中。第三第四个参数分别用于指定允许图片最大的宽度和高度，如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，指定成0的话就表示不管图片有多大，都不会进行压缩。第五个参数用于指定图片的颜色属性，Bitmap.Config下的几个常量都可以在这里使用，其中ARGB_8888可以展示最好的颜色属性，每个图片像素占据4个字节的大小，而RGB_565则表示每个图片像素占据2个字节大小。第六个参数是图片请求失败的回调，这里我们当请求失败时在ImageView中显示一张默认图片。


最后将这个ImageRequest对象添加到RequestQueue里就可以了，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. mQueue.add(imageRequest);  

现在如果运行一下程序，并尝试发出这样一条网络请求，很快就能看到网络上的图片在ImageView中显示出来了，如下图所示：




2. ImageLoader的用法


如果你觉得ImageRequest已经非常好用了，那我只能说你太容易满足了 ^_^。实际上，Volley在请求网络图片方面可以做到的还远远不止这些，而ImageLoader就是一个很好的例子。ImageLoader也可以用于加载网络上的图片，并且它的内部也是使用ImageRequest来实现的，不过ImageLoader明显要比ImageRequest更加高效，因为它不仅可以帮我们对图片进行缓存，还可以过滤掉重复的链接，避免重复发送请求。


由于ImageLoader已经不是继承自Request的了，所以它的用法也和我们之前学到的内容有所不同，总结起来大致可以分为以下四步：


1. 创建一个RequestQueue对象。

2. 创建一个ImageLoader对象。

3. 获取一个ImageListener对象。

4. 调用ImageLoader的get()方法加载网络上的图片。


下面我们就来按照这个步骤，学习一下ImageLoader的用法吧。首先第一步的创建RequestQueue对象我们已经写过很多遍了，相信已经不用再重复介绍了，那么就从第二步开始学习吧，新建一个ImageLoader对象，代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ImageLoader imageLoader = new ImageLoader(mQueue, new ImageCache() {  
  2.     @Override  
  3.     public void putBitmap(String url, Bitmap bitmap) {  
  4.     }  
  5.   
  6.     @Override  
  7.     public Bitmap getBitmap(String url) {  
  8.         return null;  
  9.     }  
  10. });  

可以看到，ImageLoader的构造函数接收两个参数，第一个参数就是RequestQueue对象，第二个参数是一个ImageCache对象，这里我们先new出一个空的ImageCache的实现即可。


接下来需要获取一个ImageListener对象，代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ImageListener listener = ImageLoader.getImageListener(imageView,  
  2.         R.drawable.default_image, R.drawable.failed_image);  

我们通过调用ImageLoader的getImageListener()方法能够获取到一个ImageListener对象，getImageListener()方法接收三个参数，第一个参数指定用于显示图片的ImageView控件，第二个参数指定加载图片的过程中显示的图片，第三个参数指定加载图片失败的情况下显示的图片。


最后，调用ImageLoader的get()方法来加载图片，代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. imageLoader.get("https://img-my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", listener);  

get()方法接收两个参数，第一个参数就是图片的URL地址，第二个参数则是刚刚获取到的ImageListener对象。当然，如果你想对图片的大小进行限制，也可以使用get()方法的重载，指定图片允许的最大宽度和高度，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. imageLoader.get("https://img-my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",  
  2.                 listener, 200, 200);  

现在运行一下程序并开始加载图片，你将看到ImageView中会先显示一张默认的图片，等到网络上的图片加载完成后，ImageView则会自动显示该图，效果如下图所示。




虽然现在我们已经掌握了ImageLoader的用法，但是刚才介绍的ImageLoader的优点却还没有使用到。为什么呢？因为这里创建的ImageCache对象是一个空的实现，完全没能起到图片缓存的作用。其实写一个ImageCache也非常简单，但是如果想要写一个性能非常好的ImageCache，最好就要借助Android提供的LruCache功能了，如果你对LruCache还不了解，可以参考我之前的一篇博客Android高效加载大图、多图解决方案，有效避免程序OOM。


这里我们新建一个BitmapCache并实现了ImageCache接口，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class BitmapCache implements ImageCache {  
  2.   
  3.     private LruCache<String, Bitmap> mCache;  
  4.   
  5.     public BitmapCache() {  
  6.         int maxSize = 10 * 1024 * 1024;  
  7.         mCache = new LruCache<String, Bitmap>(maxSize) {  
  8.             @Override  
  9.             protected int sizeOf(String key, Bitmap bitmap) {  
  10.                 return bitmap.getRowBytes() * bitmap.getHeight();  
  11.             }  
  12.         };  
  13.     }  
  14.   
  15.     @Override  
  16.     public Bitmap getBitmap(String url) {  
  17.         return mCache.get(url);  
  18.     }  
  19.   
  20.     @Override  
  21.     public void putBitmap(String url, Bitmap bitmap) {  
  22.         mCache.put(url, bitmap);  
  23.     }  
  24.   
  25. }  
可以看到，这里我们将缓存图片的大小设置为10M。接着修改创建ImageLoader实例的代码，第二个参数传入BitmapCache的实例，如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache());  

这样我们就把ImageLoader的功能优势充分利用起来了。


3. NetworkImageView的用法


除了以上两种方式之外，Volley还提供了第三种方式来加载网络图片，即使用NetworkImageView。不同于以上两种方式，NetworkImageView是一个自定义控制，它是继承自ImageView的，具备ImageView控件的所有功能，并且在原生的基础之上加入了加载网络图片的功能。NetworkImageView控件的用法要比前两种方式更加简单，大致可以分为以下五步：


1. 创建一个RequestQueue对象。

2. 创建一个ImageLoader对象。

3. 在布局文件中添加一个NetworkImageView控件。

4. 在代码中获取该控件的实例。

5. 设置要加载的图片地址。


其中，第一第二步和ImageLoader的用法是完全一样的，因此这里我们就从第三步开始学习了。首先修改布局文件中的代码，在里面加入NetworkImageView控件，如下所示：

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     android:layout_width="fill_parent"  
  3.     android:layout_height="fill_parent"  
  4.     android:orientation="vertical" >  
  5.   
  6.     <Button  
  7.         android:id="@+id/button"  
  8.         android:layout_width="wrap_content"  
  9.         android:layout_height="wrap_content"  
  10.         android:text="Send Request" />  
  11.       
  12.     <com.android.volley.toolbox.NetworkImageView   
  13.         android:id="@+id/network_image_view"  
  14.         android:layout_width="200dp"  
  15.         android:layout_height="200dp"  
  16.         android:layout_gravity="center_horizontal"  
  17.         />  
  18.   
  19. </LinearLayout>  
接着在Activity获取到这个控件的实例，这就非常简单了，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. networkImageView = (NetworkImageView) findViewById(R.id.network_image_view);  
得到了NetworkImageView控件的实例之后，我们可以调用它的setDefaultImageResId()方法、setErrorImageResId()方法和setImageUrl()方法来分别设置加载中显示的图片，加载失败时显示的图片，以及目标图片的URL地址，如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. networkImageView.setDefaultImageResId(R.drawable.default_image);  
  2. networkImageView.setErrorImageResId(R.drawable.failed_image);  
  3. networkImageView.setImageUrl("https://img-my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",  
  4.                 imageLoader);  
其中，setImageUrl()方法接收两个参数，第一个参数用于指定图片的URL地址，第二个参数则是前面创建好的ImageLoader对象。


好了，就是这么简单，现在重新运行一下程序，你将看到和使用ImageLoader来加载图片一模一样的效果，这里我就不再截图了。


这时有的朋友可能就会问了，使用ImageRequest和ImageLoader这两种方式来加载网络图片，都可以传入一个最大宽度和高度的参数来对图片进行压缩，而NetworkImageView中则完全没有提供设置最大宽度和高度的方法，那么是不是使用NetworkImageView来加载的图片都不会进行压缩呢？


其实并不是这样的，NetworkImageView并不需要提供任何设置最大宽高的方法也能够对加载的图片进行压缩。这是由于NetworkImageView是一个控件，在加载图片的时候它会自动获取自身的宽高，然后对比网络图片的宽度，再决定是否需要对图片进行压缩。也就是说，压缩过程是在内部完全自动化的，并不需要我们关心，NetworkImageView会始终呈现给我们一张大小刚刚好的网络图片，不会多占用任何一点内存，这也是NetworkImageView最简单好用的一点吧。


当然了，如果你不想对图片进行压缩的话，其实也很简单，只需要在布局文件中把NetworkImageView的layout_width和layout_height都设置成wrap_content就可以了，这样NetworkImageView就会将该图片的原始大小展示出来，不会进行任何压缩。


经过前面两篇文章的学习，我们已经掌握了Volley各种Request的使用方法，包括StringRequest、JsonRequest、ImageRequest等。其中StringRequest用于请求一条普通的文本数据，JsonRequest(JsonObjectRequest、JsonArrayRequest)用于请求一条JSON格式的数据，ImageRequest则是用于请求网络上的一张图片。


可是Volley提供给我们的Request类型就只有这么多，而我们都知道，在网络上传输的数据通常有两种格式，JSON和XML，那么如果想要请求一条XML格式的数据该怎么办呢？其实很简单，Volley提供了非常强的扩展机制，使得我们可以很轻松地定制出任意类型的Request，这也就是本篇文章的主题了。


在开始之前还是友情提醒一下，如果你还没有阅读过我前面两篇关于Volley的文章，建议先去阅读一下Android Volley完全解析(一)，初识Volley的基本用法和Android Volley完全解析(二)，使用Volley加载网络图片。


1. 自定义XMLRequest


下面我们准备自定义一个XMLRequest，用于请求一条XML格式的数据。那么该从哪里开始入手呢？额，好像是有些无从下手。遇到这种情况，我们应该去参考一下Volley的源码，看一看StringRequest是怎么实现的，然后就可以模仿着写出XMLRequest了。首先看下StringRequest的源码，如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * A canned request for retrieving the response body at a given URL as a String. 
  3.  */  
  4. public class StringRequest extends Request<String> {  
  5.     private final Listener<String> mListener;  
  6.   
  7.     /** 
  8.      * Creates a new request with the given method. 
  9.      * 
  10.      * @param method the request {@link Method} to use 
  11.      * @param url URL to fetch the string at 
  12.      * @param listener Listener to receive the String response 
  13.      * @param errorListener Error listener, or null to ignore errors 
  14.      */  
  15.     public StringRequest(int method, String url, Listener<String> listener,  
  16.             ErrorListener errorListener) {  
  17.         super(method, url, errorListener);  
  18.         mListener = listener;  
  19.     }  
  20.   
  21.     /** 
  22.      * Creates a new GET request. 
  23.      * 
  24.      * @param url URL to fetch the string at 
  25.      * @param listener Listener to receive the String response 
  26.      * @param errorListener Error listener, or null to ignore errors 
  27.      */  
  28.     public StringRequest(String url, Listener<String> listener, ErrorListener errorListener) {  
  29.         this(Method.GET, url, listener, errorListener);  
  30.     }  
  31.   
  32.     @Override  
  33.     protected void deliverResponse(String response) {  
  34.         mListener.onResponse(response);  
  35.     }  
  36.   
  37.     @Override  
  38.     protected Response<String> parseNetworkResponse(NetworkResponse response) {  
  39.         String parsed;  
  40.         try {  
  41.             parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));  
  42.         } catch (UnsupportedEncodingException e) {  
  43.             parsed = new String(response.data);  
  44.         }  
  45.         return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));  
  46.     }  
  47. }  

可以看到，StringRequest的源码很简练，根本就没几行代码，我们一起来分析下。首先StringRequest是继承自Request类的，Request可以指定一个泛型类，这里指定的当然就是String了，接下来StringRequest中提供了两个有参的构造函数，参数包括请求类型，请求地址，以及响应回调等，由于我们已经很熟悉StringRequest的用法了，相信这几个参数的作用都不用再解释了吧。但需要注意的是，在构造函数中一定要调用super()方法将这几个参数传给父类，因为HTTP的请求和响应都是在父类中自动处理的。


另外，由于Request类中的deliverResponse()和parseNetworkResponse()是两个抽象方法，因此StringRequest中需要对这两个方法进行实现。deliverResponse()方法中的实现很简单，仅仅是调用了mListener中的onResponse()方法，并将response内容传入即可，这样就可以将服务器响应的数据进行回调了。parseNetworkResponse()方法中则应该对服务器响应的数据进行解析，其中数据是以字节的形式存放在NetworkResponse的data变量中的，这里将数据取出然后组装成一个String，并传入Response的success()方法中即可。


了解了StringRequest的实现原理，下面我们就可以动手来尝试实现一下XMLRequest了，代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class XMLRequest extends Request<XmlPullParser> {  
  2.   
  3.     private final Listener<XmlPullParser> mListener;  
  4.   
  5.     public XMLRequest(int method, String url, Listener<XmlPullParser> listener,  
  6.             ErrorListener errorListener) {  
  7.         super(method, url, errorListener);  
  8.         mListener = listener;  
  9.     }  
  10.   
  11.     public XMLRequest(String url, Listener<XmlPullParser> listener, ErrorListener errorListener) {  
  12.         this(Method.GET, url, listener, errorListener);  
  13.     }  
  14.   
  15.     @Override  
  16.     protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {  
  17.         try {  
  18.             String xmlString = new String(response.data,  
  19.                     HttpHeaderParser.parseCharset(response.headers));  
  20.             XmlPullParserFactory factory = XmlPullParserFactory.newInstance();  
  21.             XmlPullParser xmlPullParser = factory.newPullParser();  
  22.             xmlPullParser.setInput(new StringReader(xmlString));  
  23.             return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));  
  24.         } catch (UnsupportedEncodingException e) {  
  25.             return Response.error(new ParseError(e));  
  26.         } catch (XmlPullParserException e) {  
  27.             return Response.error(new ParseError(e));  
  28.         }  
  29.     }  
  30.   
  31.     @Override  
  32.     protected void deliverResponse(XmlPullParser response) {  
  33.         mListener.onResponse(response);  
  34.     }  
  35.   
  36. }  

可以看到，其实并没有什么太多的逻辑，基本都是仿照StringRequest写下来的，XMLRequest也是继承自Request类的，只不过这里指定的泛型类是XmlPullParser，说明我们准备使用Pull解析的方式来解析XML。在parseNetworkResponse()方法中，先是将服务器响应的数据解析成一个字符串，然后设置到XmlPullParser对象中，在deliverResponse()方法中则是将XmlPullParser对象进行回调。


好了，就是这么简单，下面我们尝试使用这个XMLRequest来请求一段XML格式的数据。http://flash.weather.com.cn/wmaps/xml/china.xml这个接口会将中国所有的省份数据以XML格式进行返回，如下所示：

[html] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. <china dn="day" slick-uniqueid="3">  
  2. <city quName="黑龙江" pyName="heilongjiang" cityname="哈尔滨" state1="0" state2="0" stateDetailed="晴" tem1="18" tem2="6" windState="西北风3-4级转西风小于3级"/>  
  3. <city quName="吉林" pyName="jilin" cityname="长春" state1="0" state2="0" stateDetailed="晴" tem1="19" tem2="6" windState="西北风3-4级转小于3级"/>  
  4. <city quName="辽宁" pyName="liaoning" cityname="沈阳" state1="0" state2="0" stateDetailed="晴" tem1="21" tem2="7" windState="东北风3-4级"/>  
  5. <city quName="海南" pyName="hainan" cityname="海口" state1="1" state2="1" stateDetailed="多云" tem1="30" tem2="24" windState="微风"/>  
  6. <city quName="内蒙古" pyName="neimenggu" cityname="呼和浩特" state1="0" state2="0" stateDetailed="晴" tem1="19" tem2="5" windState="东风3-4级"/>  
  7. <city quName="新疆" pyName="xinjiang" cityname="乌鲁木齐" state1="0" state2="0" stateDetailed="晴" tem1="22" tem2="10" windState="微风转东南风小于3级"/>  
  8. <city quName="西藏" pyName="xizang" cityname="拉萨" state1="1" state2="7" stateDetailed="多云转小雨" tem1="18" tem2="4" windState="微风"/>  
  9. <city quName="青海" pyName="qinghai" cityname="西宁" state1="0" state2="1" stateDetailed="晴转多云" tem1="18" tem2="2" windState="微风"/>  
  10. <city quName="宁夏" pyName="ningxia" cityname="银川" state1="0" state2="0" stateDetailed="晴" tem1="19" tem2="8" windState="微风"/>  
  11. <city quName="甘肃" pyName="gansu" cityname="兰州" state1="0" state2="0" stateDetailed="晴" tem1="21" tem2="6" windState="微风"/>  
  12. <city quName="河北" pyName="hebei" cityname="石家庄" state1="0" state2="0" stateDetailed="晴" tem1="25" tem2="12" windState="北风小于3级"/>  
  13. <city quName="河南" pyName="henan" cityname="郑州" state1="0" state2="0" stateDetailed="晴" tem1="24" tem2="13" windState="微风"/>  
  14. <city quName="湖北" pyName="hubei" cityname="武汉" state1="0" state2="0" stateDetailed="晴" tem1="24" tem2="12" windState="微风"/>  
  15. <city quName="湖南" pyName="hunan" cityname="长沙" state1="2" state2="1" stateDetailed="阴转多云" tem1="20" tem2="15" windState="北风小于3级"/>  
  16. <city quName="山东" pyName="shandong" cityname="济南" state1="1" state2="1" stateDetailed="多云" tem1="20" tem2="10" windState="北风3-4级转小于3级"/>  
  17. <city quName="江苏" pyName="jiangsu" cityname="南京" state1="2" state2="2" stateDetailed="阴" tem1="19" tem2="13" windState="西北风4-5级转3-4级"/>  
  18. <city quName="安徽" pyName="anhui" cityname="合肥" state1="2" state2="1" stateDetailed="阴转多云" tem1="20" tem2="12" windState="西北风转北风3-4级"/>  
  19. <city quName="山西" pyName="shanxi" cityname="太原" state1="0" state2="0" stateDetailed="晴" tem1="22" tem2="8" windState="微风"/>  
  20. <city quName="陕西" pyName="sanxi" cityname="西安" state1="1" state2="0" stateDetailed="多云转晴" tem1="21" tem2="9" windState="东北风小于3级"/>  
  21. <city quName="四川" pyName="sichuan" cityname="成都" state1="1" state2="1" stateDetailed="多云" tem1="26" tem2="15" windState="南风小于3级"/>  
  22. <city quName="云南" pyName="yunnan" cityname="昆明" state1="7" state2="7" stateDetailed="小雨" tem1="21" tem2="13" windState="微风"/>  
  23. <city quName="贵州" pyName="guizhou" cityname="贵阳" state1="1" state2="3" stateDetailed="多云转阵雨" tem1="21" tem2="11" windState="东风小于3级"/>  
  24. <city quName="浙江" pyName="zhejiang" cityname="杭州" state1="3" state2="1" stateDetailed="阵雨转多云" tem1="22" tem2="14" windState="微风"/>  
  25. <city quName="福建" pyName="fujian" cityname="福州" state1="1" state2="2" stateDetailed="多云转阴" tem1="28" tem2="18" windState="微风"/>  
  26. <city quName="江西" pyName="jiangxi" cityname="南昌" state1="2" state2="1" stateDetailed="阴转多云" tem1="23" tem2="15" windState="北风3-4级转微风"/>  
  27. <city quName="广东" pyName="guangdong" cityname="广州" state1="3" state2="2" stateDetailed="阵雨转阴" tem1="26" tem2="20" windState="微风"/>  
  28. <city quName="广西" pyName="guangxi" cityname="南宁" state1="3" state2="3" stateDetailed="阵雨" tem1="23" tem2="19" windState="东北风小于3级"/>  
  29. <city quName="北京" pyName="beijing" cityname="北京" state1="0" state2="0" stateDetailed="晴" tem1="26" tem2="10" windState="微风"/>  
  30. <city quName="天津" pyName="tianjin" cityname="天津" state1="1" state2="0" stateDetailed="多云转晴" tem1="22" tem2="13" windState="东北风3-4级转小于3级"/>  
  31. <city quName="上海" pyName="shanghai" cityname="上海" state1="7" state2="1" stateDetailed="小雨转多云" tem1="20" tem2="16" windState="西北风3-4级"/>  
  32. <city quName="重庆" pyName="chongqing" cityname="重庆" state1="1" state2="3" stateDetailed="多云转阵雨" tem1="21" tem2="14" windState="微风"/>  
  33. <city quName="香港" pyName="xianggang" cityname="香港" state1="3" state2="1" stateDetailed="阵雨转多云" tem1="26" tem2="22" windState="微风"/>  
  34. <city quName="澳门" pyName="aomen" cityname="澳门" state1="3" state2="1" stateDetailed="阵雨转多云" tem1="27" tem2="22" windState="东北风3-4级转微风"/>  
  35. <city quName="台湾" pyName="taiwan" cityname="台北" state1="9" state2="7" stateDetailed="大雨转小雨" tem1="28" tem2="21" windState="微风"/>  
  36. <city quName="西沙" pyName="xisha" cityname="西沙" state1="3" state2="3" stateDetailed="阵雨" tem1="30" tem2="26" windState="东北风4-5级"/>  
  37. <city quName="南沙" pyName="nanshadao" cityname="南沙" state1="1" state2="1" stateDetailed="多云" tem1="32" tem2="27" windState="东风4-5级"/>  
  38. <city quName="钓鱼岛" pyName="diaoyudao" cityname="钓鱼岛" state1="7" state2="1" stateDetailed="小雨转多云" tem1="23" tem2="19" windState="西南风3-4级转北风5-6级"/>  
  39. </china>  
确定了访问接口后，我们只需要在代码中按照以下的方式来使用XMLRequest即可：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. XMLRequest xmlRequest = new XMLRequest(  
  2.         "http://flash.weather.com.cn/wmaps/xml/china.xml",  
  3.         new Response.Listener<XmlPullParser>() {  
  4.             @Override  
  5.             public void onResponse(XmlPullParser response) {  
  6.                 try {  
  7.                     int eventType = response.getEventType();  
  8.                     while (eventType != XmlPullParser.END_DOCUMENT) {  
  9.                         switch (eventType) {  
  10.                         case XmlPullParser.START_TAG:  
  11.                             String nodeName = response.getName();  
  12.                             if ("city".equals(nodeName)) {  
  13.                                 String pName = response.getAttributeValue(0);  
  14.                                 Log.d("TAG", "pName is " + pName);  
  15.                             }  
  16.                             break;  
  17.                         }  
  18.                         eventType = response.next();  
  19.                     }  
  20.                 } catch (XmlPullParserException e) {  
  21.                     e.printStackTrace();  
  22.                 } catch (IOException e) {  
  23.                     e.printStackTrace();  
  24.                 }  
  25.             }  
  26.         }, new Response.ErrorListener() {  
  27.             @Override  
  28.             public void onErrorResponse(VolleyError error) {  
  29.                 Log.e("TAG", error.getMessage(), error);  
  30.             }  
  31.         });  
  32. mQueue.add(xmlRequest);  

可以看到，这里XMLRequest的用法和StringRequest几乎是一模一样的，我们先创建出一个XMLRequest的实例，并把服务器接口地址传入，然后在onResponse()方法中解析响应的XML数据，并把每个省的名字打印出来，最后将这个XMLRequest添加到RequestQueue当中。


现在运行一下代码，观察控制台日志，就可以看到每个省的名字都从XML中解析出来了，如下图所示。



2. 自定义GsonRequest


JsonRequest的数据解析是利用Android本身自带的JSONObject和JSONArray来实现的，配合使用JSONObject和JSONArray就可以解析出任意格式的JSON数据。不过也许你会觉得使用JSONObject还是太麻烦了，还有很多方法可以让JSON数据解析变得更加简单，比如说GSON。遗憾的是，Volley中默认并不支持使用自家的GSON来解析数据，不过没有关系，通过上面的学习，相信你已经知道了自定义一个Request是多么的简单，那么下面我们就来举一反三一下，自定义一个GsonRequest。


首先我们需要把gson的jar包添加到项目当中，jar包的下载地址是：https://code.google.com/p/google-gson/downloads/list 。


接着定义一个GsonRequest继承自Request，代码如下所示：

[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class GsonRequest<T> extends Request<T> {  
  2.   
  3.     private final Listener<T> mListener;  
  4.   
  5.     private Gson mGson;  
  6.   
  7.     private Class<T> mClass;  
  8.   
  9.     public GsonRequest(int method, String url, Class<T> clazz, Listener<T> listener,  
  10.             ErrorListener errorListener) {  
  11.         super(method, url, errorListener);  
  12.         mGson = new Gson();  
  13.         mClass = clazz;  
  14.         mListener = listener;  
  15.     }  
  16.   
  17.     public GsonRequest(String url, Class<T> clazz, Listener<T> listener,  
  18.             ErrorListener errorListener) {  
  19.         this(Method.GET, url, clazz, listener, errorListener);  
  20.     }  
  21.   
  22.     @Override  
  23.     protected Response<T> parseNetworkResponse(NetworkResponse response) {  
  24.         try {  
  25.             String jsonString = new String(response.data,  
  26.                     HttpHeaderParser.parseCharset(response.headers));  
  27.             return Response.success(mGson.fromJson(jsonString, mClass),  
  28.                     HttpHeaderParser.parseCacheHeaders(response));  
  29.         } catch (UnsupportedEncodingException e) {  
  30.             return Response.error(new ParseError(e));  
  31.         }  
  32.     }  
  33.   
  34.     @Override  
  35.     protected void deliverResponse(T response) {  
  36.         mListener.onResponse(response);  
  37.     }  
  38.   
  39. }  

可以看到，GsonRequest是继承自Request类的，并且同样提供了两个构造函数。在parseNetworkResponse()方法中，先是将服务器响应的数据解析出来，然后通过调用Gson的fromJson方法将数据组装成对象。在deliverResponse方法中仍然是将最终的数据进行回调。


那么下面我们就来测试一下这个GsonRequest能不能够正常工作吧，调用http://www.weather.com.cn/data/sk/101010100.html这个接口可以得到一段JSON格式的天气数据，如下所示：

[plain] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. {"weatherinfo":{"city":"北京","cityid":"101010100","temp":"19","WD":"南风","WS":"2级","SD":"43%","WSE":"2","time":"19:45","isRadar":"1","Radar":"JC_RADAR_AZ9010_JB"}}  
接下来我们使用对象的方式将这段JSON字符串表示出来。新建一个Weather类，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class Weather {  
  2.   
  3.     private WeatherInfo weatherinfo;  
  4.   
  5.     public WeatherInfo getWeatherinfo() {  
  6.         return weatherinfo;  
  7.     }  
  8.   
  9.     public void setWeatherinfo(WeatherInfo weatherinfo) {  
  10.         this.weatherinfo = weatherinfo;  
  11.     }  
  12.   
  13. }  
Weather类中只是引用了WeatherInfo这个类。接着新建WeatherInfo类，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public class WeatherInfo {  
  2.   
  3.     private String city;  
  4.   
  5.     private String temp;  
  6.   
  7.     private String time;  
  8.   
  9.     public String getCity() {  
  10.         return city;  
  11.     }  
  12.   
  13.     public void setCity(String city) {  
  14.         this.city = city;  
  15.     }  
  16.   
  17.     public String getTemp() {  
  18.         return temp;  
  19.     }  
  20.   
  21.     public void setTemp(String temp) {  
  22.         this.temp = temp;  
  23.     }  
  24.   
  25.     public String getTime() {  
  26.         return time;  
  27.     }  
  28.   
  29.     public void setTime(String time) {  
  30.         this.time = time;  
  31.     }  
  32.   
  33. }  
WeatherInfo类中含有city、temp、time这几个字段。下面就是如何调用GsonRequest了，其实也很简单，代码如下所示：
[java] view plain copy 在CODE上查看代码片 派生到我的代码片
  1. GsonRequest<Weather> gsonRequest = new GsonRequest<Weather>(  
  2.         "http://www.weather.com.cn/data/sk/101010100.html", Weather.class,  
  3.         new Response.Listener<Weather>() {  
  4.             @Override  
  5.             public void onResponse(Weather weather) {  
  6.                 WeatherInfo weatherInfo = weather.getWeatherinfo();  
  7.                 Log.d("TAG", "city is " + weatherInfo.getCity());  
  8.                 Log.d("TAG", "temp is " + weatherInfo.getTemp());  
  9.                 Log.d("TAG", "time is " + weatherInfo.getTime());  
  10.             }  
  11.         }, new Response.ErrorListener() {  
  12.             @Override  
  13.             public void onErrorResponse(VolleyError error) {  
  14.                 Log.e("TAG", error.getMessage(), error);  
  15.             }  
  16.         });  
  17. mQueue.add(gsonRequest);  

可以看到，这里onResponse()方法的回调中直接返回了一个Weather对象，我们通过它就可以得到WeatherInfo对象，接着就能从中取出JSON中的相关数据了。现在运行一下代码，观察控制台日志，打印数据如下图所示：


Void_J
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Volley网络请求demo
04-11
本项目“Volley网络请求demo”提供了一个实际应用示例，展示了如何使用Volley进行GET和POST请求。 Volley的核心优势在于其内置了缓存机制、线程池管理和请求队列，能够优化网络请求的性能，减少延迟，提高用户体验...
Volley网络请求框架
最新发布
06-20
Volley是Google推出的一款强大而高效的网络请求与图片加载框架。它简化了网络请求的流程，支持多线程、缓存和异步处理，同时内置了图片加载功能，为开发者提供了一站式的网络请求解决方案。无论是数据请求还是图片...
网络请求框架---Volley
weixin_33984032的博客
08-01 115
2019独角兽企业重金招聘Python工程师标准>>> ...
Volley网络请求
星枫的博客
04-23 373
一. 配置之前网上找了好几个jar包都是需要币的，但是我没有啊，找了下自己的百度网盘才发现自己以前存过，特发此供大家学习，收费什么的麻烦。jar包地址：https://pan.baidu.com/s/1hCDP2t63CvUCQL73p28URw提取密码：b7z8将jar包复制粘贴到项目的libs下，然后右键jar包，下方有一个Add As Library...如图：add之后，jar包会出现有子...
一个简单的volley网络请求
Lighthouse
08-29 806
volley网络请求 1 volley 一个简单的网络请求流程 2 可以看到主要的流程都在RequestQueue队列中封装处理 3这个类主要做的事情 4 以上是简单请求队列初始化的 不能只关注设置模式其他还有好多 5接下来分析sart方法 6接下来就要分析网络分发了NetWorkDispatcher 因为HurlStack 和 HttpClientStack 衍生为HttpStack 而 Ht
使用volley进行网络请求
HotSmoking的博客
04-27 1328
//Volley 缓存StringRequest,JsonObjectRequest两级缓存（网络--->磁盘） //ImageLoader（三级缓存 网络--->内存缓存---->磁盘） //从缓存中获取数据（缓存失效时间失效）--->hit获取直接展示数据 //没有获取数据，走网络，响应头，判断是否进行缓存 //首先展示的是volley的工具类 封装到一个类中统一使用  packag
防volley网络请求框架
06-12
仿写的Volley网络请求框架可能还需要包含其他的组件，如网络连接池、超时重试策略、请求监听器等，以进一步完善功能和提高性能。在BaseSimpleNet这个文件中，我们可以预期它可能是整个框架的基础部分，包含了一些...
Volley网络请求封装
03-24
网络请求使用的Volley.Jar.Json解析使用的谷歌的Gson,此封装可以 重复调用 一个网络请求，并可以自动解析JSON为一个对象,我们都知道，在基本使用Volley的时候，每个Activity 都会去创建一个 网络 请求,这样显得代码...
volley网络请求的小demo
10-30
快来下载好用的volley请求样例，google封装的网络框架，针对小数据量的访问并发奇效，相信你值得拥有，快来使用它构建属于自己的项目吧，里边有volley的jar哦，copy可直接使用，就在libs目录下
Volley网络请求概述
海礁的奋斗历程
03-08 682
特点： · 自动调度网络请求 · 支持并发网络连接（即支持多线程） · 支持标准的HTTP缓存协议（由服务器来决定是否缓存数据） · 支持请求优先级设置(4级) · 支持取消单个或多个请求 · 易于定制（重试），扩展性强。比如Retry&Backoff机制 · 强大的网络请求能力让你轻松的发送异步请求来填充UI数据 · 提供调试和跟踪工具 优点： 擅长将RPC(远程过程调用协议
Android 使用 Volley 实现网络请求
qq_27494201的博客
04-03 235
更多：http://www.360doc.com/content/22/0510/12/12185854_1030641565.shtml。Volley框架学习参考：https://www.cnblogs.com/nhgtx/p/16918545.html。解决：将http改为https即可。
简析Android网络请求Volley框架的工作原理
废墟的树的专栏
10-29 3910
Volley网络模块以及错误重试机制分析 相关类如下： Network ：封装网络请求接口 BaseNetWork : Network 接口实现类，用于封装网络请求，并且对请求结果封装，且实现网络请求错误重试机制。 HttpStack：执行网络请求接口 HurlStack：HttpStack 接口实现类，用于真正执行网络请求，并且得到请求结果。 HttpClientStack：Http
网络请求Volley篇【Android】
.....
08-01 353
Volley相关API 1.RequestQueue:请求队列，会自动执行队列中的请求 Volley.newRequestQueue(context):创建一个请求队列 addRequest(Request request):将请求添加到请求队列 2.Request:代表请求的接口 StringRequest:获取字符串结果的请求 JsonRequest:获取Json数据结
Volley网络请求使用讲解
wk_先森的博客
11-17 448
1.简介 1)它是2013年Goole I/O上发布的一款网络框架，基于android平台，能使网络通讯更快， 更简单，更健全 优点： 1）网络请求额排序 2）网络请求的优先级处理 3）缓存 4）多级别取消处理 5）和activity生命周期联动（Activity结束时取消所有网络请求） 6）非常适合去进行数据量不大，但是通讯频繁的网络操作 7）可以自定义扩展 缺点： 对于
常用的Volley网络请求方法:
zw904448290的博客
10-01 376
一.Volley Volley结合了AsyncHttpClient和Universal-Image-Loader的优点——简化了http的使用 + 异步加载图片的神奇能力。Android中的Http实现主要有HttpUrlConnection和HttpClient两种，关于二者的选择Google在Blog中表示推荐在姜饼小人（API level = 9）及以上的版本中使用Java的HttpU
volley网络请求架构分析
Garment1991的专栏
01-04 433
volley的源码架构的分析
Android 中使用Volley进行网络请求和图片加载详解
路宇的博客
03-26 4230
前言： Volley概述： Volley既可以访问网络取得数据，也可以加载图片，并且在性能方面进行了大幅度的调整。它的设计目标就是适合进行数据量不大但通信频繁 的网络操作。而对于大数据量的网络操作，比如说下载文件等，Volley的表现却非常糟糕。 使用Volley前，需要在项目的build.gradle中引入相应的依赖： implementation 'com.android.volley:volley:1.2.1' 一、使用Volley进行GET请求： 1.创建activity_volley.xml，代
Volley框架进行请求网络数据的使用
拼搏的少年的博客
10-27 1776
问题的阐述：Android SDK中的HttpClient和HttpUrlConnection两种请求方式用来处理网络的复杂的操作，但当应用比较复杂的时候需要我们编写大量的代码处理很多东西：图像缓存，请求的调度等等；解决：Volley就是为解决这些而生，它与2013年Google I/O大会上被提出：使得Android应用网络操作更方便更快捷；抽象了底层Http Client等实现的细节，让开发者更
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值