Android网络通信框架Volley总结

　　1.什么是Volley?

　　　　Volley是一个网络通信库，它是对网络操作的一个封装框架，能够简化网络的相关操作，同时使网络更快、更简单、更健壮。

　　2.Volley有什么用？

　　　　　　

　　　　　　上面这张图是在2013年Google I/O 大会中，引入Volley时所采用的图，由于Volley是一个网络通信库，那么这张图可以很清晰的告诉我们Volley使用的场景，即是适用于数据量不大但是网络通信很频繁的时候，如JSON/XML文本数据或图片加载等操作，不适用与大量数据的网络操作，如大数据的下载，文件上传和流媒体。

　　　　复习：Android中网络通信常用类:HttpURLConnection、HttpClient、AsyncTask、AsyncTaskLoader、Thread+handler等。

　　3.Volley原理

　　　　Volley使用线程池作为基本结构：线程分为main thread，cache thread，network thread.

　　　　 结构图:

　　　　

　　　　

　　4.Volley的使用

　　　　任意创建一个规范的Android项目，然后在src目录下新建一个包com.android.volly，将Volleyball源码拷到这个包下就可以了。

　　　　

　　　　

　　　　

　　　　

　　　　核心代码:

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

　　　　

 　　　　

　　　　可以将所有的操作封装成一个工具类,这里RequestQueue类和ImageLoader类在内存中始终只存在一个对象:

　　　　

package com.qf.utils;

import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;

import android.content.Context;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;

import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.Volley;

public class VolleyUtils {

    public static RequestQueue mQueue;
    public static ImageLoader mLoader;
    
    private static LruCache<String,Bitmap> lruCache;//强引用缓存，一级缓存，特点：使用最近最少使用的算法，将旧数据移除，为新数据提供空间
    private static Map<String,SoftReference<Bitmap>> softCache; //软引用缓存，二级缓存
    
    
    public static RequestQueue getQueue(Context context){
        if(mQueue==null){
            mQueue=Volley.newRequestQueue(context);
        }
        
        return mQueue;
    }
    
    public static ImageLoader getLoader(Context context){
        if(mLoader==null){
            //实例化二级缓存
            softCache=new HashMap<String, SoftReference<Bitmap>>();
            
            //实例化一级缓存
            lruCache=new LruCache<String, Bitmap>(2*1024*1024){  //缓存的内存空间为2M
                @Override
                protected int sizeOf(String key, Bitmap value) {
                    // TODO 计算存放成员的大小，返回字节大小
                    return value.getRowBytes()*value.getHeight();
                }
                
                @Override
                protected void entryRemoved(boolean evicted, String key,
                        Bitmap oldValue, Bitmap newValue) {
                    // TODO 移除旧成员
                
                    if(evicted)
                        //将移除的成员存放到二级缓存中
                        softCache.put(key, new SoftReference<Bitmap>(oldValue));
                    
                    super.entryRemoved(evicted, key, oldValue, newValue);
                }
            };
            
            mLoader=new ImageLoader(getQueue(context), new ImageLoader.ImageCache() {
                
                @Override
                public void putBitmap(String url, Bitmap bitmap) {
                    // TODO 将图片存放在缓存中的方法
                    //将图片存放在一级缓存中
                    lruCache.put(url, bitmap);
                    
                    //将图片也存放在扩展卡
                    try {
                        ImageUtils.saveImg(url, bitmap);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                
                @Override
                public Bitmap getBitmap(String url) {
                    // TODO 从缓存中读取图片的方法
                    //先从一级缓存中获取
                    Bitmap b=lruCache.get(url);
                    if(b==null){
                        //从二级缓存中读取
                        SoftReference<Bitmap> reference=softCache.get(url);
                        if(reference!=null){ //二级缓存中存在
                            b=reference.get();
                            if(b!=null){
                                //将图片对象存放在一级缓存
                                lruCache.put(url, b);
                                
                                //从二级缓存中移除
                                softCache.remove(reference);
                            }
                        }else{ //从三级缓存中读取--扩展卡
                            b=ImageUtils.getImg(url);
                            if(b!=null){
                                //将图片存放到一级缓存中
                                lruCache.put(url, b);
                            }
                        }
                    }
                    return b;
                }
            });
        }
        
        return mLoader;
    }
    
}

　　　　

　　　　

　　　　使用Volley获取网络图片的三种方法:

　　　　1. ImageRequest类

　　　　　　

 // 参数2: 图片下载成功, 自动回调这个接口
        // 参数3: 内存中Bitmap 最大的宽度限制，用于降低内存的消耗
        // 参数4：内存中 Bitmap 最大的高度限制，用于降低内存的消耗
        // 参数5：告诉 BitmapFactory，在生成Bitmap的时候，一个像素，包含的信息
        // 参数 6：图片加载失败的时候，回调
        ImageRequest request = new ImageRequest(url,
                new Response.Listener<Bitmap>() {
                    @Override
                    public void onResponse(Bitmap response) {
                        imageView.setImageBitmap(response);
                    }
                }
                ,200,100,Bitmap.Config.ARGB_8888,
                new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        imageView.setImageResource(R.drawable.ic_launcher);
                    }
                });

　　　　2.ImageLoader类

　　　　　　

 // 参数1 : 用于实际的网络请求
        // 参数2 : ImageCache 内存缓存
        imageLoader = new ImageLoader(requestQueue, new ImageLoader.ImageCache() {
            LruCache<String,Bitmap> cache = new LruCache<>(10);
            @Override
            public Bitmap getBitmap(String url) {
                return cache.get(url);
            }

            @Override
            public void putBitmap(String url, Bitmap bitmap) {
                cache.put(url,bitmap);
            }
        });

　　　　　　

 //方法1
        /*imageLoader.get(url, new ImageLoader.ImageListener() {
            @Override
            public void onResponse(ImageLoader.ImageContainer response, boolean isImmediate) {
                // TODO 设置图片
            }

            @Override
            public void onErrorResponse(VolleyError error) {
                // TODO 设置失败图片
            }
        });*/

        //方法2
        ImageView imageView = (ImageView) findViewById(R.id.imageView);
        imageLoader.get(url+"sdf",
                ImageLoader.getImageListener(imageView,R.drawable.ic_launcher,android.R.drawable.ic_delete));

　　　　3.NetworkImageView类

　　　　　NetworkImageVIew类时Volley自定义的一个类，它继承ImageView，在XML文件中可以像ImageView控件一样使用，与ImageView的使用没有区别，只是NetworkImageView是用来加载网络图片的ImageView。

　　　　　

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

    <ImageView
            android:id="@+id/imageView"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            />
    <com.android.volley.toolbox.NetworkImageView
            android:id="@+id/networkImageView"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            />
    <android.support.v4.view.ViewPager
            android:id="@+id/viewPager"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>

</LinearLayout>

　　　　　

 //NetworkImageView
        NetworkImageView networkImageView = (NetworkImageView) findViewById(R.id.networkImageView);
        networkImageView.setImageUrl(url,imageLoader);

　　　　

　　　　未完，待续。