精华内容
下载资源
问答
  • volley框架

    2018-04-10 19:42:20
    volley框架jar包,导入项目中可以获取volley框架 便于开发
  • Volley框架

    2019-04-17 20:19:28
    //创建一个类,继承Addlication public class MyApp extends Application { private static RequestQueue queue; @Override public void onCreate() { ... queue = Volley.newRequestQueue(getApplica...

    //创建一个类,继承Addlication
    public class MyApp extends Application {

    private static RequestQueue queue;
    @Override
    public void onCreate() {
        super.onCreate();
        queue = Volley.newRequestQueue(getApplicationContext());
    }
    public static RequestQueue getHttpQueue(){
        return queue;
    }
    

    }
    //在清单文件中调用MyApp类
    android:name=".volley.MyApp"

    //HttpVolley
    public class HttpVolley {

    private static HttpVolley httpVolley;
    private StringRequest stringRequest;
    
    public interface VolleyCallBack{
        void onSuccess(String data);
        void onFail(VolleyError error);
    }
    //网络判断
    public boolean isNet(Context context){
        if (context!=null){
            ConnectivityManager mConnectivityManager =
                    (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = mConnectivityManager.getActiveNetworkInfo();
            if (networkInfo!=null){
                return networkInfo.isAvailable();
            }
        }
        return false;
    }
    //单例模式
    public static  synchronized HttpVolley getInstance(){
        if (httpVolley==null){
            httpVolley=new HttpVolley();
        }
        return httpVolley;
    }
    
    
    public void HttpVolleyGet(String url,final VolleyCallBack callBack){
        stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                callBack.onSuccess(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callBack.onFail(error);
            }
        });
        //设置请求的Tag标签,可以在全局请求队列中通过Tag标签进行请求的查找
        stringRequest.setTag("textPost");
        //将请求加入全局队列中
        MyApp.getHttpQueue().add(stringRequest);
    }
    //post请求
    public void HttpVolleyPost(String url, final Map<String,String> map,final VolleyCallBack callBack){
        stringRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                callBack.onSuccess(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                callBack.onFail(error);
            }
        }){
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                return map;
            }
        };
        stringRequest.setTag("textPost");
        MyApp.getHttpQueue().add(stringRequest);
    }
    

    }

    展开全文
  • Volley 框架

    千次阅读 2018-04-10 20:31:30
    本文转载自:https://blog.csdn.net/u011324501/article/details/53933212Volley可以 自动调度网络请求 多个并发的网络连接 通过使用标准的HTTP缓存机制保持磁盘和内存响应的一致 支持请求优先级 ...Volley特别适合数...

    本文转载自:https://blog.csdn.net/u011324501/article/details/53933212

    Volley可以 自动调度网络请求 多个并发的网络连接 通过使用标准的HTTP缓存机制保持磁盘和内存响应的一致 支持请求优先级 支持取消请求的强大API,可以取消单个请求或多个 易于定制 健壮性:便于正确的更新UI和获取数据 包含调试和追踪工具等优点。

    Volley特别适合数据量不大但是通信频繁的场景。

    1、首先下载一个volley.jar包导入libs文件下,下载地址http://download.csdn.net/detail/u010049692/7813127

    2、新布局代码中添加几个按钮,两个图片按钮和一个textview用于显示数据

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:id="@+id/activity_main"  
    4.     android:layout_width="match_parent"  
    5.     android:layout_height="match_parent"  
    6.     android:orientation="vertical">  
    7.   
    8.     <Button  
    9.         android:id="@+id/volley_get"  
    10.         android:layout_width="match_parent"  
    11.         android:layout_height="wrap_content"  
    12.         android:layout_marginTop="5dip"  
    13.         android:text="get请求" />  
    14.   
    15.     <Button  
    16.         android:id="@+id/volley_post"  
    17.         android:layout_width="match_parent"  
    18.         android:layout_height="wrap_content"  
    19.         android:layout_marginTop="5dip"  
    20.         android:text="post请求" />  
    21.   
    22.     <Button  
    23.         android:id="@+id/volley_json"  
    24.         android:layout_width="match_parent"  
    25.         android:layout_height="wrap_content"  
    26.         android:layout_marginTop="5dip"  
    27.         android:text="请求json数据请求" />  
    28.   
    29.     <Button  
    30.         android:id="@+id/volley_imageRequest"  
    31.         android:layout_width="match_parent"  
    32.         android:layout_height="wrap_content"  
    33.         android:layout_marginTop="5dip"  
    34.         android:text="imageRequest加载图片" />  
    35.   
    36.     <Button  
    37.         android:id="@+id/volley_imageLader"  
    38.         android:layout_width="match_parent"  
    39.         android:layout_height="wrap_content"  
    40.         android:layout_marginTop="5dip"  
    41.         android:text="imageLader加载图片" />  
    42.   
    43.     <Button  
    44.         android:id="@+id/netWorkImageView"  
    45.         android:layout_width="match_parent"  
    46.         android:layout_height="wrap_content"  
    47.         android:layout_marginTop="5dip"  
    48.         android:text="netWorkImageView" />  
    49.   
    50.     <TextView  
    51.         android:layout_width="match_parent"  
    52.         android:layout_height="wrap_content"  
    53.         android:layout_marginTop="5dip"  
    54.         android:text="显示结果" />  
    55.   
    56.     <ImageView  
    57.         android:id="@+id/volley_image"  
    58.         android:layout_width="wrap_content"  
    59.         android:layout_height="wrap_content"  
    60.         android:layout_marginTop="5dip" />  
    61.   
    62.     <com.facebook.drawee.view.SimpleDraweeView  
    63.         android:id="@+id/volley_imageNet"  
    64.         android:layout_width="wrap_content"  
    65.         android:layout_height="wrap_content"  
    66.         android:layout_marginTop="5dip" />  
    67.   
    68.     <ScrollView  
    69.         android:layout_width="match_parent"  
    70.         android:layout_height="match_parent"  
    71.         android:layout_marginTop="5dip">  
    72.   
    73.         <TextView  
    74.             android:id="@+id/volley_result"  
    75.             android:layout_width="match_parent"  
    76.             android:layout_height="wrap_content"  
    77.             android:text="" />  
    78.   
    79.     </ScrollView>  
    80. </LinearLayout>  
    3、由于要显示网络图片,所以添加fresco,需要在build.gradle 中添加下面代码,并在需要在新建一个MyApplication类,记得在权限中添加。还要添加网络权限代码
    [html] view plain copy
    1. compile 'com.facebook.fresco:fresco:0.12.0'  
    [html] view plain copy
    1. package com.example.apple.volley;  
    2.   
    3. import android.app.Application;  
    4.   
    5. import com.facebook.drawee.backends.pipeline.Fresco;  
    6.   
    7. /**  
    8.  * Created by apple on 16/12/29.  
    9.  */  
    10.   
    11. public class MyApplication extends Application {  
    12.     public MyApplication() {  
    13.         super();  
    14.     }  
    15.   
    16.     @Override  
    17.     public void onCreate() {  
    18.         super.onCreate();  
    19.   
    20.         //Fresco初始化  
    21.         Fresco.initialize(getApplicationContext());  
    22.     }  
    23. }  

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     package="com.example.apple.volley">  
    4.     <uses-permission android:name="android.permission.INTERNET" />  
    5.     <application  
    6.         android:name=".MyApplication"  
    7.         android:allowBackup="true"  
    8.         android:icon="@mipmap/ic_launcher"  
    9.         android:label="@string/app_name"  
    10.         android:supportsRtl="true"  
    11.         android:theme="@style/AppTheme">  
    12.         <activity android:name=".MainActivity">  
    13.             <intent-filter>  
    14.                 <action android:name="android.intent.action.MAIN" />  
    15.   
    16.                 <category android:name="android.intent.category.LAUNCHER" />  
    17.             </intent-filter>  
    18.         </activity>  
    19.     </application>  
    20. </manifest>  
    4、先实现get 请求,首先创建一个队列,然后创建一个请求,将url传进去,请求中有两个方法,当正确接受数据时可以打印出来,错误时也可以显示出来,最后添加到队列中,这就完成了get请求。返回的数据可自己处理。

    [html] view plain copy
    1. /**  
    2.    * get  
    3.    */  
    4.   public void get(){  
    5.       //创建一个请求队列  
    6.       requestQueue = Volley.newRequestQueue(MainActivity.this);  
    7.       //创建一个请求  
    8.       String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    9.   
    10.       StringRequest stringRequest =new StringRequest(url, new Response.Listener<String>() {  
    11.           //正确接收数据回调  
    12.           @Override  
    13.           public void onResponse(String s) {  
    14.   
    15.               try {  
    16.                   JSONObject jsonObject = new JSONObject(s);  
    17.                  // TestData testDatanew Gson().fromJson(s, TestData.class);  
    18.                  // Log.e(TAG,"length="+jsonObject.getJSONObject("trailers").length());  
    19.                //   for (int i = 0;i<jsonObject.getJSONObject("trailers").length();i++){  
    20.                       volley_result.setText(s);  
    21.                       Log.e(TAG,"s="+jsonObject.getJSONArray("trailers").get(0)+"\n");  
    22.                  // }  
    23.   
    24.               } catch (JSONException e) {  
    25.                   e.printStackTrace();  
    26.               }  
    27.   
    28.           }  
    29.       }, new Response.ErrorListener() {//异常后的监听数据  
    30.           @Override  
    31.           public void onErrorResponse(VolleyError volleyError) {  
    32.               volley_result.setText("加载错误"+volleyError);  
    33.           }  
    34.       });  
    35.       //将get请求添加到队列中  
    36.       requestQueue.add(stringRequest);  
    37.   }  

    5、实现post请求,post请求跟get差不多,都要创建一个队列,然后创建一个请求,再添加到队列中,不同的是,需要在创建请求时声明是POST,传入参数时可以用Map,然后返回。
    [html] view plain copy
    1. private void post(){  
    2.         //创建一个请求队列  
    3.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    4.         //创建一个请求  
    5.         String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    6.   
    7.         StringRequest stringRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {  
    8.             @Override  
    9.             public void onResponse(String s) {  
    10.                 volley_result.setText(s);  
    11.             }  
    12.   
    13.         }, new Response.ErrorListener() {  
    14.             @Override  
    15.             public void onErrorResponse(VolleyError volleyError) {  
    16.                 volley_result.setText("加载错误"+volleyError);  
    17.             }  
    18.         }){  
    19.             @Override  
    20.             protected Map<String, String> getParams() throws AuthFailureError {  
    21.   
    22.                 Map<String,String> map = new HashMap<>();  
    23.                // map.put("value1","param1");//传入参数  
    24.   
    25.                 return map;  
    26.             }  
    27.         };  
    28.   
    29.         //将post请求添加到队列中  
    30.         requestQueue.add(stringRequest);  
    31.     }  

    6、json请求,跟上面基本一样,但是如果数据格式外面时{}需要用JsonObjectRequest,如果时[]则要用JsonArrayRequest,返回的是JSONObject数据。

    [html] view plain copy
    1. private void json(){  
    2.        //创建一个请求队列  
    3.         requestQueue = Volley.newRequestQueue(MainActivity.this);  
    4.   
    5.        //创建一个请求  
    6.        String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    7.        JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(url, null, new Response.Listener<JSONObject>() {  
    8.            @Override  
    9.            public void onResponse(JSONObject jsonObject) {  
    10.                //TestData data = new Gson().fromJson(String.valueOf(jsonObject),TestData.class);  
    11.                volley_result.setText(jsonObject.toString());  
    12.                Log.e(TAG,"data="+jsonObject);  
    13.            }  
    14.        }, new Response.ErrorListener() {  
    15.            @Override  
    16.            public void onErrorResponse(VolleyError volleyError) {  
    17.                volley_result.setText("加载错误"+volleyError);  
    18.   
    19.            }  
    20.        });  
    21.   
    22.        //将创建的请求添加到队列中  
    23.        requestQueue.add(jsonObjectRequest);  
    24.    }  

    7、加载图片,也是需要那三步,但是是用ImageRequest。

    [html] view plain copy
    1. /**  
    2.     * 加载图片  
    3.     */  
    4.    private void image(){  
    5.        //创建一个请求队列  
    6.         requestQueue = Volley.newRequestQueue(MainActivity.this);  
    7.   
    8.        //创建一个请求  
    9.        String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    10.        //第二个参数,第三个:宽高,第四个:图片质量  
    11.        ImageRequest imageRequest = new ImageRequest(url, new Response.Listener<Bitmap>() {  
    12.            @Override  
    13.            public void onResponse(Bitmap bitmap) {  
    14.                //正确接收图片  
    15.                volley_image.setImageBitmap(bitmap);  
    16.            }  
    17.        }, 0, 0, Bitmap.Config.RGB_565, new Response.ErrorListener() {  
    18.            @Override  
    19.            public void onErrorResponse(VolleyError volleyError) {  
    20.                volley_image.setImageResource(R.mipmap.ic_launcher);  
    21.            }  
    22.        });  
    23.   
    24.        //将创建的请求添加到队列中  
    25.        requestQueue.add(imageRequest);  
    26.    }  
    8、加载网络图片,这个可以新建一个BitmapCache类用来缓存图片

    [html] view plain copy
    1. private void imageLoader(){  
    2.         //创建一个请求队列  
    3.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    4.   
    5.         //创建一个请求  
    6.   
    7. //        ImageLoader imageLoader = new ImageLoader(requestQueue, new ImageLoader.ImageCache() {  
    8. //            @Override  
    9. //            public Bitmap getBitmap(String s) {  
    10. //                return null;  
    11. //            }  
    12. //  
    13. //            @Override  
    14. //            public void putBitmap(String s, Bitmap bitmap) {  
    15. //  
    16. //            }  
    17. //        });  
    18.   
    19.         ImageLoader imageLoader = new ImageLoader(requestQueue,new BitmapCache());//带缓存  
    20.   
    21.         //加载图片  
    22.         String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    23.         //加载不到,加载失败  
    24.         ImageLoader.ImageListener imageLister = ImageLoader.getImageListener(volley_imageNet,R.mipmap.ic_launcher,R.mipmap.ic_launcher);  
    25.         imageLoader.get(url,imageLister);  
    26.     }  
    [html] view plain copy
    1. package com.example.apple.volley.entity;  
    2.   
    3. import android.graphics.Bitmap;  
    4. import android.util.LruCache;  
    5.   
    6. import com.android.volley.toolbox.ImageLoader;  
    7.   
    8. /**  
    9.  * Created by apple on 16/12/29.  
    10.  * 图片缓存  
    11.  */  
    12.   
    13. public class BitmapCache implements ImageLoader.ImageCache{  
    14.   
    15.     private LruCache<String,Bitmap> mCache;  
    16.   
    17.     public BitmapCache() {  
    18.         int maxSize = 10* 1024 *1024;//10m  
    19.         mCache = new LruCache<String,Bitmap>(maxSize){  
    20.             @Override  
    21.             protected int sizeOf(String key, Bitmap bitmap) {  
    22.                 return bitmap.getRowBytes() * bitmap.getHeight();  
    23.             }  
    24.         };  
    25.     }  
    26.   
    27.     @Override  
    28.     public Bitmap getBitmap(String url) {  
    29.         return mCache.get(url);  
    30.     }  
    31.   
    32.     @Override  
    33.     public void putBitmap(String url, Bitmap bitmap) {  
    34.         mCache.put(url,bitmap);  
    35.     }  
    36. }  
    10、加载网络图片
    [html] view plain copy
    1. /**  
    2.      * netWorkImageView  
    3.      */  
    4.     private void netWorkImageView(){  
    5.         //创建一个请求队列  
    6.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    7.   
    8.         //创建一个imageLoader  
    9.         ImageLoader imageLoader = new ImageLoader(requestQueue,new BitmapCache());  
    10.   
    11.         //默认图片设置  
    12.         volley_imageNet.setImageResource(R.mipmap.ic_launcher);  
    13.   
    14.         //加载图片  
    15.         String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    16.         volley_imageNet.setImageURI(url,imageLoader);  
    17.     }  
    11、最后可以在stop中添加取消所有队列

    [html] view plain copy
    1. @Override  
    2.     protected void onStop() {  
    3.         super.onStop();  
    4.         //取消队列里所有的请求  
    5.         requestQueue.cancelAll(this);  
    6.   
    7.     }  

    完整代码:

    [html] view plain copy
    1. package com.example.apple.volley;  
    2.   
    3. import android.graphics.Bitmap;  
    4. import android.support.v7.app.AppCompatActivity;  
    5. import android.os.Bundle;  
    6. import android.util.Log;  
    7. import android.view.View;  
    8. import android.widget.Button;  
    9. import android.widget.ImageView;  
    10. import android.widget.TextView;  
    11.   
    12. import com.android.volley.AuthFailureError;  
    13. import com.android.volley.Request;  
    14. import com.android.volley.RequestQueue;  
    15. import com.android.volley.Response;  
    16. import com.android.volley.VolleyError;  
    17. import com.android.volley.toolbox.ImageLoader;  
    18. import com.android.volley.toolbox.ImageRequest;  
    19. import com.android.volley.toolbox.JsonObjectRequest;  
    20. import com.android.volley.toolbox.StringRequest;  
    21. import com.android.volley.toolbox.Volley;  
    22. import com.example.apple.volley.entity.BitmapCache;  
    23. import com.facebook.drawee.view.SimpleDraweeView;  
    24.   
    25. import org.json.JSONException;  
    26. import org.json.JSONObject;  
    27.   
    28. import java.util.HashMap;  
    29. import java.util.Map;  
    30.   
    31. /**  
    32.  * JSON,图像等的异步下载;  
    33.  网络请求的排序(scheduling)  
    34.  网络请求的优先级处理  
    35.  缓存  
    36.  多级别取消请求  
    37.  和Activity和生命周期的联动(Activity结束时同时取消所有网络请求)  
    38.  */  
    39. public class MainActivity extends AppCompatActivity implements View.OnClickListener{  
    40.   
    41.     private Button volley_get;  
    42.     private Button volley_post;  
    43.     private Button volley_json;  
    44.     private Button volley_imageRequest;  
    45.     private Button volley_imageLader;  
    46.     private Button netWorkImageView;  
    47.     private ImageView volley_image;  
    48.     private SimpleDraweeView volley_imageNet;  
    49.     private TextView volley_result;  
    50.     private final String TAG = "MainActivity";  
    51.   
    52.     RequestQueue requestQueue;  
    53.   
    54.     @Override  
    55.     protected void onCreate(Bundle savedInstanceState) {  
    56.         super.onCreate(savedInstanceState);  
    57.         setContentView(R.layout.activity_main);  
    58.   
    59.         initView();  
    60.     }  
    61.   
    62.     private void initView() {  
    63.         volley_get = (Button)findViewById(R.id.volley_get);  
    64.         volley_get.setOnClickListener(this);  
    65.   
    66.         volley_post = (Button)findViewById(R.id.volley_post);  
    67.         volley_post.setOnClickListener(this);  
    68.   
    69.         volley_json = (Button)findViewById(R.id.volley_json);  
    70.         volley_json.setOnClickListener(this);  
    71.   
    72.         volley_imageRequest = (Button)findViewById(R.id.volley_imageRequest);  
    73.         volley_imageRequest.setOnClickListener(this);  
    74.   
    75.         volley_imageLader = (Button)findViewById(R.id.volley_imageLader);  
    76.         volley_imageLader.setOnClickListener(this);  
    77.   
    78.         netWorkImageView = (Button)findViewById(R.id.netWorkImageView);  
    79.         netWorkImageView.setOnClickListener(this);  
    80.   
    81.         volley_image = (ImageView) findViewById(R.id.volley_image);  
    82.   
    83.         volley_imageNet = (SimpleDraweeView) findViewById(R.id.volley_imageNet);  
    84.   
    85.         volley_result = (TextView)findViewById(R.id.volley_result);  
    86.     }  
    87.   
    88.     @Override  
    89.     public void onClick(View v) {  
    90.         switch (v.getId()){  
    91.   
    92.             case R.id.volley_get://get请求  
    93.   
    94.                 get();  
    95.   
    96.                 break;  
    97.   
    98.             case R.id.volley_post://post请求  
    99.   
    100.                 post();  
    101.                 break;  
    102.   
    103.             case R.id.volley_json://json请求 JsonObjectRequest{} JsonArrayRequest[]  
    104.   
    105.                 json();  
    106.                 break;  
    107.   
    108.             case R.id.volley_imageRequest://imageRequest加载图片  
    109.   
    110.                 image();  
    111.                 break;  
    112.   
    113.             case R.id.volley_imageLader://imageLader加载图片  
    114.                 imageLoader();  
    115.   
    116.                 break;  
    117.   
    118.             case R.id.netWorkImageView:  
    119.                     netWorkImageView();  
    120.                 break;  
    121.   
    122.             default:  
    123.                 break;  
    124.   
    125.         }  
    126.     }  
    127.   
    128.     /**  
    129.      * get  
    130.      */  
    131.     public void get(){  
    132.         //创建一个请求队列  
    133.         requestQueue = Volley.newRequestQueue(MainActivity.this);  
    134.         //创建一个请求  
    135.         String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    136.   
    137.         StringRequest stringRequest =new StringRequest(url, new Response.Listener<String>() {  
    138.             //正确接收数据回调  
    139.             @Override  
    140.             public void onResponse(String s) {  
    141.   
    142.                 try {  
    143.                     JSONObject jsonObject = new JSONObject(s);  
    144.                    // TestData testDatanew Gson().fromJson(s, TestData.class);  
    145.                    // Log.e(TAG,"length="+jsonObject.getJSONObject("trailers").length());  
    146.                  //   for (int i = 0;i<jsonObject.getJSONObject("trailers").length();i++){  
    147.                         volley_result.setText(s);  
    148.                         Log.e(TAG,"s="+jsonObject.getJSONArray("trailers").get(0)+"\n");  
    149.                    // }  
    150.   
    151.                 } catch (JSONException e) {  
    152.                     e.printStackTrace();  
    153.                 }  
    154.   
    155.             }  
    156.         }, new Response.ErrorListener() {//异常后的监听数据  
    157.             @Override  
    158.             public void onErrorResponse(VolleyError volleyError) {  
    159.                 volley_result.setText("加载错误"+volleyError);  
    160.             }  
    161.         });  
    162.         //将get请求添加到队列中  
    163.         requestQueue.add(stringRequest);  
    164.     }  
    165.   
    166.     /**  
    167.      * post  
    168.      */  
    169.     private void post(){  
    170.         //创建一个请求队列  
    171.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    172.         //创建一个请求  
    173.         String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    174.   
    175.         StringRequest stringRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {  
    176.             @Override  
    177.             public void onResponse(String s) {  
    178.                 volley_result.setText(s);  
    179.             }  
    180.   
    181.         }, new Response.ErrorListener() {  
    182.             @Override  
    183.             public void onErrorResponse(VolleyError volleyError) {  
    184.                 volley_result.setText("加载错误"+volleyError);  
    185.             }  
    186.         }){  
    187.             @Override  
    188.             protected Map<String, String> getParams() throws AuthFailureError {  
    189.   
    190.                 Map<String,String> map = new HashMap<>();  
    191.                // map.put("value1","param1");//传入参数  
    192.   
    193.                 return map;  
    194.             }  
    195.         };  
    196.   
    197.         //将post请求添加到队列中  
    198.         requestQueue.add(stringRequest);  
    199.     }  
    200.   
    201.     /**  
    202.      * json  
    203.      */  
    204.     private void json(){  
    205.         //创建一个请求队列  
    206.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    207.   
    208.         //创建一个请求  
    209.         String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";  
    210.         JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(url, null, new Response.Listener<JSONObject>() {  
    211.             @Override  
    212.             public void onResponse(JSONObject jsonObject) {  
    213.   
    214.                 //TestData data = new Gson().fromJson(String.valueOf(jsonObject),TestData.class);  
    215.   
    216.                 volley_result.setText(jsonObject.toString());  
    217.   
    218.   
    219.                 Log.e(TAG,"data="+jsonObject);  
    220.             }  
    221.         }, new Response.ErrorListener() {  
    222.             @Override  
    223.             public void onErrorResponse(VolleyError volleyError) {  
    224.                 volley_result.setText("加载错误"+volleyError);  
    225.   
    226.             }  
    227.         });  
    228.   
    229.         //将创建的请求添加到队列中  
    230.         requestQueue.add(jsonObjectRequest);  
    231.     }  
    232.   
    233.     /**  
    234.      * 加载图片  
    235.      */  
    236.     private void image(){  
    237.         //创建一个请求队列  
    238.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    239.   
    240.         //创建一个请求  
    241.         String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    242.         //第二个参数,第三个:宽高,第四个:图片质量  
    243.         ImageRequest imageRequest = new ImageRequest(url, new Response.Listener<Bitmap>() {  
    244.             @Override  
    245.             public void onResponse(Bitmap bitmap) {  
    246.                 //正确接收图片  
    247.                 volley_image.setImageBitmap(bitmap);  
    248.             }  
    249.         }, 0, 0, Bitmap.Config.RGB_565, new Response.ErrorListener() {  
    250.             @Override  
    251.             public void onErrorResponse(VolleyError volleyError) {  
    252.                 volley_image.setImageResource(R.mipmap.ic_launcher);  
    253.             }  
    254.         });  
    255.   
    256.         //将创建的请求添加到队列中  
    257.         requestQueue.add(imageRequest);  
    258.     }  
    259.   
    260.     /**  
    261.      * imageLoader  
    262.      */  
    263.     private void imageLoader(){  
    264.         //创建一个请求队列  
    265.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    266.   
    267.         //创建一个请求  
    268.   
    269. //        ImageLoader imageLoader = new ImageLoader(requestQueue, new ImageLoader.ImageCache() {  
    270. //            @Override  
    271. //            public Bitmap getBitmap(String s) {  
    272. //                return null;  
    273. //            }  
    274. //  
    275. //            @Override  
    276. //            public void putBitmap(String s, Bitmap bitmap) {  
    277. //  
    278. //            }  
    279. //        });  
    280.   
    281.         ImageLoader imageLoader = new ImageLoader(requestQueue,new BitmapCache());//带缓存  
    282.   
    283.         //加载图片  
    284.         String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    285.         //加载不到,加载失败  
    286.         ImageLoader.ImageListener imageLister = imageLoader.getImageListener(volley_imageNet,R.mipmap.ic_launcher,R.mipmap.ic_launcher);  
    287.         imageLoader.get(url,imageLister);  
    288.     }  
    289.   
    290.     /**  
    291.      * netWorkImageView  
    292.      */  
    293.     private void netWorkImageView(){  
    294.         //创建一个请求队列  
    295.          requestQueue = Volley.newRequestQueue(MainActivity.this);  
    296.   
    297.         //创建一个imageLoader  
    298.         ImageLoader imageLoader = new ImageLoader(requestQueue,new BitmapCache());  
    299.   
    300.         //默认图片设置  
    301.         volley_imageNet.setImageResource(R.mipmap.ic_launcher);  
    302.   
    303.         //加载图片  
    304.         String url = "http://img5.mtime.cn/mg/2016/12/26/164311.99230575.jpg";  
    305.         volley_imageNet.setImageURI(url,imageLoader);  
    306.     }  
    307.   
    308.     @Override  
    309.     protected void onStop() {  
    310.         super.onStop();  
    311.         //取消队列里所有的请求  
    312.         requestQueue.cancelAll(this);  
    313.   
    314.     }  
    315.   
    316.     @Override  
    317.     protected void onDestroy() {  
    318.         super.onDestroy();  
    319.     }  
    320. }  
    实现效果图片和代码下载地址:http://download.csdn.net/detail/u011324501/9725043






    展开全文
  • 安卓volley框架

    2021-01-13 23:29:36
    安卓volley框架
  • Volley框架使用

    2016-07-13 22:33:09
    Volley框架使用
  • Volley框架学习

    2016-08-19 01:43:14
    Volley框架

     前一篇粗略的介绍了一下Volley,并在最后附上了一段使用代码,这一篇详细的介绍一下Volley的使用。前面也说了Volley主要获取JSON对象和图片加载,这里也分为两部分介绍。

    1、获取JSON对象

    1.1声明RequestQueue

    声明一个新的RequestQueue对象
    [java] view plain copy
     print?
    1. private RequestQueue mRequestQueue;  
     
    onCreate初始化mRequestQueue
    [java] view plain copy
     print?
    1. mRequestQueue =  Volley.newRequestQueue(this);  

    1.2 声明并使用Request

    [java] view plain copy
     print?
    1. JsonObjectRequest jr = new JsonObjectRequest(Request.Method.GET,url,null,new Response.Listener<JSONObject>() {  
    2.             @Override  
    3.             public void onResponse(JSONObject response) {  
    4.                 Log.i(TAG,response.toString());  
    5.                 parseJSON(response);  
    6.                 va.notifyDataSetChanged();  
    7.                 pd.dismiss();  
    8.             }  
    9.         },new Response.ErrorListener() {  
    10.             @Override  
    11.             public void onErrorResponse(VolleyError error) {  
    12.                 Log.i(TAG,error.getMessage());  
    13.             }  
    14.         });  
    15.         mRequestQueue.add(jr);  


    Volley提供了JsonObjectRequest、JsonArrayRequest、StringRequest等Request形式。

    JsonObjectRequest:返回JSON对象。

    JsonArrayRequest:返回JsonArray。

    StringRequest:返回String,这样可以自己处理数据,更加灵活。

    另外可以继承Request<T>自定义Request。


    1.3 取消Request

          Activity里面启动了网络请求,而在这个网络请求还没返回结果的时候,Activity被结束了,此时如果继续使用其中的Context等,除了无辜的浪费CPU,电池,网络等资源,有可能还会导致程序crash,所以,我们需要处理这种一场情况。使用Volley的话,我们可以在Activity停止的时候,同时取消所有或部分未完成的网络请求。Volley里所有的请求结果会返回给主进程,如果在主进程里取消了某些请求,则这些请求将不会被返回给主线程。Volley支持多种request取消方式。
    1)可以针对某些个request做取消操作:


    [java] view plain copy
     print?
    1. @Override  
    2.    public void onStop() {  
    3.        for (Request <?> req : mRequestQueue) {  
    4.            req.cancel();  
    5.        }  
    6.    }  

    2)取消这个队列里的所有请求:

    [java] view plain copy
     print?
    1. @Override  
    2. protected void onStop() {  
    3.     // TODO Auto-generated method stub  
    4.     super.onStop();  
    5.     mRequestQueue.cancelAll(this);  
    6. }  

    3)可以根据RequestFilter或者Tag来终止某些请求
    [java] view plain copy
     print?
    1. @Override  
    2. rotected void onStop() {  
    3. // TODO Auto-generated method stub  
    4. super.onStop();  
    5.   
    6. mRequestQueue.cancelAll( new RequestFilter() {});  
    7. or  
    8. mRequestQueue.cancelAll(new Object());  
    9.   
    10.    


    Volley支持http的GET、POST、PUT、DELETE等方法,上面给出了GET方法,其他方法请参考



    2、图片加载

    2.1使用ImageRequest下载图片

        Volley提供了多种Request方法,ImageRequest能够处理单张图片,返回bitmap。下面是ImageRequest的使用例子,和JsonRequest的一样。
    [java] view plain copy
     print?
    1. singleImg=(ImageView)findViewById(R.id.volley_img_single_imgeview);  
    2.         ImageRequest imgRequest=new ImageRequest(url, new Response.Listener<Bitmap>() {  
    3.             @Override  
    4.             public void onResponse(Bitmap arg0) {  
    5.                 // TODO Auto-generated method stub  
    6.                 singleImg.setImageBitmap(arg0);  
    7.             }  
    8.         }, 300200, Config.ARGB_8888, new ErrorListener(){  
    9.             @Override  
    10.             public void onErrorResponse(VolleyError arg0) {  
    11.                 // TODO Auto-generated method stub  
    12.                   
    13.             }             
    14.         });  
    15.         mRequestQueue.add(imgRequest);  


    2.2使用ImageLoader

        ImageLoader这个类需要一个Request的实例以及一个ImageCache的实例。图片通过一个URL和一个ImageListener实例的get()方法就可以被加载。从哪里,ImageLoader会检查ImageCache,而且如果缓存里没有图片就会从网络上获取。

        Volley的ImageCache接口允许你使用你喜欢的L1缓存实现。不幸的是Volley没有提供默认的实现。在I/O的介绍中展示了BitmapLruCache的一点代码片段,但是Volley这个库本身并不包含任何相关的实现。

        ImageCache接口有两个方法,getBitmap(String url)和putBitmap(String url, Bitmap bitmap).这两个方法足够简单直白,他们可以添加任何的缓存实现。

    [java] view plain copy
     print?
    1. RequestQueue mRequestQueue = Volley.newRequestQueue(this);  
    2.         final LruCache<String, Bitmap> mImageCache = new LruCache<String, Bitmap>(  
    3.                 20);  
    4.         ImageCache imageCache = new ImageCache() {  
    5.             @Override  
    6.             public void putBitmap(String key, Bitmap value) {  
    7.                 mImageCache.put(key, value);  
    8.             }  
    9.   
    10.             @Override  
    11.             public Bitmap getBitmap(String key) {  
    12.                 return mImageCache.get(key);  
    13.             }  
    14.         };  
    15.         ImageLoader mImageLoader = new ImageLoader(mRequestQueue, imageCache);  
    16.         // imageView是一个ImageView实例  
    17.         // ImageLoader.getImageListener的第二个参数是默认的图片resource id  
    18.         // 第三个参数是请求失败时候的资源id,可以指定为0  
    19.         ImageListener listener = ImageLoader  
    20.                 .getImageListener(imageView, android.R.drawable.ic_menu_rotate,  
    21.                         android.R.drawable.ic_delete);  
    22.         mImageLoader.get(url, listener);  


    2.3 使用NetworkImageView


    [java] view plain copy
     print?
    1. public class NetworkImageView extends ImageView  
    继承自ImageView,添加了一个
    [java] view plain copy
     print?
    1. public void setImageUrl(String url, ImageLoader imageLoader) {}  
    方法,参数包含一个Url地址和一个ImageLoader对象
    核心方法:
    [java] view plain copy
     print?
    1. private void loadImageIfNecessary(final boolean isInLayoutPass) {}  
    内部实现,boolean 类型参数代表是否重新请求网络 ,true:重新请求 false:取缓存
    内部实现和ImageLoader类似,都是通过ImageContainer中new一个ImageListener,在ImageListener,只是做了Url的空判断,如果Url为null,则调用ImageContainer.cancelRequest();取消请求。
    覆写方法:
     
    [java] view plain copy
     print?
    1. @Override  
    2. protected void onLayout(boolean changed, int left, int top, int right, int bottom) {  
    3. super.onLayout(changed, left, top, right, bottom);  
    4. //onLayout时重新请求  
    5. loadImageIfNecessary(true);  
    6. }  
    7. @Override  
    8. protected void onDetachedFromWindow() {  
    9. //销毁View的时候Release操作  
    10. if (mImageContainer != null) {  
    11. // If the view was bound to an image request, cancel it and clear  
    12. // out the image from the view.  
    13. mImageContainer.cancelRequest();  
    14. setImageBitmap(null);  
    15. // also clear out the container so we can reload the image if necessary.  
    16. mImageContainer = null;  
    17. }  
    18. super.onDetachedFromWindow();  
    19. }  
    20. //drawable状态改变重绘  
    21. @Override  
    22. protected void drawableStateChanged() {  
    23. super.drawableStateChanged();  
    24. invalidate();  
    25. }  


        总结:网络请求下载图片显示,可以使用此控件,比传统的ImageView多了网络处理,也添加了2个方法,设置开始下载的默认图和下载出错后显示图。

    [java] view plain copy
     print?
    1. /** 
    2. * Sets the default image resource ID to be used for this view until the attempt to load it 
    3. * completes. 
    4. */  
    5. public void setDefaultImageResId(int defaultImage) {  
    6. mDefaultImageId = defaultImage;  
    7. }  
    8. /** 
    9. * Sets the error image resource ID to be used for this view in the event that the image 
    10. * requested fails to load. 
    11. */  
    12. public void setErrorImageResId(int errorImage) {  
    13. mErrorImageId = errorImage;  
    14. }  
    展开全文
  • 主要介绍了Android Volley框架全面解析的相关资料,非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • Volley框架浅析

    2017-06-16 14:56:57
    Volley框架的使用和原理做简要介绍

    一、概念



    什么是Volley

    开发android应用很多时候都要涉及网络操作,Android SDK中提供了HttpClient 和 HttpUrlConnection两种方式用来处理网络操作,但当应用比较复杂的时候需要我们编写大量的代码处理很多东西:图像缓存,请求的调度等等;

    而Volley框架就是为解决这些而生的,它与2013年Google I/O大会上被提出:使得Android应用网络操作更方便更快捷;抽象了底层Http Client等实现的细节,让开发者更专注与产生RESTful Request。另外,Volley在不同的线程上异步执行所有请求而避免了阻塞主线程。




    二、特点


    如下是Volley框架的内部实现原理图,蓝色是主线程,黄色是缓存线程,绿色是网络线程


    1. 自动调度网络请求
    2. 多个并发的网络连接
    3. 通过使用标准的HTTP缓存机制保持磁盘和内存响应的一致
    4. 支持请求优先级
    5. 支持取消请求的强大API,可以取消单个请求或多个
    6. 易于定制
    7. 健壮性:便于正确的更新UI和获取数据
    8. 包含调试和追踪工具

    三、使用


    1. 获得String数据
            volleybt.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    //新建请求队列
                    RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
    
                    //新建请求
                    String url = "https://www.baidu.com/?tn=sitehao123_15";
    
                    StringRequest request = new StringRequest(url, new Response.Listener<String>() {
                        @Override
                        public void onResponse(String s) {
                            volleytext.setText(s);
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError volleyError) {
                            volleytext.setText("加载失败"+volleyError);
                        }
                    });
    
                    requestQueue.add(request);
                }
            });

    2. 获得json数据
            json_bt.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // 1 创建一个请求队列
                    RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
    
                    // 2 创建一个请求
                    String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";
                    JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(url, null, new Response.Listener<JSONObject>() {
                        @Override
                        public void onResponse(JSONObject jsonObject) {
                            volleytext.setText(jsonObject.toString());
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError volleyError) {
                            volleytext.setText("请求失败" + volleyError);
                        }
                    });
    
                    // 3 将创建的请求添加到请求队列中
                    requestQueue.add(jsonObjectRequest);
                }
            });
    

    3. post获得String数据
            post_bt.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // 1 创建一个请求队列
                    RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
    
                    // 2 创建一个post请求
                    String url = "http://api.m.mtime.cn/PageSubArea/TrailerList.api";
                    StringRequest stringRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
                        @Override
                        public void onResponse(String s) {
                            volleytext.setText(s);
                        }
                    }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError volleyError) {
                            volleytext.setText("请求失败" + volleyError);
                        }
                    }) {
    
                    };
    
                    // 3 将post请求添加到队列中
                    requestQueue.add(stringRequest);
                }
            });
    

    4. 自定义获得xml数据
            xml_bt.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    // 1 创建一个请求队列
                    RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
                    XMLRequest xmlRequest = new XMLRequest(
                            "http://flash.weather.com.cn/wmaps/xml/china.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.d("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);
                        }
                    });
                    requestQueue.add(xmlRequest);
                }
            });

    需要重新一个xmlRequest继承Request
    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 {
                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);
        }
    }
    

    5. 自定义获得Gson解析后的数据
            gson_bt.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    RequestQueue requestQueue = Volley.newRequestQueue(MainActivity.this);
    
                    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();
                                    Log.d("TAG", "city is " + weatherInfo.getCity());
                                    Log.d("TAG", "temp is " + weatherInfo.getTemp());
                                    Log.d("TAG", "time is " + weatherInfo.getTime());
                                }
                            }, new Response.ErrorListener() {
                        @Override
                        public void onErrorResponse(VolleyError error) {
                            Log.e("TAG", error.getMessage(), error);
                        }
                    });
                    requestQueue.add(gsonRequest);
                }
            });
    

    同样需要定义一个GsonRequest继承Request
    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 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);
        }
    }
    
    
    //用于解析的类
    class Weather {
    
        private WeatherInfo weatherinfo;
    
        public WeatherInfo getWeatherinfo() {
            return weatherinfo;
        }
    
        public void setWeatherinfo(WeatherInfo weatherinfo) {
            this.weatherinfo = weatherinfo;
        }
    
    }
    

    还需要一个WeatherInfo类来解析Gson
    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;
        }
    }
    


    四、原理

    首先来梳理一下整体的流程,先建立也队列,根据不同的系统版本建立不同的网络初始化,接下来在这个队列 中建立一个缓存进程和四个网络进程,一共是五个进程,然后在就是往这个队列中添加任务来。如果得到的请求有缓存资源就可以进行通过缓存线程执行任务了,如果没有缓存就加入到网路线程任务中,处理完成后将response发送出去,我们在回调函数中就可以得到结果了。

    (一)队列创建

    (1)网络的选择,是选择HttpStack还是HttpClientStack

        public static RequestQueue newRequestQueue(Context context, HttpStack stack) {  
            File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);  
            String userAgent = "volley/0";  
            try {  
                String packageName = context.getPackageName();  
                PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);  
                userAgent = packageName + "/" + info.versionCode;  
            } catch (NameNotFoundException e) {  
            }  
            if (stack == null) {  
                if (Build.VERSION.SDK_INT >= 9) {  
                    stack = new HurlStack();  
                } else {  
                    stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));  
                }  
            }  
            Network network = new BasicNetwork(stack);  
            RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);  
            queue.start();  
            return queue;  
        }  


    (2)建立一个缓存线程和四个网络线程

    
        public void start() {  
            stop();  // Make sure any currently running dispatchers are stopped.  
            // Create the cache dispatcher and start it.  
            mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);  
            mCacheDispatcher.start();  
            // Create network dispatchers (and corresponding threads) up to the pool size.  
            for (int i = 0; i < mDispatchers.length; i++) {  
                NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,  
                        mCache, mDelivery);  
                mDispatchers[i] = networkDispatcher;  
                networkDispatcher.start();  
            }  
        }  


    (二)增加请求


    (1)加入队列中

        public <T> Request<T> add(Request<T> request) {  
            // Tag the request as belonging to this queue and add it to the set of current requests.  
            request.setRequestQueue(this);  
            synchronized (mCurrentRequests) {  
                mCurrentRequests.add(request);  
            }  
            // Process requests in the order they are added.  
            request.setSequence(getSequenceNumber());  
            request.addMarker("add-to-queue");  
            // If the request is uncacheable, skip the cache queue and go straight to the network.  
            if (!request.shouldCache()) {  
                mNetworkQueue.add(request);  
                return request;  
            }  
            // Insert request into stage if there's already a request with the same cache key in flight.  
            synchronized (mWaitingRequests) {  
                String cacheKey = request.getCacheKey();  
                if (mWaitingRequests.containsKey(cacheKey)) {  
                    // There is already a request in flight. Queue up.  
                    Queue<Request<?>> stagedRequests = mWaitingRequests.get(cacheKey);  
                    if (stagedRequests == null) {  
                        stagedRequests = new LinkedList<Request<?>>();  
                    }  
                    stagedRequests.add(request);  
                    mWaitingRequests.put(cacheKey, stagedRequests);  
                    if (VolleyLog.DEBUG) {  
                        VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);  
                    }  
                } else {  
                    // Insert 'null' queue for this cacheKey, indicating there is now a request in  
                    // flight.  
                    mWaitingRequests.put(cacheKey, null);  
                    mCacheQueue.add(request);  
                }  
                return request;  
            }  
        }  

    (2)通过while循环的方式进行相应,如果缓存为空就加入到网络线程中

        public class CacheDispatcher extends Thread {  
          
            ……  
          
            @Override  
            public void run() {  
                if (DEBUG) VolleyLog.v("start new dispatcher");  
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
                // Make a blocking call to initialize the cache.  
                mCache.initialize();  
                while (true) {  
                    try {  
                        // Get a request from the cache triage queue, blocking until  
                        // at least one is available.  
                        final Request<?> request = mCacheQueue.take();  
                        request.addMarker("cache-queue-take");  
                        // If the request has been canceled, don't bother dispatching it.  
                        if (request.isCanceled()) {  
                            request.finish("cache-discard-canceled");  
                            continue;  
                        }  
                        // Attempt to retrieve this item from cache.  
                        Cache.Entry entry = mCache.get(request.getCacheKey());  
                        if (entry == null) {  
                            request.addMarker("cache-miss");  
                            // Cache miss; send off to the network dispatcher.  
                            mNetworkQueue.put(request);  
                            continue;  
                        }  
                        // If it is completely expired, just send it to the network.  
                        if (entry.isExpired()) {  
                            request.addMarker("cache-hit-expired");  
                            request.setCacheEntry(entry);  
                            mNetworkQueue.put(request);  
                            continue;  
                        }  
                        // We have a cache hit; parse its data for delivery back to the request.  
                        request.addMarker("cache-hit");  
                        Response<?> response = request.parseNetworkResponse(  
                                new NetworkResponse(entry.data, entry.responseHeaders));  
                        request.addMarker("cache-hit-parsed");  
                        if (!entry.refreshNeeded()) {  
                            // Completely unexpired cache hit. Just deliver the response.  
                            mDelivery.postResponse(request, response);  
                        } else {  
                            // Soft-expired cache hit. We can deliver the cached response,  
                            // but we need to also send the request to the network for  
                            // refreshing.  
                            request.addMarker("cache-hit-refresh-needed");  
                            request.setCacheEntry(entry);  
                            // Mark the response as intermediate.  
                            response.intermediate = true;  
                            // Post the intermediate response back to the user and have  
                            // the delivery then forward the request along to the network.  
                            mDelivery.postResponse(request, response, new Runnable() {  
                                @Override  
                                public void run() {  
                                    try {  
                                        mNetworkQueue.put(request);  
                                    } catch (InterruptedException e) {  
                                        // Not much we can do about this.  
                                    }  
                                }  
                            });  
                        }  
                    } catch (InterruptedException e) {  
                        // We may have been interrupted because it was time to quit.  
                        if (mQuit) {  
                            return;  
                        }  
                        continue;  
                    }  
                }  
            }  
        }  

    (3)最后进行事件的分发





    尊重作者,尊重原创,参考文章:


    http://blog.csdn.net/guolin_blog/article/details/17656437

    http://www.cnblogs.com/zyw-205520/p/4950357.html



















    展开全文
  • 过去在Android上网络通信都是使用... 这里我先分析下Volley框架的简单网络请求的源码。 使用Volley请求网络数据的简单过程: RequestQueue queue = Volley.newRequestQueue(this); //实例化一个请求队列 Google推荐写
  • volley框架学习

    2020-05-11 11:43:41
    需求场景:用户网络不好或者流量用完的时候,原生volley框架会抛一个com.android.volley.TimeoutError的异常错误,虽然这是这是正常的,但是有两个问题: 1.我们使用bugly检测,bugly上捕获到了这种错误,会影响我们...
  • volley框架简单使用demo。 volley框架简单使用demo。 volley框架简单使用demo。
  • volley框架介绍

    2016-08-11 23:37:19
    volley框架介绍
  • 主要为大家详细介绍了Android Volley框架使用方法,从网络请求和图片加载两大方面进行分析,感兴趣的小伙伴们可以参考一下
  • Android Volley框架详细

    千次阅读 多人点赞 2018-08-22 09:53:33
    一、理清思路 篇 先来一张关于Volley的思维导图 Volley,它适用于数据请求...首先,要使用Volley框架解析网络json数据,那么就要先进行导入相应的依赖 在Modle中德build.gradle中导入 compile 'com.mcxiaoke.vol...
  • 使用Volley框架

    2017-11-29 14:11:55
    为什么要使用Volley框架   开发android应用很多时候都要涉及网络操作,Android SDK中提供了HttpClient 和 HttpUrlConnection两种方式用来处理网络操作,但当应用比较复杂的时候需要我们编写大量的代码处理...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,289
精华内容 1,715
关键字:

volley框架