Android之Volley使用

Volley使用demo：

public class MainActivity extends Activity {

     private RequestQueue mQueue;

     private TextView tv;
     private ImageView iv;
     private Button sr,btn2,btn3,btn4,btn5,btn6,btn7;

     private NetworkImageView netImageView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mQueue=Volley.newRequestQueue(getApplicationContext());

        initView();


    }



    private void initView() {
        // TODO Auto-generated method stub
        tv=(TextView) findViewById(R.id.tv_1);
        iv=(ImageView) findViewById(R.id.iv_1);

        sr=(Button) findViewById(R.id.btn_1);
        sr.setOnClickListener(new Listener());

        btn2=(Button) findViewById(R.id.btn_2);
        btn2.setOnClickListener(new Listener());

        btn3=(Button) findViewById(R.id.btn_3);
        btn3.setOnClickListener(new Listener());

        btn4=(Button) findViewById(R.id.btn_4);
        btn4.setOnClickListener(new Listener());

        btn5=(Button) findViewById(R.id.btn_5);
        btn5.setOnClickListener(new Listener());

        btn6=(Button) findViewById(R.id.btn_6);
        btn6.setOnClickListener(new Listener());

        btn7=(Button) findViewById(R.id.btn_7);
        btn7.setOnClickListener(new Listener());

        netImageView=(NetworkImageView) findViewById(R.id.network_imageView);
    }


    class Listener implements OnClickListener{

        @Override
        public void onClick(View v) {
            switch(v.getId()){

            case R.id.btn_1:

                loadGetStr("http://www.baidu.com");
                break;

            case R.id.btn_2:
                loadPostStr("");
                break;
            case R.id.btn_3:
                loadGetJson("http://www.imooc.com/api/teacher?type=4&num=30");
                break;
            case R.id.btn_4:
                networkImageViewUse(netImageView, "http://img.taopic.com/uploads/allimg/120331/2722-12033109302882.jpg");
                break;
            case R.id.btn_5:
                loadeXMLRequest("http://flash.weather.com.cn/wmaps/xml/china.xml");
                break;
            case R.id.btn_6:
                loadJsonResponse("http://www.weather.com.cn/data/sk/101010100.html");           
                break;
            case R.id.btn_7:
                getImageLoader(iv, "http://img.taopic.com/uploads/allimg/120331/2722-12033109302882.jpg");          
                break;
            }


        }}

    //返回String 网络请求Get方法
    private void loadGetStr(String url){
        StringRequest stringRequest=new StringRequest(url, new Response.Listener<String>() {

            @Override
            public void onResponse(String response) {
                 Log.d("TAG", response);  
                 tv.setText(response);

            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                // TODO Auto-generated method stub
                Log.d("TAG",error.getMessage());
                tv.setText(error.getMessage());
            }
        } );
        //设置是否缓存    失败了，不明白为啥
        stringRequest.setShouldCache(true); 
        mQueue.add(stringRequest);
        mQueue.start();

    }
    //返回string，网络请求Post
    private void loadPostStr(String url){
        StringRequest stringRequest = new StringRequest(Method.POST, url,  new Response.Listener<String>() {

            @Override
            public void onResponse(String response) {
                // TODO Auto-generated method stub

            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                // TODO Auto-generated method stub

            }
        }) {  
            @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;  
            }  
        };  

    }
    //返回json  网络get请求
    private void loadGetJson(String url){
        JsonObjectRequest jr=new JsonObjectRequest(url,null, new Response.Listener<JSONObject>() {

            @Override
            public void onResponse(JSONObject response) {
                 tv.setText(response.toString());

            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                // TODO Auto-generated method stub
                tv.setText(error.getMessage());
            }
        });
        mQueue.add(jr);
        mQueue.start();
    }


    //newwork控件 请求图片
    @SuppressWarnings("unused")
    private void networkImageViewUse(NetworkImageView iv, String url) {  
        ImageLoader imLoader = new ImageLoader(mQueue, new BitmapCache());  
        //请求图片之前显示的图片
        iv.setDefaultImageResId(R.drawable.ic_launcher);
       // 请求图片失败显示的图片
        iv.setErrorImageResId(R.drawable.ic_launcher);  
        iv.setImageUrl(url, imLoader);  
    }  
    //图片一级缓存处理
    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);  
        }  

    }  
    // XML 
    private void loadeXMLRequest(String url){
        XMLRequest xmlRequest=new XMLRequest(url, new Response.Listener<XmlPullParser>() {

            @Override
            public void onResponse(XmlPullParser response) {
                // TODO Auto-generated method stub
                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.d("TAG", "pName is " + pName); 
                                tv.setText(pName);
                            }  
                            break;  
                        }  
                        eventType = response.next();  
                    }  
                } catch (XmlPullParserException e) {  
                    e.printStackTrace();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  

        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                tv.setText(error.getMessage());

            }
        });
        mQueue.add(xmlRequest); 
    }
    //json
    @SuppressWarnings({ "unused", "unchecked" })
    private void loadJsonResponse(String url){
        GsonRequest<Weather> gsonRequest=new GsonRequest(url, Weather.class, new Response.Listener<Weather>() {

            @Override
            public void onResponse(Weather weather) {
                WeatherInfo weatherInfo=weather.getWeatherinfo();
                   Log.d("TAG", "city is " + weatherInfo.getCity());  
                    Log.d("TAG", "temp is " + weatherInfo.getTemp());  
                    Log.d("TAG", "time is " + weatherInfo.getTime());
                    tv.setText(weatherInfo.getCity());

            }
        }, new Response.ErrorListener() {

            @Override
            public void onErrorResponse(VolleyError error) {
                // TODO Auto-generated method stub
                tv.setText(error.getMessage());
            }
        });
        mQueue.add(gsonRequest);
    }


    //ImageLoader 请求图片
    private void getImageLoader(ImageView iv,String url){
        ImageLoader il=new ImageLoader(mQueue, new BitmapCache());

        ImageListener listener = ImageLoader.getImageListener(iv,  
                R.drawable.ic_launcher, R.drawable.ic_launcher); 
        il.get(url, listener, 200, 200);
    }
}

GsonRequest集成：

import java.io.UnsupportedEncodingException;

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;
import com.google.gson.Gson;

public class GsonRequest<T> extends Request<T> {  

    private final Listener<T> mListener;  

    private Gson mGson;  

    private Class<T> mClass;  

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

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

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

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

}  

XMLRequest 集成：

import java.io.StringReader;
import java.io.UnsupportedEncodingException;

import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlPullParserFactory;

import com.android.volley.NetworkResponse;
import com.android.volley.ParseError;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.Response.ErrorListener;
import com.android.volley.Response.Listener;
import com.android.volley.toolbox.HttpHeaderParser;

public class XMLRequest extends Request<XmlPullParser> {  

    private final Listener<XmlPullParser> mListener;  

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

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

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

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

}  

public class Weather {

     private WeatherInfo weatherinfo;

     public WeatherInfo getWeatherinfo() {
        return weatherinfo;
    }

    public void setWeatherinfo(WeatherInfo weatherinfo) {
        this.weatherinfo = weatherinfo;
    }

     class WeatherInfo { 

    private String city;  

        private String temp;  

        private String time;

        public String getCity() {
            return city;
        }

        public void setCity(String city) {
            this.city = city;
        }

        public String getTemp() {
            return temp;
        }

        public void setTemp(String temp) {
            this.temp = temp;
        }

        public String getTime() {
            return time;
        }

        public void setTime(String time) {
            this.time = time;
        }  

    } 
}

VolleyErrorHelper 集成

import java.util.HashMap;  
import java.util.Map;  


import android.content.Context;  


import com.android.volley.AuthFailureError;  
import com.android.volley.NetworkError;  
import com.android.volley.NetworkResponse;  
import com.android.volley.NoConnectionError;  
import com.android.volley.ServerError;  
import com.android.volley.TimeoutError;  
import com.android.volley.VolleyError;  
import com.csun.sos.R;
import com.google.gson.Gson;  
import com.google.gson.reflect.TypeToken;  


public class VolleyErrorHelper {  

    /** 
     * Returns appropriate message which is to be displayed to the user against 
     * the specified error object. 
     *  
     * @param error 
     * @param context 
     * @return 
     */  
    public static String getMessage(Object error, Context context) {  
        if (error instanceof TimeoutError) {  
            return context.getResources().getString(  
                    R.string.generic_server_down);  
        } else if (isServerProblem(error)) {  
            return handleServerError(error, context);  
        } else if (isNetworkProblem(error)) {  
            return context.getResources().getString(R.string.no_internet);  
        }  
        return context.getResources().getString(R.string.generic_error);  
    }  

    /** 
     * Determines whether the error is related to network 
     *  
     * @param error 
     * @return 
     */  
    private static boolean isNetworkProblem(Object error) {  
        return (error instanceof NetworkError)  
                || (error instanceof NoConnectionError);  
    }  

    /** 
     * Determines whether the error is related to server 
     *  
     * @param error 
     * @return 
     */  
    private static boolean isServerProblem(Object error) {  
        return (error instanceof ServerError)  
                || (error instanceof AuthFailureError);  
    }  

    /** 
     * Handles the server error, tries to determine whether to show a stock 
     * message or to show a message retrieved from the server. 
     *  
     * @param err 
     * @param context 
     * @return 
     */  
    private static String handleServerError(Object err, Context context) {  
        VolleyError error = (VolleyError) err;  

        NetworkResponse response = error.networkResponse;  

        if (response != null) {  
            switch (response.statusCode) {  
            case 404:  
            case 422:  
            case 401:  
                try {  
                    // server might return error like this { "error":  
                    // "Some error occured" }  
                    // Use "Gson" to parse the result  
                    HashMap<String, String> result = new Gson().fromJson(  
                            new String(response.data),  
                            new TypeToken<Map<String, String>>() {  
                            }.getType());  

                    if (result != null && result.containsKey("error")) {  
                        return result.get("error");  
                    }  

                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
                // invalid request  
                return error.getMessage();  

            default:  
                return context.getResources().getString(  
                        R.string.generic_server_down);  
            }  
        }  
        return context.getResources().getString(R.string.generic_error);  
    }  
} 

Volley，Gson库