Volley的简单使用

Gson的使用---引入包---谷歌下的包
自动生成解析对象---file---plugins--搜索GsonFormat---Generate -gsonFormat




1. 创建一个RequestQueue对象。
RequestQueue mQueue = Volley.newRequestQueue(context); 
注意这里拿到的RequestQueue是一个请求队列对象，它可以缓存所有的HTTP请求，
然后按照一定的算法并发地发出这些请求。RequestQueue内部的设计就是非常合适高并发的，
因此我们不必为每一次HTTP请求都创建一个RequestQueue对象，这是非常浪费资源的，
基本上在每一个需要和网络交互的Activity中创建一个RequestQueue对象就足够了 
2. 创建一个StringRequest对象。
StringRequest stringRequest = new StringRequest("http://www.baidu.com",  
                        new Response.Listener<String>() {  
                            @Override  
                            public void onResponse(String response) {  
                                Log.d("TAG", response);  
                            }  
                        }, new Response.ErrorListener() {  
                            @Override  
                            public void onErrorResponse(VolleyError error) {  
                                Log.e("TAG", error.getMessage(), error);  
                            }  
                        }); 
可以看到，这里new出了一个StringRequest对象，StringRequest的构造函数需要传入三个参数，
第一个参数就是目标服务器的URL地址，第二个参数是服务器响应成功的回调，
第三个参数是服务器响应失败的回调。其中，目标服务器地址我们填写的是百度的首页，
然后在响应成功的回调里打印出服务器返回的内容，在响应失败的回调里打印出失败的详细信息。
3. 将StringRequest对象添加到RequestQueue里面。


当发出POST请求的时候，Volley会尝试调用StringRequest的父类——Request中的getParams()方法来获取POST参数，
那么解决方法自然也就有了，我们只需要在StringRequest的匿名类中重写getParams()方法，
在这里设置POST参数就可以了，代码如下所示：
StringRequest stringRequest = new StringRequest(Method.POST, url,  listener, 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;  
    }  
};  
======================================(自定义Request)创建一个JSON自定义的对象继承Request================================================
public class QsbkRequest extends Request<QsbkBean>{


    private final Response.Listener<QsbkBean> mListener;
    /**
     * Creates a new request with the given method.
     *
     * @param method the request {@link Method} to use
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public QsbkRequest(int method, String url, Response.Listener<QsbkBean> listener,
                         Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }


    /**
     * Creates a new GET request.
     *
     * @param url URL to fetch the string at
     * @param listener Listener to receive the String response
     * @param errorListener Error listener, or null to ignore errors
     */
    public QsbkRequest(String url, Response.Listener<QsbkBean> listener, Response.ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }
    @Override
    protected Response<QsbkBean> parseNetworkResponse(NetworkResponse response) {
        //更具json数据获得qsbk对象


        Gson gson = new Gson();
        QsbkBean qsbkBean = null;
        try {
            qsbkBean = gson.fromJson(new String(response.data, HttpHeaderParser.parseCharset(response.headers)), QsbkBean.class);
        } catch (UnsupportedEncodingException e) {
            qsbkBean = gson.fromJson(new String(response.data),QsbkBean.class);
        }
        return Response.success(qsbkBean, HttpHeaderParser.parseCacheHeaders(response));
    }


    @Override
    protected void deliverResponse(QsbkBean response) {
        mListener.onResponse(response);
    }
}
============================================================================
 //post请求String


        requestQueue = MyApplication.getRequestQueue();
        //声名请求的request
        StringRequest stringRequest = new StringRequest(Request.Method.POST, AppUri.pathPost, new Response.Listener<String>() {
            public void onResponse(String response) {
                tvTest.setText(response);
            }
        }, new Response.ErrorListener() {
            public void onErrorResponse(VolleyError error) {
            }
        }) {
            /*给post请求设置参数,  在StringRequest中重写getParams方法*/
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                HashMap<String, String> postParamsMap = new HashMap<>();
                //设置参数
                //post测试
                //post提交的字段：pageNo=1&pageSize=20&serialIds=2143,3404&v=4.0.0
                // public final static  String pathPost = "http://mrobot.pcauto.com.cn/v2/cms/channels/1?";
                postParamsMap.put("pageNo", "1");
                postParamsMap.put("pageSize", "20");
                postParamsMap.put("serialIds", "2143,3404");
                postParamsMap.put("v", "4.0.0");
                return postParamsMap;
            }
        };


---------------=======================================================\
1. 创建一个RequestQueue对象。
2. 创建一个ImageRequest对象。
3. 将ImageRequest对象添加到RequestQueue里面。
其中，StringRequest和JsonRequest都是继承自Request的，所以它们的用法才会如此类似。
那么不用多说，今天我们要学习的ImageRequest，相信你从名字上就已经猜出来了，它也是继承自Request的，
因此它的用法也是基本相同的，首先需要获取到一个RequestQueue对象，可以调用如下方法获取到：
ImageRequest imageRequest = new ImageRequest(  
        "http://developer.android.com/images/home/aw_dac.png",  
        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的构造函数接收六个参数，第一个参数就是图片的URL地址，
这个没什么需要解释的。第二个参数是图片请求成功的回调，
这里我们把返回的Bitmap参数设置到ImageView中。
第三第四个参数分别用于指定允许图片最大的宽度和高度，
如果指定的网络图片的宽度或高度大于这里的最大值，则会对图片进行压缩，
指定成0的话就表示不管图片有多大，都不会进行压缩。第五个参数用于指定图片的颜色属性，
Bitmap.Config下的几个常量都可以在这里使用，其中ARGB_8888可以展示最好的颜色属性，
每个图片像素占据4个字节的大小，而RGB_565则表示每个图片像素占据2个字节大小
。第六个参数是图片请求失败的回调，这里我们当请求失败时在ImageView中显示一张默认图片。
最后将这个ImageRequest对象添加到RequestQueue里就可以了：


=========================================================


ImageLoader的用法
实际上，Volley在请求网络图片方面可以做到的还远远不止这些，而ImageLoader就是一个很好的例子。
ImageLoader也可以用于加载网络上的图片，并且它的内部也是使用ImageRequest来实现的，
不过ImageLoader明显要比ImageRequest更加高效，因为它不仅可以帮我们对图片进行缓存，还可以过滤掉重复的链接，避免重复发送请求。
由于ImageLoader已经不是继承自Request的了，所以它的用法也和我们之前学到的内容有所不同，总结起来大致可以分为以下四步：
1. 创建一个RequestQueue对象。
2. 创建一个ImageLoader对象。
3. 获取一个ImageListener对象。
4. 调用ImageLoader的get()方法加载网络上的图片。
下面我们就来按照这个步骤，学习一下ImageLoader的用法吧。
首先第一步的创建RequestQueue对象我们已经写过很多遍了，相信已经不用再重复介绍了，
那么就从第二步开始学习吧，新建一个ImageLoader对象，
ImageLoader imageLoader = new ImageLoader(mQueue, new ImageCache() {  
    @Override  
    public void putBitmap(String url, Bitmap bitmap) {  
    }  
  
    @Override  
    public Bitmap getBitmap(String url) {  
        return null;  
    }  
});  
可以看到，ImageLoader的构造函数接收两个参数，第一个参数就是RequestQueue对象，
第二个参数是一个ImageCache对象，这里我们先new出一个空的ImageCache的实现即可。
接下来需要获取一个ImageListener对象，
ImageListener listener = ImageLoader.getImageListener(imageView, R.drawable.default_image, R.drawable.failed_image);  
我们通过调用ImageLoader的getImageListener()方法能够获取到一个ImageListener对象，
getImageListener()方法接收三个参数，第一个参数指定用于显示图片的ImageView控件，
第二个参数指定加载图片的过程中显示的图片，第三个参数指定加载图片失败的情况下显示的图片。
最后，调用ImageLoader的get()方法来加载图片
get()方法接收两个参数，第一个参数就是图片的URL地址，第二个参数则是刚刚获取到的ImageListener对象。
当然，如果你想对图片的大小进行限制，也可以使用get()方法的重载，指定图片允许的最大宽度和高度，
imageLoader.get("https://img-my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",  
                listener, 200, 200);  

虽然现在我们已经掌握了ImageLoader的用法，但是刚才介绍的ImageLoader的优点却还没有使用到。
为什么呢？因为这里创建的ImageCache对象是一个空的实现，完全没能起到图片缓存的作用。
其实写一个ImageCache也非常简单，但是如果想要写一个性能非常好的ImageCache，最好就要借助Android提供的LruCache功能了，
这里我们新建一个BitmapCache并实现了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();  
            }  
        };  
    }   
    public Bitmap getBitmap(String url) {  
        return mCache.get(url);  
    }  
    public void putBitmap(String url, Bitmap bitmap) {  
        mCache.put(url, bitmap);  
    }  
}  
可以看到，这里我们将缓存图片的大小设置为10M。接着修改创建ImageLoader实例的代码，第二个参数传入BitmapCache的实例，
ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache());  
===========================================例子=================================================
public class VolleyImgActivity extends AppCompatActivity {
    private RequestQueue requestQueue;
    private ImageView image;
    private NetworkImageView networkImageView;


    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_volley_img);


//        image = (ImageView) findViewById(R.id.img);


        //给networkimageview设置图片
        networkImageView = (NetworkImageView) findViewById(R.id.network_img);
        ImageLoader imageLoader = new ImageLoader(MyApplication.getRequestQueue(),new MyImageCache());
        //设置默认的图片
        networkImageView.setDefaultImageResId(R.mipmap.ic_launcher);
        //设置错误的图片
        networkImageView.setErrorImageResId(R.mipmap.ic_launcher);
        /*  String url, 图片的地址
        ImageLoader imageLoader  */
        networkImageView.setImageUrl("http://e.hiphotos.baidu.com/image/pic/item/14ce36d3d539b600be63e95eed50352ac75cb7ae.jpg",imageLoader);
        -----------------------------------------------
其中，setImageUrl()方法接收两个参数，第一个参数用于指定图片的URL地址，第二个参数则是前面创建好的ImageLoader对象。
好了，就是这么简单，现在重新运行一下程序，你将看到和使用ImageLoader来加载图片一模一样的效果，这里我就不再截图了。
这时有的朋友可能就会问了，使用ImageRequest和ImageLoader这两种方式来加载网络图片，
都可以传入一个最大宽度和高度的参数来对图片进行压缩，而NetworkImageView中则完全没有提供设置最大宽度和高度的方法，
那么是不是使用NetworkImageView来加载的图片都不会进行压缩呢？
其实并不是这样的，NetworkImageView并不需要提供任何设置最大宽高的方法也能够对加载的图片进行压缩。
这是由于NetworkImageView是一个控件，在加载图片的时候它会自动获取自身的宽高，然后对比网络图片的宽度，
再决定是否需要对图片进行压缩。也就是说，压缩过程是在内部完全自动化的，并不需要我们关心，
NetworkImageView会始终呈现给我们一张大小刚刚好的网络图片，不会多占用任何一点内存，这也是NetworkImageView最简单好用的一点吧。
当然了，如果你不想对图片进行压缩的话，其实也很简单，只需要在布局文件中把NetworkImageView的layout_width和
layout_height都设置成wrap_content就可以了，这样NetworkImageView就会将该图片的原始大小展示出来，不会进行任何压缩。

----------------------------------------------
//通过imageLoader加载图片
       // getImaFromImageLoader();
        //通过iamgeRequest请求网络图片
       // getImgFromImageRequest();
    }
    private void getImaFromImageLoader() {
       /* //1.声名imageloader
            //2. 设置监听
           //3.请求
        */
        /*声名一个imageloader
        * 参数1:请求队列
        * 参数2:  缓存的实现接口
        * */
        ImageLoader imageLoader = new ImageLoader(MyApplication.getRequestQueue(),new MyImageCache());
       /*声名image图片的请求监听
        android.widget.ImageView view,  需要放置网络图片的控件
        int defaultImageResId,   默认的图片
        int errorImageResId      请求错误的图片*/
        ImageLoader.ImageListener imageListener = imageLoader.getImageListener(image, R.mipmap.ic_launcher, R.mipmap.ic_launcher);
        //通过imageloader请求图片
        imageLoader.get("http://e.hiphotos.baidu.com/image/pic/item/14ce36d3d539b600be63e95eed50352ac75cb7ae.jpg",
                imageListener);
    }
    private void getImgFromImageRequest() {
        requestQueue = MyApplication.getRequestQueue();
   /*     String url,  图片的网络地址
        Response.Listener<Bitmap> listener,  请求成功的监听器
        int maxWidth,  图片的最大宽度
        int maxHeight,  图片的最大高度 ,  请求完图片会自动的限制在该范围中,  0,0 表示图片不进行处理
        android.widget.ImageView.ScaleType scaleType,  图片的缩放类型
        Bitmap.Config decodeConfig,   图片的每个点需要多少字节来存储
        Response.ErrorListener errorListener  错误,异常的回调*/
       /* Bitmap.Config.ARGB_4444    00000000   每一个值用4位来表示   总共占据2字节
       * Bitmap.Config.ARGB_8888      每一个值用8位来表示,  总共占据4个字节
       * Bitmap.Config.RGB_565      R 用5位来表示   G-6  B-5   总共占据2字节
       * */
        ImageRequest imageRequest = new ImageRequest("http://e.hiphotos.baidu.com/image/pic/item/14ce36d3d539b600be63e95eed50352ac75cb7ae.jpg"
                , new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
                image.setImageBitmap(response);
            }
        }, 0, 0, ImageView.ScaleType.CENTER_CROP, Bitmap.Config.RGB_565, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
            }
        });
        imageRequest.setTag("quxiao");
        //放入请求队列
        requestQueue.add(imageRequest);
    }
    protected void onDestroy() {
        super.onDestroy();
        requestQueue.cancelAll("quxiao");
    }
    class  MyImageCache implements ImageLoader.ImageCache{
        LruCache<String, Bitmap> lruCache;
        /*初始化Lrucache的大小*/
        public MyImageCache(){
            lruCache = new LruCache<String, Bitmap>((int) (Runtime.getRuntime().maxMemory() / 6)) {
                protected int sizeOf(String key, Bitmap value) {
                    return value.getRowBytes() * value.getHeight();
                }
            };
        }
        /*从缓存中获取bitmap*/
        public Bitmap getBitmap(String url) {
            return lruCache.get(url);
        }
        /*将bitmap放入到缓存中*/
        public void putBitmap(String url, Bitmap bitmap) {
            lruCache.put(url,bitmap);
        }
    }
}