Volley的一些应用

CustomXMLRequest

//配置同上
//第一步，仿照官方Volley框架，自己写一个类
public class XMLRequest extends Request<XmlPullParser> {

    private final Response.Listener<XmlPullParser> mListener;

    public XMLRequest(int method, String url, Response.Listener<XmlPullParser> listener,
                      Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    public XMLRequest(String url, Response.Listener<XmlPullParser> listener, Response.ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }

    @Override
    protected void deliverResponse(XmlPullParser response) {
        mListener.onResponse(response);
    }

    @Override
    protected Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
        try {
            String xmlString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser xmlPullParser = factory.newPullParser();
            xmlPullParser.setInput(new StringReader(xmlString));
            return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        } catch (XmlPullParserException e) {
            return Response.error(new ParseError(e));
        }
    }
}
//第二步，获取请求对象
private RequestQueue mQueue = Volley.newRequestQueue(this);
//第三步，建立XMLRequest
XMLRequest xmlRequest = new XMLRequest(
        "http://192.168.191.1/get_data.xml",
        new Response.Listener<XmlPullParser>() {
            @Override
            public void onResponse(XmlPullParser response) {
                try {
                    int eventType = response.getEventType();
                    while (eventType != XmlPullParser.END_DOCUMENT) {
                        switch (eventType) {
                            case XmlPullParser.START_TAG:
                                String nodeName = response.getName();
                                if ("city".equals(nodeName)) {
                                    String pName = response.getAttributeValue(0);
                                    Log.w("TAG", "pName is " + pName);
                                }
                                break;
                        }
                        eventType = response.next();
                    }
                } catch (XmlPullParserException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("TAG","出错了：" + error.getMessage(), error);
            }
        });
//第四步，添加到请求列表
mQueue.add(xmlRequest);

imageRequestHandler

<!--需要布局中有ImageView-->
<ImageView
        android:id="@+id/image_view"
        android:layout_gravity="center_horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>
/**
 * 使用ImageRequest加载图片<br/>
 * 获取imageRequest实例，设置6个参数<br/>
 * 添加到RequestQueue中
 * */
public void imageRequestHandler(View view){
    ImageRequest imageRequest = new ImageRequest(
            "http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",
            new Response.Listener<Bitmap>() {
                @Override
                public void onResponse(Bitmap response) {
                    imageView.setImageBitmap(response);
                }
            }, 0, 0, Bitmap.Config.RGB_565,
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    imageView.setImageResource(R.mipmap.ic_launcher);
                }
            });

    mQueue.add(imageRequest);
}

loadImage

<!--需要布局中有ImageView-->
<ImageView
        android:id="@+id/image_view"
        android:layout_gravity="center_horizontal"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"/>

//第一步，创建缓存类
/**
 * Created by Quhaofeng on 2016-4-13-0013.<br/>
 * 一个图片缓存设置类<br/>
 * 构造方法BitmapCache()对最大缓存进行了设置<br/>
 *
 *
 */
public class BitmapCache implements ImageLoader.ImageCache {

    private LruCache<String, Bitmap> mCache;

    /**
     * 构造方法BitmapCache()对最大缓存进行了设置<br/>
     * */
    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 s) {
        return mCache.get(s);
    }

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

//第二步，调用
/**
 * 使用loadImage加载图片<br/>
 * 创建ImageLoader对象，new 一个实例，传入RequestQueue对象和ImageCache对象<br/>
 * 创建监听ImageLoader.ImageListener,并获取ImageLoader的监听，参数为imageview，默认图，错误图</br>
 * 最后使用imageloader.get(url，listener) ，传入网络地址和监听器
 * */
public void loadImage(View view){
    ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache());//使用了缓存

    ImageLoader.ImageListener listener = ImageLoader.getImageListener(imageView,
            R.drawable.ic_aspect_ratio_black_48dp, R.drawable.ic_mood_bad_black_24dp);

    imageLoader.get("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg", listener);
}

NetworkImageView

<!--需要布局中有NetworkImageView控件-->
<com.android.volley.toolbox.NetworkImageView
        android:id="@+id/network_image_view"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:layout_gravity="center_horizontal"/>


//第一步，创建图片缓存类
/**
 * Created by Quhaofeng on 2016-4-13-0013.<br/>
 * 一个图片缓存设置类<br/>
 * 构造方法BitmapCache()对最大缓存进行了设置<br/>
 *
 *
 */
public class BitmapCache implements ImageLoader.ImageCache {

    private LruCache<String, Bitmap> mCache;

    /**
     * 构造方法BitmapCache()对最大缓存进行了设置<br/>
     * */
    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 s) {
        return mCache.get(s);
    }

    @Override
    public void putBitmap(String s, Bitmap bitmap) {
        mCache.put(s, bitmap);
    }
}
//第二步，调用
/**
 * 使用NetworkImageView自定义控件<br/>
 * 创建imageloader对象，new 时 传入RequestQueue对象和imageCache对象<br/>
 * 通过控件的set，设置默认图片和错误图片<br/>
 * 通过set设置图片url和imageloader
 * */
public void loadNetworkImage(View view){

    ImageLoader imageLoader = new ImageLoader(mQueue, new BitmapCache());
    networkImageView.setDefaultImageResId(R.drawable.ic_aspect_ratio_black_48dp);
    networkImageView.setErrorImageResId(R.drawable.ic_mood_bad_black_24dp);
    networkImageView.setImageUrl("http://img.my.csdn.net/uploads/201404/13/1397393290_5765.jpeg",
            imageLoader);
}

VolleyJsonArrayRequest

//配置：在libs文件夹中有Volley.jar包，并完成了库引用
private List<Data> mDataArrayList = new ArrayList<Data>();
//第一步，获取请求对象
private RequestQueue mQueue = Volley.newRequestQueue(this);
//第二步，设置返Json数组的请求或其他请求
//"http://192.168.191.1/get_data.json"这个参数是自己建的服务器，服务返回的是json数组
JsonArrayRequest jsonArrayRequest = new JsonArrayRequest("http://192.168.191.1/get_data.json",
        new Response.Listener<JSONArray>() {
            @Override
            public void onResponse(JSONArray jsonArray) {//返回参数Json数组
                try {
                    for (int i = 0; i < jsonArray.length(); i++) {
                        JSONObject jsonObject = jsonArray.getJSONObject(i);
                        
                        //Data是一个数据模型类，对应于Json数组的每个元素
                        Data data = new Data();
                        data.setId(jsonObject.getInt("id"));
                        data.setVersion(jsonObject.getDouble("version"));
                        data.setName(jsonObject.getString("name"));
                        //Log.w("TestTag",data.getName() + data.getId() + data.getVersion());
                        //Log.w("TestTag", data.toString());
                        mDataArrayList.add(data);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                Log.w("TestTag", mDataArrayList.toString());
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {

            }
        });
//第三步，将发送请求添加到请求对象
mQueue.add(jsonArrayRequest);

VolleyJsonObjectRequest

//配置：在libs文件夹中有Volley.jar包，并完成了库引用

//第一步，获取请求对象
private RequestQueue mQueue = Volley.newRequestQueue(this);
//第二步，设置返回Json对象的请求或其他请求
//"http://192.168.191.1/get_data.json"这个参数是自己建的服务器，服务返回的是json数组或对象
JsonObjectRequest jsonObjectRequest = new JsonObjectRequest("http://192.168.191.1/get_data.json", null,
        new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject jsonObject) {//返回的是json对象
                Log.w("MyTag", jsonObject.toString());
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError volleyError) {//出错
                Log.w("MyTag", volleyError.getMessage(), volleyError);
            }
        });
//第三步，将发送请求添加到请求对象
mQueue.add(jsonObjectRequest);

VolleyStringRequest

//配置：在libs文件夹中有Volley.jar包，并完成了库引用

//第一步，获取请求对象
private RequestQueue mQueue = Volley.newRequestQueue(this);
//第二步，设置返回字符串的请求或其他请求
StringRequest stringRequest = new StringRequest("http://www.baidu.com",
        new Response.Listener<String>() {
            @Override
            public void onResponse(String s) {//返回的数据
                Log.w("TAG", s);
            }
        },
        new Response.ErrorListener() {//返回出错时
            @Override
            public void onErrorResponse(VolleyError volleyError) {
                Log.w("TAG", volleyError.getMessage(), volleyError);
            }
        });
//第三步，将发送请求添加到请求对象
mQueue.add(stringRequest);

VolleyWithGson

//配置，libs中不仅要有Volley.jar还要有Gson.jar两个第三方库

//第一步，自定义一个处理Gson的类
public class GsonRequest<T> extends Request<T>{

    private final Response.Listener<T> mListener;

    private Gson mGson;

    private Class<T> mClass;

    public GsonRequest(int method, String url, Class<T> clazz, Response.Listener<T> listener,
                       Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        mGson = new Gson();
        mClass = clazz;
        mListener = listener;
    }

    public GsonRequest(String url, Class<T> clazz, Response.Listener<T> listener,
                       Response.ErrorListener errorListener) {
        this(Method.GET, url, clazz, listener, errorListener);
    }

    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }

    @Override
    protected Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            String jsonString = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            return Response.success(mGson.fromJson(jsonString, mClass),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        }
    }
}



//第二步，获取请求对象
private RequestQueue mQueue = Volley.newRequestQueue(this);
//第三步，建立请求
//只能对jsonObject进行这样的解析，不适用于jsonArray
GsonRequest<Data> gsonRequest = new GsonRequest<Data>("http://192.168.191.1/get_data.json", Data.class,
        new Response.Listener<Data>() {
            @Override
            public void onResponse(Data data) {//Data同样是数据模型类
                Log.w("TAG", data.toString());
            }
        },
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("TAG", error.getMessage(), error);
            }
        });
//第四步，添加到请求列表
mQueue.add(gsonRequest);

Volley的一些应用，之后可以直接拷来用