Volley===Volley框架的基本使用方法

现在开发app,可以说离不开网络操作，今天给大家介绍一下Android网络框架volley的使用方法。

volley简介

Volley主页 https://android.googlesource.com/platform/frameworks/volley 
Github地址 https://github.com/mcxiaoke/android-volley

Volley:2013年Google I/O大会上推出的一个新的Android网络通信框架,能使网络通信更快，更简单，更健壮。

功能: 
Json,图像等的异步下载 
网络请求的排序(scheduling) 
网络请求的优先级处理 
缓存 
多级别取消请求 
和Activity生命周期联动(Activity结束时同时取消所有请求)

使用volley: 
compile 'com.mcxiaoke.volley:library:1.0.19'

基本使用方法

StringRequest使用方法: 

演示:通过StringRequest发送一个get请求

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void getStringRequest() {  
  2.             String url="http://api.k780.com:88/?app=phone.get&phone=13800138000&appkey=10003&sign=b59bc3ef6191eb9f747dd4e83c99f2a4&format=json";  
  3.             RequestQueue queue= Volley.newRequestQueue(this);  
  4.             StringRequest request=new StringRequest(url, new Response.Listener<String>() {  
  5.                 @Override  
  6.                 public void onResponse(String s) {  
  7.                     Log.e("success",s);  
  8.                 }  
  9.             }, new Response.ErrorListener() {  
  10.                 @Override  
  11.                 public void onErrorResponse(VolleyError volleyError) {  
  12.   
  13.                 }  
  14.             });  
  15.             queue.add(request);  
  16.         }  
演示:通过StringRequest发送一个post请求
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void postStringRequest() {  
  2.        String url="http://api.k780.com:88/?app=phone.get";  
  3.        RequestQueue queue=Volley.newRequestQueue(this);  
  4.        StringRequest request=new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {  
  5.            @Override  
  6.            public void onResponse(String s) {  
  7.                Log.e("sucess",s);  
  8.            }  
  9.        }, new Response.ErrorListener() {  
  10.            @Override  
  11.            public void onErrorResponse(VolleyError volleyError) {  
  12.   
  13.            }  
  14.        }){  
  15.            @Override  
  16.            protected Map<String, String> getParams() throws AuthFailureError {  
  17.                Map<String,String> map=new HashMap<>();  
  18.                map.put("phone","13800138000");  
  19.                map.put("appkey", "10003");  
  20.                map.put("sign", "b59bc3ef6191eb9f747dd4e83c99f2a4");  
  21.                map.put("format", "json");  
  22.                map.put("idcard", "110101199001011114");  
  23.                return map;  
  24.            }  
  25.        };  
  26.        queue.add(request);  
  27.    }  

通过上述代码，我们可以总结出，StringRequest可以发送get和post请求，但是服务器返回的数据以String类型进行接收。 
通过StringRequest发送请求一般需要以下三步： 
1.创建一个请求队列RequestQueue 
2.创建StringRequest对象 
3.将请求对象添加到请求队列中

JsonRequest使用方法: 
演示:通过JsonRequest发送一个get请求

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void getJsonRequest() {  
  2.             String url="http://api.k780.com:88/?app=phone.get&phone=13800138000&appkey=10003&sign=b59bc3ef6191eb9f747dd4e83c99f2a4&format=json";  
  3.             RequestQueue queue= Volley.newRequestQueue(this);  
  4.             JsonObjectRequest request=new JsonObjectRequest(url, new Response.Listener<JSONObject>() {  
  5.                 @Override  
  6.                 public void onResponse(JSONObject jsonObject) {  
  7.                     Log.e("success",jsonObject.toString());  
  8.                 }  
  9.             }, new Response.ErrorListener() {  
  10.                 @Override  
  11.                 public void onErrorResponse(VolleyError volleyError) {  
  12.   
  13.                 }  
  14.             });  
  15.             queue.add(request);  
  16.         }  

演示:通过JsonRequest发送一个post请求
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void postJsonRequest() {  
  2.             String url="http://api.k780.com:88/?app=phone.get";  
  3.             RequestQueue queue=Volley.newRequestQueue(this);  
  4.             JsonObjectRequest request=new JsonObjectRequest(Request.Method.POST, url, new Response.Listener<JSONObject>() {  
  5.                 @Override  
  6.                 public void onResponse(JSONObject jsonObject) {  
  7.                     Log.e("success",jsonObject.toString());  
  8.                 }  
  9.             }, new Response.ErrorListener() {  
  10.                 @Override  
  11.                 public void onErrorResponse(VolleyError volleyError) {  
  12.   
  13.                 }  
  14.             }){  
  15.                 @Override  
  16.                 protected Map<String, String> getParams() throws AuthFailureError {  
  17.                     Map<String,String> map=new HashMap<>();  
  18.                     map.put("phone","13800138000");  
  19.                     map.put("appkey", "10003");  
  20.                     map.put("sign", "b59bc3ef6191eb9f747dd4e83c99f2a4");  
  21.                     map.put("format", "json");  
  22.                     map.put("idcard", "110101199001011114");  
  23.                     return map;  
  24.                 }  
  25.             };  
  26.             queue.add(request);  
  27.         }  

通过以上分析，可以发现，StringRequest和JsonObjectRequest用法基本一样，只是接收的数据类型不一样。 
同理，JsonArrayRequest方法和上面的用法也差不多，这里不做过多介绍。

封装Volley: 
具体实现功能如下: 
发送get请求 
发送post请求 
加载网络图片 
上传图片

Volley管理的类:

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 管理类  
  3.  * @author Yan  
  4.  */  
  5. public class MyVolley {  
  6.     private static final String TAG="MyVolley";  
  7.     private static MyVolley instance;  
  8.     //请求队列  
  9.     private static RequestQueue mRequestQueue;  
  10.     //创建ImageLoader  
  11.     private static ImageLoader mImageLoader;  
  12.     //默认分配最大空间的几分之几  
  13.     private final static int RATE=8;  
  14.   
  15.     public MyVolley(Context context){  
  16.         //初始化请求队列(默认创建5个线程)  
  17.         mRequestQueue=Volley.newRequestQueue(context);  
  18.         //获取ActivityManager管理者  
  19.         ActivityManager manager=(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
  20.         int maxSize=manager.getMemoryClass()/RATE;  
  21.         //初始化ImageLoader对象  
  22.         mImageLoader=new ImageLoader(mRequestQueue, new BitmapLruCache(1024*1024*maxSize));  
  23.         Log.e(TAG, "MyVolley初始化完成");  
  24.     }  
  25.   
  26.     /**  
  27.      * Volley的初始化操作，使用volley前必须调用此方法  
  28.      */  
  29.     public static void init(Context context){  
  30.         if(instance==null){  
  31.             instance=new MyVolley(context);  
  32.         }  
  33.     }  
  34.   
  35.     /**  
  36.      * 获取消息队列  
  37.      */  
  38.     public static RequestQueue getRequestQueue(){  
  39.         throwIfNotInit();  
  40.         return mRequestQueue;  
  41.     }  
  42.   
  43.     /**  
  44.      * 获取ImageLoader  
  45.      */  
  46.     public static ImageLoader getImageLoader(){  
  47.         throwIfNotInit();  
  48.         return mImageLoader;  
  49.     }  
  50.   
  51.     /**  
  52.      * 加入请求队列  
  53.      */  
  54.     public static void addRequest(Request<?> request){  
  55.         getRequestQueue().add(request);  
  56.     }  
  57.   
  58.     /**  
  59.      * 加载网络图片  
  60.      */  
  61.     public static void getImage(String requestUrl, ImageView imageView) {  
  62.         getImage(requestUrl, imageView, 0, 0);  
  63.     }  
  64.   
  65.     /**  
  66.      * 加载网络图片  
  67.      *   
  68.      */  
  69.     public static void getImage(String requestUrl, ImageView imageView,  
  70.             int defaultImageResId, int errorImageResId) {  
  71.         getImage(requestUrl, imageView, defaultImageResId, errorImageResId, 0,  
  72.                 0);  
  73.     }  
  74.   
  75.     /**  
  76.      * 加载网络图片  
  77.      *   
  78.      */  
  79.     public static void getImage(String requestUrl, ImageView imageView,  
  80.             int defaultImageResId, int errorImageResId, int maxWidth,  
  81.             int maxHeight) {  
  82.         imageView.setTag(requestUrl);  
  83.         try {  
  84.             getImageLoader().get(  
  85.                     requestUrl,  
  86.                     ImageListenerFactory.getImageListener(imageView,  
  87.                             defaultImageResId, errorImageResId), maxWidth,  
  88.                             maxHeight);  
  89.         } catch (Exception e) {  
  90.             e.printStackTrace();  
  91.         }  
  92.     }  
  93.   
  94.     /**  
  95.      * 检查是否完成初始化  
  96.      */  
  97.     private static void throwIfNotInit() {  
  98.         if (instance == null) {  
  99.             throw new IllegalStateException("MyVolley尚未初始化，在使用前应该执行init()");  
  100.         }  
  101.     }  
  102. }  

通过以上代码，主要提供了下面几个方法： 
1.在构造方法中，初始化一个全局的请求队列RequestQueue,初始化了一个ImageLoader。 
2.获取消息队列 
3.获取ImageLoader对象 
4.将请求加入到消息队列中 
5.加载图片 
注意:使用MyVolley时，一定要在应用的全局的Application中进行初始化 
MyVolley.init(getApplicationContext());

加载图片中涉及到的2个缓存类如下:

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 图片缓存类(Lru算法)  
  3.  * @author Yan  
  4.  *  
  5.  */  
  6. public class BitmapLruCache extends LruCache<String, Bitmap> implements ImageCache{  
  7.     private static final String TAG="BitmapLruCache";  
  8.     //图片缓存的软引用  
  9.     private BitmapSoftRefCache softRefCache;  
  10.   
  11.     public BitmapLruCache(int maxSize) {  
  12.         super(maxSize);  
  13.         //初始化BitmapSoftRefCache  
  14.         softRefCache=new BitmapSoftRefCache();  
  15.     }  
  16.   
  17.     @Override  
  18.     protected int sizeOf(String key, Bitmap value) {  
  19.         return value.getRowBytes()*value.getHeight();  
  20.     }  
  21.   
  22.     @Override  
  23.     protected void entryRemoved(boolean evicted, String key, Bitmap oldValue,  
  24.             Bitmap newValue) {  
  25.         if(evicted){  
  26.             //将bitmap添加到软引用的缓存中  
  27.             softRefCache.putBitmap(key, oldValue);  
  28.         }  
  29.   
  30.     }  
  31.   
  32.     /**  
  33.      * 从缓存中获取图片  
  34.      */  
  35.     @Override  
  36.     public Bitmap getBitmap(String url) {  
  37.         Bitmap bitmap=get(url);  
  38.         if(bitmap==null){  
  39.             //从软引用缓存中获取  
  40.             bitmap=softRefCache.getBitmap(url);  
  41.         }  
  42.         return bitmap;  
  43.     }  
  44.   
  45.     /**  
  46.      * 将图片放入到缓存中  
  47.      */  
  48.     @Override  
  49.     public void putBitmap(String url, Bitmap bitmap) {  
  50.         put(url, bitmap);  
  51.     }  
  52. }  

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 图片缓存管理类(软引用)  
  3.  * @author Yan  
  4.  *  
  5.  */  
  6. public class BitmapSoftRefCache implements ImageCache {  
  7.     private static final String TAG="BitmapSoftRefCache";  
  8.     //创建一个集合保存Bitmap  
  9.     private LinkedHashMap<String,SoftReference<Bitmap>> map;  
  10.   
  11.     public BitmapSoftRefCache(){  
  12.         map=new LinkedHashMap<>();  
  13.     }  
  14.   
  15.     /**  
  16.      * 根据图片url从缓存中拿出bitmap  
  17.      */  
  18.     @Override  
  19.     public Bitmap getBitmap(String url) {  
  20.         Bitmap bitmap=null;  
  21.         SoftReference<Bitmap> softRef=map.get(url);  
  22.         if(softRef!=null){  
  23.             bitmap=softRef.get();  
  24.             if(bitmap==null){  
  25.                 //从集合中移除  
  26.                 map.remove(url);  
  27.             }  
  28.         }  
  29.         return null;  
  30.     }  
  31.   
  32.     /**  
  33.      * 把图片放进缓存中  
  34.      */  
  35.     @Override  
  36.     public void putBitmap(String url, Bitmap bitmap) {  
  37.         SoftReference<Bitmap> softRef=new SoftReference<Bitmap>(bitmap);  
  38.         map.put(url, softRef);  
  39.     }  
  40.   
  41. }  

[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 图片加载状态监听  
  3.  * @author Yan  
  4.  *  
  5.  */  
  6. public class ImageListenerFactory {  
  7.     private static final String TAG="ImageListenerFactory";  
  8.   
  9.     public static ImageListener getImageListener(final ImageView view,  
  10.             final int defaultImageResId, final int errorImageResId){  
  11.         return new ImageListener() {  
  12.   
  13.             @Override  
  14.             public void onErrorResponse(VolleyError error) {  
  15.                 if(errorImageResId!=0){  
  16.                     view.setImageResource(errorImageResId);  
  17.                 }  
  18.             }  
  19.   
  20.             @Override  
  21.             public void onResponse(ImageContainer response, boolean isImmediate) {  
  22.                 if(response.getBitmap()!=null){  
  23.                     if(view.getTag().toString().equals(response.getRequestUrl())){  
  24.                         view.setImageBitmap(response.getBitmap());  
  25.                     }  
  26.                 }  
  27.                 else if(defaultImageResId!=0){  
  28.                     view.setImageResource(defaultImageResId);  
  29.                 }  
  30.             }  
  31.         };  
  32.     }  
  33. }  

这里加载图片采用了LRU算法，然后配合软引用使用，这样会更好的对内存进行管理，代码中注释已经很详细，相信大家都可以理解。
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 返回成功监听(自定义处理逻辑)  
  3.  * @author Yan  
  4.  */  
  5. public abstract class MyReponseListener implements Response.Listener<BaseVO> {  
  6.     @Override  
  7.     public void onResponse(BaseVO arg0) {  
  8.         onMyResponse(arg0);  
  9.     }  
  10.   
  11.     public boolean onMyResponse(BaseVO t) {  
  12.         //      DialogMaker.closeProgressDialog();  
  13.         // 自定义处理逻辑  
  14.         ...  
  15.         return true;  
  16.     }  
  17. }  
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1.   
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. /**  
  2.  * 自定义返回错误信息监听  
  3.  *   
  4.  * @author Yan  
  5.  *   
  6.  */  
  7. public abstract class MyErrorListener implements ErrorListener {  
  8.   
  9.     public void onErrorResponse(VolleyError error) {  
  10.         //自定义同意错误逻辑处理  
  11.         ...  
  12.     }  
  13. }  
下面提供一个请求服务器返回数据后封装成对象的一个GsonRequest:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. public class GsonRequest extends Request<BaseVO>{  
  2.     private static final String TAG="GsonRequest";  
  3.     //超时时间，默认10秒  
  4.     private int defaultHttpTimeOut=10*1000;  
  5.     //回调监听  
  6.     private Listener<BaseVO> listener;  
  7.     //返回类型  
  8.     private Type type;  
  9.     //请求参数  
  10.     private Map<String,String> methodBody;   
  11.   
  12.     /**  
  13.      * get请求  
  14.      *   
  15.      * @param url  
  16.      * @param type  
  17.      * @param listener  
  18.      * @param errorListener  
  19.      */  
  20.     public GsonRequest(String url, Type type, Listener<BaseVO> listener,  
  21.             ErrorListener errorListener) {  
  22.         super(Method.GET, url, errorListener);  
  23.         // 不启用缓存(默认是true)  
  24.         setShouldCache(false);  
  25.         this.type = type;  
  26.         this.listener = listener;  
  27.         // 设置重连策略  
  28.         this.setRetryPolicy(new DefaultRetryPolicy(defaultHttpTimeOut,  
  29.                 DefaultRetryPolicy.DEFAULT_MAX_RETRIES,  
  30.                 DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));  
  31.     }  
  32.   
  33.   
  34.     /**  
  35.      * post请求  
  36.      *   
  37.      * @param methodName  
  38.      * @param methodBoby  
  39.      * @param type  
  40.      * @param listener  
  41.      * @param errorListener  
  42.      */  
  43.     public GsonRequest(String url, Map<String, String> methodBoby, Type type,  
  44.             Listener<BaseVO> listener, ErrorListener errorListener) {  
  45.         super(Method.POST, url, errorListener);  
  46.         this.methodBody = methodBoby;  
  47.         this.listener = listener;  
  48.         this.type = type;  
  49.         // 不启用缓存  
  50.         setShouldCache(false);  
  51.         // 设置重连策略  
  52.         this.setRetryPolicy(new DefaultRetryPolicy(defaultHttpTimeOut,  
  53.                 DefaultRetryPolicy.DEFAULT_MAX_RETRIES,  
  54.                 DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));  
  55.     }  
  56.   
  57.     /**  
  58.      * 设置请求参数  
  59.      */  
  60.     @Override  
  61.     protected Map<String, String> getParams() throws AuthFailureError {  
  62.         if(methodBody==null){  
  63.             return super.getParams();  
  64.         }  
  65.         //创建一个集合，保存请求参数  
  66.         Map<String,String> map=new LinkedHashMap<>();  
  67.         //----此处可以添加多个通用参数  
  68.         //map.put(key,value);  
  69.         //------  
  70.         //------  
  71.         //遍历集合  
  72.         Iterator<Entry<String,String>> iter=methodBody.entrySet().iterator();  
  73.         while(iter.hasNext()){  
  74.             Entry<String, String> entry=iter.next();  
  75.             map.put(entry.getKey(), entry.getValue());  
  76.         }  
  77.         return map;  
  78.     }  
  79.   
  80.     /**  
  81.      * 将服务器返回的原生字节内容进行转换  
  82.      */  
  83.     @Override  
  84.     protected Response<BaseVO> parseNetworkResponse(NetworkResponse response) {  
  85.         try {  
  86.             // 获取返回的数据(在 Content-Type首部中获取编码集，如果没有找到，默认返回 ISO-8859-1)  
  87.             String jsonString = new String(response.data,  
  88.                     HttpHeaderParser.parseCharset(response.headers));  
  89.             return Response.success(parseNetworkResponseDelegate(jsonString),  
  90.                     HttpHeaderParser.parseCacheHeaders(response));  
  91.         } catch (Exception e) {  
  92.             return Response.error(new ParseError(e));  
  93.         }  
  94.     }  
  95.   
  96.     /**  
  97.      * 将服务器返回的内容用gson进行封装  
  98.      */  
  99.     private BaseVO parseNetworkResponseDelegate(String jsonString) {  
  100.             return new Gson().fromJson(jsonString, type);  
  101.     }  
  102.   
  103.     /**  
  104.      * 将解析后的数据进行回调  
  105.      */  
  106.     @Override  
  107.     protected void deliverResponse(BaseVO arg0) {  
  108.         listener.onResponse(arg0);  
  109.     }  
  110. }  

下面提供一个请求服务器返回XML格式数据后的一个XMLRequest:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. **  
  2.  * 服务器以XML格式返回数据  
  3.  * @author Yan  
  4.  */  
  5. public class XMLRequest extends Request<XmlPullParser>{  
  6.     private Listener<XmlPullParser> mListener;  
  7.   
  8.     public XMLRequest(int method, String url, Listener<XmlPullParser> listener,  
  9.             ErrorListener errorListener){  
  10.         super(method, url, errorListener);  
  11.         //不启用缓存  
  12.         setShouldCache(false);  
  13.         mListener=listener;  
  14.     }  
  15.   
  16.     public XMLRequest(String url, Listener<XmlPullParser> listener, ErrorListener errorListener) {  
  17.         this(Method.GET, url, listener, errorListener);  
  18.     }  
  19.   
  20.   
  21.     /**  
  22.      * 解析服务器返回的数据  
  23.      */  
  24.     @Override  
  25.     protected Response<XmlPullParser> parseNetworkResponse(  
  26.             NetworkResponse response) {  
  27.         try {    
  28.             String xmlString = new String(response.data,    
  29.                     HttpHeaderParser.parseCharset(response.headers));    
  30.             //创建解析工厂  
  31.             XmlPullParserFactory factory = XmlPullParserFactory.newInstance();    
  32.             //获取解析器  
  33.             XmlPullParser xmlPullParser = factory.newPullParser();    
  34.             //设置解析数据  
  35.             xmlPullParser.setInput(new StringReader(xmlString));    
  36.             return Response.success(xmlPullParser, HttpHeaderParser.parseCacheHeaders(response));    
  37.         } catch (UnsupportedEncodingException e) {    
  38.             return Response.error(new ParseError(e));    
  39.         } catch (XmlPullParserException e) {    
  40.             return Response.error(new ParseError(e));    
  41.         }    
  42.     }  
  43.   
  44.     /**  
  45.      * 分发结果  
  46.      */  
  47.     @Override  
  48.     protected void deliverResponse(XmlPullParser response) {  
  49.         mListener.onResponse(response);  
  50.     }  
  51. }  

下面提供一个文件上传(支持多文件)的一个PostUploadRequest:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. public class PostUploadRequest extends Request<String>{  
  2.        /**  
  3.      * 正确数据的时候回掉用  
  4.      */  
  5.     private Listener mListener ;  
  6.     /*请求 数据通过参数的形式传入*/  
  7.     private List<FormImage> mListItem ;  
  8.   
  9.     private String BOUNDARY = "--------------520-13-14"; //数据分隔线  
  10.     private String MULTIPART_FORM_DATA = "multipart/form-data";  
  11.   
  12.     public PostUploadRequest(String url, List<FormImage> listItem, Listener<String> listener,  
  13.             ErrorListener errorListener) {  
  14.         super(Method.POST, url, errorListener);  
  15.         this.mListener = listener ;  
  16.         setShouldCache(false);  
  17.         mListItem = listItem ;  
  18.         //设置请求的响应事件，因为文件上传需要较长的时间，所以在这里加大了，设为10秒  
  19.         setRetryPolicy(new DefaultRetryPolicy(10*1000,DefaultRetryPolicy.DEFAULT_MAX_RETRIES,DefaultRetryPolicy.DEFAULT_BACKOFF_MULT));  
  20.     }  
  21.   
  22.     /**  
  23.      * 这里开始解析数据  
  24.      * @param response Response from the network  
  25.      * @return  
  26.      */  
  27.     @Override  
  28.     protected Response<String> parseNetworkResponse(NetworkResponse response) {  
  29.         try {  
  30.             String mString =  
  31.                     new String(response.data, HttpHeaderParser.parseCharset(response.headers));  
  32.             return Response.success(mString,  
  33.                     HttpHeaderParser.parseCacheHeaders(response));  
  34.         } catch (UnsupportedEncodingException e) {  
  35.             return Response.error(new ParseError(e));  
  36.         }  
  37.     }  
  38.   
  39.     /**  
  40.      * 回调正确的数据  
  41.      * @param response The parsed response returned by  
  42.      */  
  43.     @Override  
  44.     protected void deliverResponse(String response) {  
  45.         mListener.onResponse(response);  
  46.     }  
  47.   
  48.     @Override  
  49.     public byte[] getBody() throws AuthFailureError {  
  50.         if (mListItem == null||mListItem.size() == 0){  
  51.             return super.getBody() ;  
  52.         }  
  53.         ByteArrayOutputStream bos = new ByteArrayOutputStream() ;  
  54.         int N = mListItem.size() ;  
  55.         for (int i = 0; i < N ;i++){  
  56.             FormImage formImage = mListItem.get(i) ;  
  57.             StringBuffer sb= new StringBuffer() ;  
  58.             /*第一行*/  
  59.             //`"--" + BOUNDARY + "\r\n"`  
  60.             sb.append("--"+BOUNDARY);  
  61.             sb.append("\r\n") ;  
  62.             /*第二行*/  
  63.             //Content-Disposition: form-data; name="参数的名称"; filename="上传的文件名" + "\r\n"  
  64.             sb.append("Content-Disposition: form-data;");  
  65.             sb.append(" name=\"");  
  66.             sb.append(formImage.getName()) ;  
  67.             sb.append("\"") ;  
  68.             sb.append("; filename=\"") ;  
  69.             sb.append(formImage.getFileName()) ;  
  70.             sb.append("\"");  
  71.             sb.append("\r\n") ;  
  72.             /*第三行*/  
  73.             //Content-Type: 文件的 mime 类型 + "\r\n"  
  74.             sb.append("Content-Type: ");  
  75.             sb.append(formImage.getMime()) ;  
  76.             sb.append("\r\n") ;  
  77.             /*第四行*/  
  78.             //"\r\n"  
  79.             sb.append("\r\n") ;  
  80.             try {  
  81.                 bos.write(sb.toString().getBytes("utf-8"));  
  82.                 /*第五行*/  
  83.                 //文件的二进制数据 + "\r\n"  
  84.                 bos.write(formImage.getValue());  
  85.                 bos.write("\r\n".getBytes("utf-8"));  
  86.             } catch (IOException e) {  
  87.                 e.printStackTrace();  
  88.             }  
  89.   
  90.         }  
  91.         /*结尾行*/  
  92.         //`"--" + BOUNDARY + "--" + "\r\n"`  
  93.         String endLine = "--" + BOUNDARY + "--" + "\r\n" ;  
  94.         try {  
  95.             bos.write(endLine.toString().getBytes("utf-8"));  
  96.         } catch (IOException e) {  
  97.             e.printStackTrace();  
  98.         }  
  99.         return bos.toByteArray();  
  100.     }  
  101.     //Content-Type: multipart/form-data; boundary=----------8888888888888  
  102.     @Override  
  103.     public String getBodyContentType() {  
  104.         return MULTIPART_FORM_DATA+"; boundary="+BOUNDARY;  
  105.     }  
  106. }  

上传文件的FormImage类如下:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. public class FormImage {  
  2.     //参数的名称  
  3.     private String name ;  
  4.     //文件名  
  5.     private String fileName ;  
  6.     //文件的mine  
  7.     private String mime ;  
  8.     //需要上传的文件  
  9.     private File file ;  
  10.   
  11.     public FormImage() {  
  12.     }  
  13.   
  14.     public File getFile() {  
  15.         return file;  
  16.     }  
  17.   
  18.     public void setFile(File file) {  
  19.         this.file = file;  
  20.     }  
  21.   
  22.     public String getMime() {  
  23.         return mime;  
  24.     }  
  25.   
  26.     public void setMime(String mime) {  
  27.         this.mime = mime;  
  28.     }  
  29.   
  30.     public String getFileName() {  
  31.         return fileName;  
  32.     }  
  33.   
  34.     public void setFileName(String fileName) {  
  35.         this.fileName = fileName;  
  36.     }  
  37.   
  38.     public String getName() {  
  39.         return name;  
  40.     }  
  41.   
  42.     public void setName(String name) {  
  43.         this.name = name;  
  44.     }  
  45.   
  46.     //对文件进行二进制转换  
  47.     public byte[] getValue() {  
  48.         byte[] buffer = null;  
  49.         try {  
  50.             FileInputStream fis = new FileInputStream(file);  
  51.             ByteArrayOutputStream bos = new ByteArrayOutputStream(1024);  
  52.             byte[] b = new byte[1024];  
  53.             int n;  
  54.             while ((n = fis.read(b)) != -1) {  
  55.                 bos.write(b, 0, n);  
  56.             }  
  57.             fis.close();  
  58.             bos.close();  
  59.             buffer = bos.toByteArray();  
  60.         } catch (FileNotFoundException e) {  
  61.             e.printStackTrace();  
  62.         } catch (IOException e) {  
  63.             e.printStackTrace();  
  64.         }  
  65.         return buffer;  
  66.     }  

下面演示如何使用封装后的方法进行网络请求: 
1.发送get请求:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void getMyVolley() {  
  2.         String url="http://api.k780.com:88/?app=idcard.get&idcard=110101199001011114&appkey=10003&sign=b59bc3ef6191eb9f747dd4e83c99f2a4&format=json";  
  3.         GsonRequest request=new GsonRequest(url, PersonInfoBean.class, new MyReponseListener() {  
  4.   
  5.             @Override  
  6.             public void onResponse(BaseVO t) {  
  7.                 super.onResponse(t);  
  8.                 PersonInfoBean bean=(PersonInfoBean) t;  
  9.                 Log.e("success", bean.toString());  
  10.             }  
  11.   
  12.         }, new MyErrorListener() {  
  13.   
  14.             @Override  
  15.             public void onErrorResponse(VolleyError error) {  
  16.                 super.onErrorResponse(error);  
  17.             }  
  18.   
  19.         });  
  20.         MyVolley.addRequest(request);  
  21.     }  

2.发送post请求:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void postMyVolley() {  
  2.         String url="http://api.k780.com:88/?app=idcard.get";  
  3.         Map<String,String> map=new HashMap<>();  
  4.         map.put("appkey", "10003");  
  5.         map.put("sign", "b59bc3ef6191eb9f747dd4e83c99f2a4");  
  6.         map.put("format", "json");  
  7.         map.put("idcard", "110101199001011114");  
  8.         GsonRequest request=new GsonRequest(url, map, PersonInfoBean.class, new MyReponseListener() {  
  9.   
  10.             @Override  
  11.             public void onResponse(BaseVO vo) {  
  12.                 super.onResponse(vo);  
  13.                 PersonInfoBean bean=(PersonInfoBean) vo;  
  14.                 Log.e("sucess", bean.toString());  
  15.             }  
  16.   
  17.         }, new MyErrorListener() {  
  18.   
  19.             @Override  
  20.             public void onErrorResponse(VolleyError error) {  
  21.                 super.onErrorResponse(error);  
  22.             }  
  23.   
  24.         });  
  25.         MyVolley.addRequest(request);  
  26.     }  


3.上传多文件演示:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. //上传文件路径  
  2.         String url="http://192.168.1.107:8080/FileUpload/FileServlet";  
  3.         List<FormImage> list=new ArrayList<>();  
  4.         String path1= Environment.getExternalStorageDirectory().getPath()+File.separator+"ss.png";  
  5.         String path2= Environment.getExternalStorageDirectory().getPath()+File.separator+"ic_launcher.png";  
  6.         File file1=new File(path1);  
  7.         File file2=new File(path2);  
  8.   
  9.         FormImage f1=new FormImage();  
  10.         f1.setFile(file1);  
  11.         f1.setFileName("t1");  
  12.         f1.setName("file1");  
  13.         f1.setMime("image/png");  
  14.         list.add(f1);  
  15.   
  16.         FormImage f2=new FormImage();  
  17.         f2.setFile(file2);  
  18.         f2.setFileName("t2");  
  19.         f2.setName("file2");  
  20.         f2.setMime("image/png");  
  21.         list.add(f2);  
  22.   
  23.   
  24.         PostUploadRequest request=new PostUploadRequest(url, list, new Response.Listener<String>() {  
  25.             @Override  
  26.             public void onResponse(String s) {  
  27.                 Log.e("success",s);  
  28.             }  
  29.         }, new Response.ErrorListener() {  
  30.             @Override  
  31.             public void onErrorResponse(VolleyError volleyError) {  
  32.   
  33.             }  
  34.         });  
  35.         MyVolley.addRequest(request);  
  36.     }  


4.发送请求，服务器返回XML:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. private void getXml() {  
  2.         String url="http://flash.weather.com.cn/wmaps/xml/china.xml";  
  3.         XMLRequest request=new XMLRequest( url, new Response.Listener<XmlPullParser>() {  
  4.             @Override  
  5.             public void onResponse(XmlPullParser xmlPullParser) {  
  6.                 try {  
  7.                     int eventType = xmlPullParser.getEventType();  
  8.                     while (eventType != XmlPullParser.END_DOCUMENT) {  
  9.                         switch (eventType) {  
  10.                             case XmlPullParser.START_TAG:  
  11.                                 String nodeName = xmlPullParser.getName();  
  12.                                 if ("city".equals(nodeName)) {  
  13.                                     String pName = xmlPullParser.getAttributeValue(0);  
  14.                                     Log.e("TAG", "city is " + pName);  
  15.                                 }  
  16.                                 break;  
  17.                         }  
  18.                         eventType = xmlPullParser.next();  
  19.                     }  
  20.                 }catch(Exception e){  
  21.                     e.printStackTrace();  
  22.                 }  
  23.             }  
  24.         }, new Response.ErrorListener() {  
  25.             @Override  
  26.             public void onErrorResponse(VolleyError volleyError) {  
  27.   
  28.             }  
  29.         });  
  30.         MyVolley.addRequest(request);  
  31.     }  

4.利用ImageLoader加载图片:
[html] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. public class MyAdapter extends  BaseAdapter{  
  2.     private Context context;  
  3.     private List<Person> list;  
  4.     private LayoutInflater mInflater;  
  5.     public ViewHolder holder;  
  6.     public MyAdapter(Context context, List<Person> list) {  
  7.         this.context = context;  
  8.         this.list = list;  
  9.         this.mInflater=LayoutInflater.from(context);  
  10.     }  
  11.   
  12.     @Override  
  13.     public int getCount() {  
  14.         return list.size();  
  15.     }  
  16.   
  17.     @Override  
  18.     public Object getItem(int position) {  
  19.         return list.get(position);  
  20.     }  
  21.   
  22.     @Override  
  23.     public long getItemId(int position) {  
  24.         return position;  
  25.     }  
  26.   
  27.     @Override  
  28.     public View getView(int position, View convertView, ViewGroup parent) {  
  29.         holder=null;  
  30.         if(convertView==null){  
  31.             convertView=mInflater.inflate(R.layout.itemone, null);  
  32.             holder=new ViewHolder();  
  33.             holder.iv_image=(ImageView) convertView.findViewById(R.id.iv_image);  
  34.             holder.tv_name=(TextView) convertView.findViewById(R.id.tv_name);  
  35.             convertView.setTag(holder);  
  36.         }  
  37.         else{  
  38.             holder=(ViewHolder) convertView.getTag();  
  39.         }  
  40.         Person bean=list.get(position);  
  41.         holder.tv_name.setText(bean.getName());  
  42.         MyVolley.getImage(bean.getImgUrl(), holder.iv_image, R.mipmap.ic_launcher, R.mipmap.ic_launcher,150,150);  
  43.         return convertView;  
  44.     }  
  45.   
  46.     class ViewHolder{  
  47.         private TextView tv_name;  
  48.         private ImageView iv_image;  
  49.     }  
  50. }  


上面主要介绍了如何封装Volley，并且如何使用封装后的MyVolley进行网络请求。 
演示： 

今天说了这么多，相信大家一定对Volley可以达到基本掌握的情况了，本篇文章主要是从实战角度出发，主要是让大家体验一下volley的框架封装的用法，volley的源码本篇文章没有涉及到，但是这完全不影响大家使用volley，后续有时间我会从源码角度进行分析volley，说了这么多，有点饿了，今天就说到这里了，大家快快练习一下Volley的操作吧~!

源码链接:http://download.csdn.net/detail/a1002450926/9379197

posted on 2016-09-18 17:08  miaozhenzhong  阅读(179)  评论(0)  编辑  收藏  举报

导航