使用 Volley

Volley 是一个 HTTP 库，它能够帮助 Android app 更方便地执行网络操作，最重要的是，它更快速高效。我们可以通过开源的 AOSP 仓库获取到 Volley
Volley 不适合用来下载大的数据文件。因为 Volley 会保持在解析的过程中所有的响应。对于下载大量的数据操作，请考虑使用 DownloadManager。

发送简单的网络请求

1)Add the INTERNET Permission

为了使用Volley，你必须添加android.permission.INTERNET权限到你的manifest文件中。没有这个权限，你的app将无法访问网络。

2)Use newRequestQueue

Volley提供了一个简便的方法：Volley.newRequestQueue用来为你建立一个RequestQueue，使用默认值，并启动这个队列。

public void sendSimpleRequest(){

        RequestQueue rQuene = Volley.newRequestQueue(this);
        String url = "https://www.baidu.com";

        Log.i("info", "send start");
        StringRequest stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener(){
            @Override
            public void onResponse(Object response) {
                Log.i("info", response.toString());
                Toast.makeText(getApplicationContext(), response.toString().substring(0,500),
                        Toast.LENGTH_SHORT).show();

                Log.i("info", "send complete");
            }
        },new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.i("info", "error");
                Toast.makeText(getApplicationContext(), "error",
                        Toast.LENGTH_SHORT).show();
            }
        });

        //添加到请求队列，发送请求
        rQuene.add(stringRequest);
        Log.i("info", "send end");
    }

建立请求队列方式

建立网络和缓存

一个 RequestQueue 需要两部分来支持它的工作：一部分是网络操作，用来传输请求，另外一个是用来处理缓存操作的 Cache。在 Volley 的工具箱中包含了标准的实现方式：DiskBasedCache 提供了每个文件与对应响应数据一一映射的缓存实现。 BasicNetwork 提供了一个基于 AndroidHttpClient 或者 HttpURLConnection 的网络传输。

BasicNetwork 是 Volley 默认的网络操作实现方式。一个 BasicNetwork 必须使用我们的 app 用于连接网络的 HTTP Client 进行初始化。这个 Client 通常是AndroidHttpClient 或者 HttpURLConnection：

对于 app target API level 低于 API 9（Gingerbread）的使用 AndroidHttpClient。在 Gingerbread 之前，HttpURLConnection 是不可靠的。对于这个的细节，请参考 Android’s HTTP Clients。
对于 API Level 9 以及以上的，使用 HttpURLConnection。
具体代码如下：

    private void sendRequestQueue() {
        //建立缓存
        Cache cache = new DiskBasedCache(getCacheDir(), 1024*1024);

        //
        Network network = new BasicNetwork(new HurlStack());

        RequestQueue rQueue = new RequestQueue(cache, network);

        rQueue.start();

        String url = "https://www.baidu.com";

        StringRequest stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>(){
            @Override
            public void onResponse(String response) {
                Log.i("info", response);
                Toast.makeText(getApplicationContext(), response.substring(0, 500), Toast.LENGTH_SHORT).show();
            }
        }, new Response.ErrorListener(){
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.i("info", error.toString());
            }
        });

        //把请求添加到队列
        rQueue.add(stringRequest);
    }

使用单例模式下载图片并显示

如果我们的应用需要持续地使用网络，更加高效的方式应该是建立一个 RequestQueue 的单例，这样它能够持续保持在整个 app 的生命周期中。我们可以通过多种方式来实现这个单例。推荐的方式是实现一个单例类，里面封装了 RequestQueue 对象与其它的 Volley 功能。另外一个方法是继承 Application 类，并在 Application.OnCreate() 方法里面建立 RequestQueue。但是我们并不推荐这个方法，因为一个 static 的单例能够以一种更加模块化的方式提供同样的功能。

一个关键的概念是 RequestQueue 必须使用 Application context 来实例化，而不是 Activity context。这确保了 RequestQueue 在我们 app 的生命周期中一直存活，而不会因为 activity 的重新创建而被重新创建(例如，当用户旋转设备时)。

下面是一个单例类，提供了 RequestQueue 与 ImageLoader 功能：

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;
    }
}

调用代码

    private void getImageByUrl() {
        Toast.makeText(getApplicationContext(), "开始加载图片", Toast.LENGTH_SHORT).show();
        String url = "http://i.imgur.com/7spzG.png";
        ImageRequest imageRequest = new ImageRequest(url, new Response.Listener(){
                @Override
                public void onResponse(Object response) {
                    imageView.setImageBitmap((Bitmap)response);
                    Toast.makeText(getApplicationContext(), "加载成功", Toast.LENGTH_SHORT).show();
                }
            },0,0,null, new Response.ErrorListener(){
                @Override
                public void onErrorResponse(VolleyError error) {
                    Toast.makeText(getApplicationContext(), "加载失败", Toast.LENGTH_SHORT).show();
                }
            }
        );
        MySingleton.getInstance(this).addToRequestQueue(imageRequest);
    }

最后结果

请求网页

加载网络图片