Android网络请求框架 Volley 你所要知道的一切

Volley是2013年谷歌官方推出的Android平台的网络通信库，Volley适用于并发和对效率、性能要求比较高的场景。

1.Volley的特点

优点：

（1）使通信更快、更简单

（2）高效的get、post网络请求以及网络图像的高效率异步处理请求

（3）能对网络请求进行排序、优先级处理

（4）网络图片加载和缓存

（5）多级别取消请求，当有多个网络请求同时进行的时候，可以进行同时取消操作

（6）和Activity生命周期的联动，当Activity结束销毁时，可以同时取消网络请求操作

（7）性能稳定

缺点：

（1）不适合数据的上传下载

2.Volley的下载

Github下载：

https://github.com/mcxiaoke/android-volley

Maven下载：

http://central.maven.org/maven2/com/mcxiaoke/volley/library/

3.Volley的get、post请求方式的使用

在进行get、post请求之前要确定请求的数据返回的类型是哪种类型，Volley提供了三种类型：

StringRequest：返回结果类型不确定的情况使用

JsonObjectRequest：返回结果类型为JsonObject

JsonArrayRequest：返回结果类型为JsonArray

（1）首先需要为应用程序建立全局请求队列

public class MyApplication extends Application {
    public static RequestQueue queue;
    @Override
    public void onCreate() {
        super.onCreate();
        // 建立Volley全局请求队列
        queue = Volley.newRequestQueue(getApplicationContext()); // 实例化RequestQueue对象
    }
    public static RequestQueue getHttpQueue() {
        return queue;
    }
}
注意：需要把MyApplication注册到AndroidManifest.xml中，并加上网络请求权限。

（2）Volley的get请求

/**
 * 返回结果类型不确定的情况下
 */
private void volleyGet(String url) {
    /**
     * int method 请求方式
     * String url 请求接口地址
     * Listener<String> listener 请求成功的回调
     * ErrorListener errorListener 请求失败的回调
     */
    StringRequest request = new StringRequest(Method.GET, url, new Response.Listener<String>() {
        @Override
        public void onResponse(String arg0) {
            System.out.println("请求成功：" + arg0); // 输出请求成功的返回结果
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError arg0) {
            System.out.println("请求失败：" + arg0);
        }
    });
    request.setTag("homeGet"); // 这个Tag设置的要有意义
    MyApplication.getHttpQueue().add(request); // 将请求加入到全局变量
}

/**
 * 返回结果类型为JsonObject
 *   注意：返回结果类型为JsonArray的请求方法和JsonObject类似
 */
private void volleyJOGet(String url) {
    /**
     * int method 请求方式
     * String url 请求接口地址
     * JSONObject jsonRequest Get为null，Post传递负载请求参数的Object
     * Listener<JSONObject> listener 请求成功的回调
     * ErrorListener errorListener 请求失败的回调
     */
    JsonObjectRequest request = new JsonObjectRequest(Method.GET, url, null, new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject arg0) {
            System.out.println("请求成功：" + arg0.toString()); // 输出请求成功返回的JSONObject，这里可以直接进行json解析了
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError arg0) {
            System.out.println("请求失败：" + arg0);
        }
    });
    request.setTag("homeJoGet"); // 这个Tag设置的要有意义
    MyApplication.getHttpQueue().add(request); // 将请求加入到全局变量
}

（3）Volley的post请求

首先我们用HashMap封装post请求的参数：

Map<String, String> hashmap = new HashMap<String, String>();
hashmap.put("zhangsan", "12"); // 将传递的参数添加进来
hashmap.put("key", "12");

然后就可以用封装好的参数向URL提交post请求了：

/**
 * 返回结果类型不确定的情况下
 */
private void volleyPost(String url, final HashMap<String, String> hashmap) {
    /**
     * int method 请求方式
     * String url 请求接口地址，使用post则请求参数不能写在URL里，而是使用参数化的传递
     *      例如url：http://www.demo.com/login/get?
     *      完整为：url：http://www.demo.com/login/get?zhangsan=12&key=12
     * Listener<String> listener 请求成功的回调
     * ErrorListener errorListener 请求失败的回调
     */
    StringRequest request = new StringRequest(Method.POST, url, new Response.Listener<String>() {
        @Override
        public void onResponse(String arg0) {
            System.out.println("请求成功：" + arg0); // 输出请求成功的返回结果
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError arg0) {
            System.out.println("请求失败：" + arg0);
        }
    }){
        // getParams()方法表示用户在volley中使用post方式请求数据中参数的传递
        // volley会自动调用getParams()中传递过来的请求参数
        @Override
        protected Map<String, String> getParams() {
            return hashmap;
        }
    };
    request.setTag("homePost"); // 这个Tag设置的要有意义
    MyApplication.getHttpQueue().add(request); // 将请求加入到全局变量
}

/**
 * 返回结果类型为JsonObject
 *   注意：返回结果类型为JsonArray的请求方法和JsonObject类似
 */
private void volleyJOPost(String url, final HashMap<String, String> hashmap) {
    JSONObject object = new JSONObject(hashmap);
    /**
     * int method 请求方式
     * String url 请求接口地址，使用post则请求参数不能写在URL里，而是使用参数化的传递
     *      例如url：http://www.demo.com/login/get?
     *      完整为：url：http://www.demo.com/login/get?zhangsan=12&key=12
     * JSONObject jsonRequest 传递负载请求参数的Object
     * Listener<JSONObject> listener 请求成功的回调
     * ErrorListener errorListener 请求失败的回调
     */
    JsonObjectRequest request = new JsonObjectRequest(Method.POST, url, object, new Response.Listener<JSONObject>() {
        @Override
        public void onResponse(JSONObject arg0) {
            System.out.println("请求成功：" + arg0.toString()); // 输出请求成功返回的JSONObject，这里可以直接进行json解析了
        }
    }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError arg0) {
            System.out.println("请求失败：" + arg0);
        }
    });
    request.setTag("homeJoPost"); // 这个Tag设置的要有意义
    MyApplication.getHttpQueue().add(request); // 将请求加入到全局变量
}

4.Volley的网络请求队列

在我们使用Volley时，要建立一个全局的请求队列，然后我们在建立一个请求，把请求加入到全局队列中，这样app的请求是通过队列管理的，方便我们进行取消某个请求或者取消全部请求。

5.Volley与Activity生命周期的联动

Volley的生命周期和Activity的生命周期是关联在一起的，可以在Activity销毁时，同时关闭请求。

一般我们将Volley和Activity的生命周期关联的时候，都需要设置我们的Tag标签（通过Tag标签在全局队列中查找），然后在onStop()方法中执行取消请求。

@Override
protected void onStop() {
    super.onStop();
    MyApplication.getHttpQueue().cancelAll("homeGet"); // 通过给定的tag值，将指定的队列全部关闭
}

6.Volley的二次回调封装-自定义Get

全局使用一个方式，可控，可自定义定制需求

首先我们创建自己的请求管理VolleyRequest，其中listener, errorListener还没有创建

public class VolleyRequest {
    public static StringRequest request;
    public static Context context;
    /**
     * GET请求
     * @param context
     * @param url
     * @param tag
     */
    public static void RequestGet(Context context, String url, String tag){
        MyApplication.getHttpQueue().cancelAll(tag); // 将tag标签的请求都取消掉，放在重复请求
        StringRequest request = new StringRequest(Method.GET, url, listener, errorListener);

        request.setTag(tag);
        MyApplication.getHttpQueue().add(request);
        MyApplication.getHttpQueue().start();
    }
}

接下来创建自定义VolleyInterface抽象类

public abstract class VolleyInterface {
    public Context context;
    public static Response.Listener<String> listener;
    public static Response.ErrorListener errorListener;

    public VolleyInterface(Context context, Response.Listener<String> listener,
            Response.ErrorListener errorListener){
        this.context = context;
        this.listener = listener;
        this.errorListener = errorListener;
    }
    public abstract void onMySuccess(String result);
    public abstract void onMyError(VolleyError error);
    /**
     * 请求成功
     * @return
     */
    public Response.Listener<String> successListener(){
        listener = new Response.Listener<String>(){
            @Override
            public void onResponse(String arg0) {
                onMySuccess(arg0);
            }
        };
        return listener;
    }
    /**
     * 请求失败
     * @return
     */
    public Response.ErrorListener errorListener(){
        errorListener = new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError arg0) {
                onMyError(arg0);
            }
        };
        return errorListener;
    }
}

接下来我们就可以在VolleyRequest中使用VolleyInterface了：

public class VolleyRequest {
    public static StringRequest request;
    public static Context context;
    /**
     * GET请求
     * @param context
     * @param url
     * @param tag
     * @param vi
     */
    public static void RequestGet(Context context, String url, String tag, VolleyInterface vi){
        MyApplication.getHttpQueue().cancelAll(tag); // 将tag标签的请求都取消掉，放在重复请求
        StringRequest request = new StringRequest(Method.GET, url, vi.successListener(), vi.errorListener());

        request.setTag(tag);
        MyApplication.getHttpQueue().add(request);
        MyApplication.getHttpQueue().start();
    }
}

到此，自定义get就写好了。

7.Volley的二次回调封装-自定义Post

在VolleyRequest中添加自定义post方法：

public class VolleyRequest {
    public static StringRequest request;
    public static Context context;
    /**
     * GET请求
     * @param context
     * @param url
     * @param tag
     * @param vi
     */
    public static void RequestGet(Context context, String url, String tag, VolleyInterface vi){
        MyApplication.getHttpQueue().cancelAll(tag); // 将tag标签的请求都取消掉，放在重复请求
        StringRequest request = new StringRequest(Method.GET, url, vi.successListener(), vi.errorListener());

        request.setTag(tag);
        MyApplication.getHttpQueue().add(request);
        MyApplication.getHttpQueue().start();
    }
    /**
     * POST请求
     * @param context
     * @param url
     * @param tag
     * @param hashmap
     * @param vi
     */
    public static void RequestPost(Context context, String url, String tag, final HashMap<String, String> hashmap, VolleyInterface vi){
        MyApplication.getHttpQueue().cancelAll(tag); // 将tag标签的请求都取消掉，放在重复请求
        StringRequest request = new StringRequest(Method.GET, url, vi.successListener(), vi.errorListener()){
            @Override
            protected Map<String, String> getParams() {
                return hashmap;
            }
        };
        request.setTag(tag);
        MyApplication.getHttpQueue().add(request);
        MyApplication.getHttpQueue().start();
    }
}

8.在Activity中使用二次封装好的Volley框架

/**
* 返回结果类型不确定的情况下
 */
private void volleyGet(String url) {
    VolleyRequest.RequestGet(this, url, "homeGet", new VolleyInterface(this,
            VolleyInterface.listener, VolleyInterface.errorListener) {
        @Override
        public void onMySuccess(String result) {
            System.out.println("请求成功：" + result);
        }
        @Override
        public void onMyError(VolleyError error) {
            System.out.println("请求失败：" + error.toString());
        }
    });
}

9.Volley使用ImageRequest获取网络图片

Volley加载网络图片可以使用ImageRequest或者ImageLoader，监听使用ImageListener，网络图片的显示也可以用NetworkImageView或者ImageView。

public class MainActivity extends Activity {
    private ImageView iv_img;
    String url = "";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv_img = (ImageView)findViewById(R.id.iv_img);
        /**
         * String url 图片地址
         * Listener<Bitmap> listener 图片请求成功的回调
         * int maxWidth 图片大小的压缩处理，设置0则显示原图
         * int maxHeight
         * Config decodeConfig 加载图片的格式
         * ErrorListener errorListener 请求失败的回调
         */
        ImageRequest request = new ImageRequest(url, new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap arg0) {
                iv_img.setImageBitmap(arg0);
            }
        }, 200, 200, Config.RGB_565, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError arg0) {
                iv_img.setBackgroundResource(R.drawable.ic_launcher); // 显示请求失败的图片
            }
        });
    }
}

10.Volley使用ImageLoader缓存网络图片

（1）创建ImageLoader

public class MainActivity extends Activity {
    private ImageView iv_img;
    String url = "";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv_img = (ImageView)findViewById(R.id.iv_img);
        /**
         * RequestQueue queue 请求队列
         * ImageCache imageCache 缓存
         */
        ImageLoader loader = new ImageLoader(MyApplication.getHttpQueue(), new BitmapCache());
    }
}

这里需要使用到imageCache（创建了BitmapCache实例），ImageCache单独使用是起不到缓存作用的，所以还要结合LruCache，接下来自定义一个ImageCache缓存类：

public class BitmapCache implements ImageCache{

    public LruCache<String, Bitmap> cache;
    public int maxSize = 10*1024*1024; // 10M，定义LruCache最大缓存大小，当超过会启动自动回收
    public BitmapCache(){
        cache = new LruCache<String, Bitmap>(maxSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight();
            }
        };
    }
    @Override
    public Bitmap getBitmap(String arg0) {
        return cache.get(arg0);
    }
    @Override
    public void putBitmap(String arg0, Bitmap arg1) {
        cache.put(arg0, arg1);
    }
}

（2）下来需要创建ImageListener来监听图片的加载过程：

public class MainActivity extends Activity {
    private ImageView iv_img;
    String url = "";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv_img = (ImageView)findViewById(R.id.iv_img);
        /**
         * RequestQueue queue 请求队列
         * ImageCache imageCache 缓存
         */
        ImageLoader loader = new ImageLoader(MyApplication.getHttpQueue(), new BitmapCache());
        /**
         * ImageView view ImageView控件
         * int defaultImageResId 默认的加载图片
         * int errorImageResId 加载出错的时候显示的图片
         */
        ImageListener listener = ImageLoader.getImageListener(iv_img,
                R.drawable.ic_launcher, R.drawable.ic_launcher);
        loader.get(url, listener); // 获取网络图片
    }
}

到此使用ImageLoader缓存网络图片就已经完成了。

10.Volley使用NetworkImageView加载网络图片

NetworkImageView是要搭配ImageLoader进行使用的：

public class MainActivity extends Activity {
    private NetworkImageView niv_img;
    String url = "";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        niv_img = (NetworkImageView)findViewById(R.id.niv_img);
        /**
         * RequestQueue queue 请求队列
         * ImageCache imageCache 缓存
         */
        ImageLoader loader = new ImageLoader(MyApplication.getHttpQueue(), new BitmapCache());
        niv_img.setDefaultImageResId(R.drawable.ic_launcher); // 设置默认图片
        niv_img.setErrorImageResId(R.drawable.ic_launcher); // 设置默认图片
        niv_img.setImageUrl(url, loader); // 设置默认图片
    }
}
时间： 2024-08-01 20:32:15

Android网络请求框架 Volley 你所要知道的一切的相关文章

网络请求框架---Volley

去年的Google I/O大会为android开发者带来了一个网络请求框架,它的名字叫做Volley.Volley诞生的使命就是让Android的网络请求更快,更健壮,而且它的网络通信的实现是基于HttpURLConnection的.前几天我整理了两个网络请求工具类,应付日常工作的开发需求还是没问题的,自己分别在HttpURLConnection和HttpClient的基础上进行进一层的封装,保证了API的足够简洁友好.有兴趣的同学可以回头去翻翻,源码在Github上,搜索AndroidHttp

Android网络请求框架AsyncHttpClient实例详解(配合JSON解析调用接口)

最近做项目要求使用到网络,想来想去选择了AsyncHttpClient框架开进行APP开发.在这里把我工作期间遇到的问题以及对AsyncHttpClient的使用经验做出相应总结,希望能对您的学习有所帮助. 首先按照惯例先来简单了解一些AsyncHttpClient网络框架的一些知识. 1.简介 Android中网络请求一般使用Apache HTTP Client或者采用HttpURLConnect,但是直接使用这两个类库需要写大量的代码才能完成网络post和get请求,而使用android-a

【Java&amp;Android开源库代码剖析】のandroid-async-http（如何设计一个优雅的Android网络请求框架，同时支持同步和异步请求）开篇

在<[Java&Android开源库代码剖析]のandroid-smart-image-view>一文中我们提到了android-async-http这个开源库,本文正式开篇来详细介绍这个库的实现,同时结合源码探讨如何设计一个优雅的Android网络请求框架.做过一段时间Android开发的同学应该对这个库不陌生,因为它对Apache的HttpClient API的封装使得开发者可以简洁优雅的实现网络请求和响应,并且同时支持同步和异步请求. 网络请求框架一般至少需要具备如下几个组件:1

Volley网络请求框架简析——Android网络请求框架（三）

题记-- 人来到这个世界上,只有两件事情,生与死, 一件事完了,另一件事还急什么? 有缘而来,无缘而去, 识自本心,见自本性 不起妄缘,无心无为 自由自在,动静自如 冷暖自知,则是修行 1.初始化一个消息请求队列以及网络请求工具类对象 /** * Created by androidlongs on 16/7/1. * 网络请求访问框架 */ public class VollyRequestUtils { /** * Volley框架使用工具类对象 */ private static Voll

Android学习笔记：Andorid网络请求框架Volley的使用（上）

Volley框架是Google I/O 2013大会上发布的.Volley是Google针对Android平台上的网络通信库而诞生,该框架能使网络通信更快,更简单,更健壮.Volley的特点有: Ⅰ:通信更简单更快捷 ll:Get,Post网络请求及网络图像进行高效异步处理 III:可以对多个网络请求进行优先级排序以级多级别取消操作 IV:网络请求缓存及与Activity生命周期进行联动,在Activity销毁的时候可以对网络请求进行取消操作,防止内存泄露. Volley的使用很简单: 1,下载

Android网络请求之Volley框架

首先必须声明权限: <uses-permission android:name="android.permission.INTERNET"/> 添加jar包并在application中注册: public class MyApplication extends Application { public static RequestQueue queue; @Override public void onCreate() { super.onCreate(); queue =

android网络请求库volley方法详解

使用volley进行网络请求:需先将volley包导入androidstudio中 File下的Project Structrue,点加号导包 volley网络请求步骤: 1. 创建请求队列       RequestQueue queue = Volley.newRequestQueue(this); 2.创建请求对象(3种) StringRequest request = new StringRequest(“请求方法”,“请求的网络地址”,“成功的网络回调”,“失败的网络回调”): Ima

Android网络请求框架—OKHttp 源码解析

总体流程 整个流程是,通过OkHttpClient将构建的Request转换为Call,然后在RealCall中进行异步或同步任务,最后通过一些的拦截器interceptor发出网络请求和得到返回的response. 将流程大概是这么个流程,大家可以有个大概的印象,继续向下看: OkHttp流程图.jpg 为了让大家有更深的印象,我准备追踪一个GET网络请求的具体流程,来介绍在源码中发生了什么. GET请求过程 这是利用OkHttp写一个Get请求步骤,这里是一个同步的请求,异步的下面也会说:

Android 网络请求库volley的封装，让请求更方便

首先封装一下volley 请求 public class CustomRequest extends StringRequest { private static final String TAG = CustomRequest.class.getSimpleName(); private String mBody; private Map<String, String> mHeaders = new HashMap<>(); public CustomRequest(int me