RequestQueue mQueue = Volley.newRequestQueue(this);

 StringRequest stringRequest=new StringRequest("http://www.wensibo.top"
         , new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                //正常情况下的逻辑处理
                String result="";
                try {
                     result= new String(response.getBytes("ISO_8859_1"), "utf-8");
                    //由于访问string的时候可能会出现乱码情况，所以保险起见，可以将其转换为utf-8格式
                    //对于其他的自定义Requet都是同理的，均需要在重写parseNetworkResponse方法时设置编码格式，避免乱码的出现
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                Intent intent = new Intent();
                intent.setClass(MainActivity.this, StringRequestActivity.class);
                intent.putExtra("string_request", result);
                startActivity(intent);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                //出错的时候做的一些处理
                Intent intent = new Intent();
                intent.setClass(MainActivity.this, StringRequestActivity.class);
                intent.putExtra("string_request", getResources().getString(R.string.error_message));
                startActivity(intent);
            }
        }
        );

mQueue.add(stringRequest);

RequestQueue mQueue = Volley.newRequestQueue(this);

JsonObjectRequest jsonObjectRequest=new JsonObjectRequest("http://www.weather.com.cn/data/cityinfo/101010100.html"
                , new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                Log.d("JsonObject", response.toString());
                Intent intent = new Intent();
                intent.setClass(MainActivity.this, JsonRequestActivity.class);
                intent.putExtra("json_request", response.toString());
                startActivity(intent);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("TAG", error.getMessage(), error);
                Intent intent = new Intent();
                intent.setClass(MainActivity.this, JsonRequestActivity.class);
                intent.putExtra("json_request", getResources().getString(R.string.error_message));
                startActivity(intent);
            }
        });

mQueue.add(jsonObjectRequest);

RequestQueue mQueue = Volley.newRequestQueue(this);

ImageRequest imageRequest=new ImageRequest("http://wensibo.top/img/avatar.jpg"
                , new Response.Listener<Bitmap>() {
            @Override
            public void onResponse(Bitmap response) {
                Log.d("SUCCESS", "成功返回ImageRequest");
                iv_image_request.setImageBitmap(response);
            }
        }, 0, 0, Bitmap.Config.RGB_565, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.d("ERROR", "返回ImageRequest失败");
                iv_image_request.setImageResource(R.drawable.failed_image);
            }
        }
        );

mQueue.add(jsonObjectRequest);

RequestQueue mQueue = Volley.newRequestQueue(this);

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(iv_image_loader, R.drawable.failed_image, R.drawable.failed_image);

imageLoader.get("http://wensibo.top/img/avatar.jpg", listener);

imageLoader.get("http://wensibo.top/img/avatar.jpg", listener,200,200);

public class BitmapCache implements ImageCache{

    private LruCache<String, Bitmap> mCache;

    public BitmapCache() {
        //将缓存图片的大小设置为8M
        int maxSize = 8 * 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());

public class StringRequest extends Request<String>{
    private final Response.Listener<String> mListener;

    /** 根据给定的METHOD设置对应的request. */
    public StringRequest(int method, String url, Response.Listener<String> listener,
                         Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

    /** 默认为GET请求的request. */
    public StringRequest(String url, Response.Listener<String> listener,
                         Response.ErrorListener errorListener) {
        this(Method.GET, url, listener, errorListener);
    }

    /** 将HTTP请求结果转换为String. */
    @Override
    protected Response<String> parseNetworkResponse(NetworkResponse response) {
        String parsed;

        try {
            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
        } catch (UnsupportedEncodingException e) {
            parsed = new String(response.data);
        }
        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
    }

    /** 将解析的String结果传递给用户的回调接口. */
    @Override
    protected void deliverResponse(String response) {
        mListener.onResponse(response);
    }
}

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 Response<XmlPullParser> parseNetworkResponse(NetworkResponse response) {
        try {
            response.headers.put("HTTP.CONTENT_TYPE", "utf-8");
            String xmlString = new String(response.data,"utf-8");
            //加上这两行可以解决乱码的问题，尤其是对于中文的xml接口，由于每个xml的编码格式不同，所以获取原编码格式之后再转换为utf-8，即可。
            XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
            XmlPullParser xmlPullParser = factory.newPullParser();
            xmlPullParser.setInput(new StringReader(xmlString));
            Log.d("SUCCESS", "xmlString的内容为" + 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);
    }

}

 XMLRequest xmlRequest = new XMLRequest(
                "http://flash.weather.com.cn/wmaps/xml/guangdong.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(2);
                                            Log.d("CITY", "PName is" + pname);
                                            citys.add(pname);
                                        }
                                        break;
                                }
                                eventType = response.next();
                            }

                            ArrayAdapter<String> arrayAdapter = new ArrayAdapter<String>(XMLRequestActivity.this, android.R.layout.simple_list_item_1, citys);
                            lv_xml_request.setAdapter(arrayAdapter);
                        } catch (XmlPullParserException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                },
                new Response.ErrorListener() {
                    @Override
                    public void onErrorResponse(VolleyError error) {
                        lv_xml_request.setVisibility(View.GONE);
                        mTextView.setVisibility(View.VISIBLE);
                        Log.d("ERROR", "返回XMLRequest失败");
                    }
                }
        );
        mQueue.add(xmlRequest);
    }

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

    private final Response.Listener<T> mListener;
    private Gson mGson;
    private Class<T> mClazz;

    public GsonRequest(int method, String url, Class<T> clazz, Response.Listener<T> listener, Response.ErrorListener errorListener) {
        super(method, url, errorListener);
        mGson = new Gson();
        mClazz = 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 Response<T> parseNetworkResponse(NetworkResponse response) {
        try {
            response.headers.put("HTTP.CONTENT_TYPE", "utf-8");
            String jsonString = new String(response.data,"utf-8");
            //加上这两行可以解决乱码的问题，尤其是对于中文的json接口，由于每个网页的编码格式不同，所以获取原编码格式之后再转换为utf-8，即可。
            return Response.success(mGson.fromJson(jsonString, mClazz),
                    HttpHeaderParser.parseCacheHeaders(response)
            );
        } catch (UnsupportedEncodingException e) {
            return Response.error(new ParseError(e));
        }
    }

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

public 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;
    }
}

public class Weather {
    //此处的weatherinfo不可以修改为weatherInfo，因为从json获取的数据格式为
    // {"weatherinfo":{"city":"北京","cityid":"101010100","temp":"19","WD":"南风","WS":"2级","SD":"43%","WSE":"2","time":"19:45","isRadar":"1","Radar":"JC_RADAR_AZ9010_JB"}}
    private WeatherInfo weatherinfo;

    public WeatherInfo getWeatherInfo() {
        return weatherinfo;
    }

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

GsonRequest<Weather> gsonRequest=new GsonRequest<Weather>("http://www.weather.com.cn/data/sk/101010100.html"
                , Weather.class,
                new Response.Listener<Weather>() {
                    @Override
                    public void onResponse(Weather weather) {
                        WeatherInfo weatherInfo = weather.getWeatherInfo();
                        if (weatherInfo != null) {
                            StringBuffer str = new StringBuffer();
                            str.append("城市：" + weatherInfo.getCity() + "\n");
                            str.append("温度：" + weatherInfo.getTemp() + "\n");
                            str.append("时间：" + weatherInfo.gettime());
                            tv_gson_request.setText(str);
                            Log.d("SUCCESS", "成功返回GsonRequest  " + str.toString());
                        } else {
                            Log.d("ERROR", "weatherinfo对象为空");
                        }
                    }
                }
                , new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.d("ERROR", "返回GsonRequest失败");
                tv_gson_request.setText(getResources().getString(R.string.error_message));
            }
        }
        );

mQueue.add(gsonRequest);