Android Volley

Android Volley 是什么，是一种网络通信的框架，是google 官方维护的网络框架，能很好的支持网络的小信息通信。

github地址
 介绍的ppt地址
 jar包下载地址
 volley-1.0.9.jar
volley-1.0.9-javadoc.jar
volley-1.0.9-sources.jar

我们都需要json，images，raw text Memory 和强有力的缓存机制。安卓本来就支持http client ，但volley只是做更为普通的工作。

在安卓中，记得一定要添加网络权限

<uses-permission android:name="android.permission.INTERNET" /> 

##volley支持什么 volley能够传递json数据，图片数据加载。

volley的简单应用： RequestQueue mQueue = Volley.newRequestQueue(context);
RequestQueue 是一个控制http请求的请求队列，需要用mQueue.add(function) 把需要的请求放进队列中，并且mQueue.stop()在Activity结束的时候释终止没有完成的请求。
function 中包括 StringRequest(),JsonArrayRequest(),JsonObjectRequest(),JsonRequest().

对于图片的应用：

ImageListener listener = ImageLoader.getImageListener(imageView, android.R.drawable.ic_menu_rotate, null);
mImageLoader.get(url, listener);//url是图片的地址

使用的函数说明：

    private void add(){
    	RequestQueue mQueue =null;
        mQueue = Volley.newRequestQueue(getApplicationContext());  
        mQueue.add(new StringRequest(Method.GET, "http://www.baidu.com", new Listener<String>() {

			@Override
			public void onResponse(String arg0) {
				// TODO Auto-generated method stub
				System.out.println(arg0.toString());
			}
		},  
                    null));  
        mQueue.start();

上述的代码是get方式，至于post方式则

StringRequest stringRequest = new StringRequest(Method.POST, "http://www.baidu.com",  new Listener<String>() {

			@Override
			public void onResponse(String arg0) {
				// TODO Auto-generated method stub
				System.out.println(arg0.toString());
			}
		}, errorListener) {   
    @Override   
    protected Map<String, String> getParams() throws AuthFailureError {  
        Map<String, String> map = new HashMap<String, String>();  
        map.put("params1", "value1");  
        map.put("params2", "value2");  
        return map;  
    }  
};

图片加载

    ImageRequest imageRequest = new ImageRequest(  
            picture_url,  
            new Response.Listener<Bitmap>() {  
                @Override  
                public void onResponse(Bitmap response) {  
                    imageView.setImageBitmap(response);  
                }  
            }, 0, 0, Config.RGB_565, new Response.ErrorListener() {  
                @Override  
                public void onErrorResponse(VolleyError error) {  
                    imageView.setImageResource(R.drawable.default_image);  
                }  
            });  

ImageRequest image = new ImageRequest(url, listener, maxWidth, maxHeight, decodeConfig, errorListener)
listener 控制的是成功后的操作。

    ImageLoader imageLoader = new ImageLoader(mQueue, new ImageCache() {  
        @Override  
        public void putBitmap(String url, Bitmap bitmap) {  
        }  
      //实现缓存机制
        @Override  
        public Bitmap getBitmap(String url) {  
            return null;  
        }  
    });  

    ImageListener listener = ImageLoader.getImageListener(imageView, R.drawable.default_image, R.drawable.failed_image); 

    imageLoader.get("picture_url",  
                listener, 200, 200); 

//对ImageCache实现缓存机制
    public class BitmapCache implements ImageCache {  
  
    private LruCache<String, Bitmap> mCache;  
  
    public BitmapCache() {  
        int maxSize = 10 * 1024 * 1024;  
        mCache = new LruCache<String, Bitmap>(maxSize) {  
            @Override  
            protected int sizeOf(String key, Bitmap bitmap) {  
                return bitmap.getRowBytes() * bitmap.getHeight();  
            }  
        };  
    }  
  
    @Override  
    public Bitmap getBitmap(String url) {  
        return mCache.get(url);  
    }  
  
    @Override  
    public void putBitmap(String url, Bitmap bitmap) {  
        mCache.put(url, bitmap);  
    }  

  ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache());//最后的功能实现
} 

NetworkImageView 实现

layout布局上

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
        android:layout_width="fill_parent"  
        android:layout_height="fill_parent"  
        android:orientation="vertical" >  
      
        <Button  
            android:id="@+id/button"  
            android:layout_width="wrap_content"  
            android:layout_height="wrap_content"  
            android:text="Send Request" />  
          
        <com.android.volley.toolbox.NetworkImageView   
            android:id="@+id/network_image_view"  
            android:layout_width="200dp"  
            android:layout_height="200dp"  
            android:layout_gravity="center_horizontal"  
            />  
      
    </LinearLayout>  

    networkImageView = (NetworkImageView) findViewById(R.id.network_image_view); 
    networkImageView.setDefaultImageResId(R.drawable.default_image);  
    networkImageView.setErrorImageResId(R.drawable.failed_image);  
    networkImageView.setImageUrl("picture_url", imageLoader);

基本上volley就这样，而且我们还可以自订自己的Request

单例模式的volley使用，在volley使用的时候，我们有时候需要注意的是RequestQueue最好是伴随着一个应用的随时使用，这样不会产生多于的操作并且容易掌控，虽然可以继承Application中使用OnCreat方法来调用，但模块化的单例模式能更好的定制。

package com.example.test.net;

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

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

public class MySingleton {

    private static MySingleton mInstance;
    private RequestQueue mRequestQueue;
    private static Context mCtx;
    private ImageLoader mImageLoader;
    private MySingleton(Context context){
        mCtx= context;
        mRequestQueue = getRequestQueue();
        mImageLoader = new ImageLoader(mRequestQueue,new ImageCache() {
            private final LruCache<String,Bitmap> 
            cache = new LruCache<String,Bitmap>(20);//缓存设置
            @Override
            public void putBitmap(String arg0, Bitmap arg1) {
                // TODO Auto-generated method stub
                cache.put(arg0, arg1);
            }
            
            @Override
            public Bitmap getBitmap(String arg0) {
                // TODO Auto-generated method stub
                return cache.get(arg0);
            }
        });
    }
    
    public RequestQueue getRequestQueue(){
        if(mRequestQueue==null){
            mRequestQueue = Volley.newRequestQueue(mCtx);
        }
        return mRequestQueue;
    }//获取 RequestQueue 队列
    
    public static synchronized MySingleton getInstance(Context con){
        if(mInstance==null){
            mInstance = new MySingleton(con);
        }
        return mInstance;
    }//单例模式
    public <T> void addToRequestQueue(Request<T> req){
        getRequestQueue().add(req);
    }//把 String 或者 JSON 请求 添加到队列中
    
    public ImageLoader getImageLoader(){
        return mImageLoader;//
    }
    /* 上面的用法
     * ImageListener listener = ImageLoader.getImageListener(imageView, R.drawable.default_image, R.drawable.failed_image); 
        imageLoader.get("picture_url",  listener, 200, 200); 
     */
}