Volley框架 以及 设置request超时时间

最新推荐文章于 2024-09-11 14:17:21 发布
最新推荐文章于 2024-09-11 14:17:21 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 【Android 进阶】 文章标签： 框架 线程 网络 android volley

Volley提供了优美的框架，使android程序网络访问更容易、更快。

Volley抽象实现了底层的HTTP Client库，我们不需关注HTTP Client细节，专注于写出更加漂亮、干净的RESTful HTTP请求。

Volley请求会异步执行，不阻挡主线程。

Volley提供的功能

  1. 封装了异步的RESTful请求API
  2. 一个优雅and稳健的请求队列
  3. 一个可扩展的架构，使开发者能实现自定义的请求和响应处理机制
  4. 能使用外部Http Client库
  5. 缓存策略
  6. 自定义的网络图像加载视图（NetworkImageView，ImageLoader等）

为什么使用异步Http请求

Android中要求HTTP请求异步执行，如果在主线程执行HTTP请求，可能会抛出 android.os.NetworkOnMainThreadException  异常。阻塞主线程有一些严重的后果，它阻碍UI渲染，用户体验不流 畅，它可能会导致可怕的ANR（Application Not Responding）。要避免这些陷阱，作为一个开发者，应该始终确保HTTP请求是在一个不同的线程

怎样使用Volley

 

1、安装和使用Volley库

 

2、使用请求队列

 

3、异步的JSON、String请求

 

4、取消请求

 

5、重试失败的请求，自定义请求超时

 

6、设置请求头（HTTP headers）

 

7、使用Cookies

 

8、错误处理

1.安装和使用Volley库

引入Volley非常简单，首先，从git库先克隆一个下来：

git clone https://android.googlesource.com/platform/frameworks/volley

然后编译为jar包，再把jar包放到自己的工程的libs目录。

 

2.使用请求队列

 Volley的所有请求都放在一个队列，然后进行处理，这里是你如何将创建一个请求队列：

 RequestQueue mRequestQueue = Volley.newRequestQueue(this); // 'this' is Context

 

 理想的情况是把请求队列集中放到一个地方，最好是初始化应用程序类中初始化请求队列，下面类做到了这一点：

 

复制代码 
public class ApplicationController extends Application {

    /**
     * Log or request TAG
     */
    public static final String TAG = "VolleyPatterns";

    /**
     * Global request queue for Volley
     */
    private RequestQueue mRequestQueue;

    /**
     * A singleton instance of the application class for easy access in other places
     */
    private static ApplicationController sInstance;

    @Override
    public void onCreate() {
        super.onCreate();

        // initialize the singleton
        sInstance = this;
    }

    /**
     * @return ApplicationController singleton instance
     */
    public static synchronized ApplicationController getInstance() {
        return sInstance;
    }

    /**
     * @return The Volley Request queue, the queue will be created if it is null
     */
    public RequestQueue getRequestQueue() {
        // lazy initialize the request queue, the queue instance will be
        // created when it is accessed for the first time
        if (mRequestQueue == null) {
            mRequestQueue = Volley.newRequestQueue(getApplicationContext());
        }

        return mRequestQueue;
    }

    /**
     * Adds the specified request to the global queue, if tag is specified
     * then it is used else Default TAG is used.
     * 
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req, String tag) {
        // set the default tag if tag is empty
        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        VolleyLog.d("Adding request to queue: %s", req.getUrl());

        getRequestQueue().add(req);
    }

    /**
     * Adds the specified request to the global queue using the Default TAG.
     * 
     * @param req
     * @param tag
     */
    public <T> void addToRequestQueue(Request<T> req) {
        // set the default tag if tag is empty
        req.setTag(TAG);

        getRequestQueue().add(req);
    }

    /**
     * Cancels all pending requests by the specified TAG, it is important
     * to specify a TAG so that the pending/ongoing requests can be cancelled.
     * 
     * @param tag
     */
    public void cancelPendingRequests(Object tag) {
        if (mRequestQueue != null) {
            mRequestQueue.cancelAll(tag);
        }
    }
}
复制代码

 

3.异步的JSON、String请求

Volley提供了以下的实用工具类进行异步HTTP请求：

JsonObjectRequest — To send and receive JSON Object from the Server

JsonArrayRequest — To receive JSON Array from the Server

StringRequest — To retrieve response body as String (ideally if you intend to parse the response by yourself)

JsonObjectRequest

这个类可以用来发送和接收JSON对象。这个类的一个重载构造函数允许设置适当的请求方法（DELETE，GET，POST和PUT）。如果您正在使用一个RESTful服务端，可以使用这个类。下面的示例显示如何使GET和POST请求

 GET请求：

复制代码 
final String URL = "/volley/resource/12";
// pass second argument as "null" for GET requests
JsonObjectRequest req = new JsonObjectRequest(URL, null,
       new Response.Listener<JSONObject>() {
           @Override
           public void onResponse(JSONObject response) {
               try {
                   VolleyLog.v("Response:%n %s", response.toString(4));
               } catch (JSONException e) {
                   e.printStackTrace();
               }
           }
       }, new Response.ErrorListener() {
           @Override
           public void onErrorResponse(VolleyError error) {
               VolleyLog.e("Error: ", error.getMessage());
           }
       });

// add the request object to the queue to be executed
ApplicationController.getInstance().addToRequestQueue(req);
复制代码

 

 POST请求：

 

复制代码 
final String URL = "/volley/resource/12";
// Post params to be sent to the server
HashMap<String, String> params = new HashMap<String, String>();
params.put("token", "AbCdEfGh123456");

JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),
       new Response.Listener<JSONObject>() {
           @Override
           public void onResponse(JSONObject response) {
               try {
                   VolleyLog.v("Response:%n %s", response.toString(4));
               } catch (JSONException e) {
                   e.printStackTrace();
               }
           }
       }, new Response.ErrorListener() {
           @Override
           public void onErrorResponse(VolleyError error) {
               VolleyLog.e("Error: ", error.getMessage());
           }
       });

// add the request object to the queue to be executed
ApplicationController.getInstance().addToRequestQueue(req);
复制代码

 

 

 

 

JsonArrayRequest

这个类可以用来接受 JSON Arrary，不支持JSON Object。这个类现在只支持 HTTP GET。由于支持GET，你可以在URL的后面加上请求参数。类的构造函数不支持请求参数

复制代码 
final String URL = "/volley/resource/all?count=20";
JsonArrayRequest req = new JsonArrayRequest(URL, new Response.Listener<JSONArray> () {
    @Override
    public void onResponse(JSONArray response) {
        try {
            VolleyLog.v("Response:%n %s", response.toString(4));
        } catch (JSONException e) {
            e.printStackTrace();
        }
    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        VolleyLog.e("Error: ", error.getMessage());
    }
});

// add the request object to the queue to be executed
ApplicationController.getInstance().addToRequestQueue(req);
复制代码

 

 

StringRequest

这个类可以用来从服务器获取String，如果想自己解析请求响应可以使用这个类，例如返回xml数据。它还可以使用重载的构造函数定制请求

复制代码 
final String URL = "/volley/resource/recent.xml";
StringRequest req = new StringRequest(URL, new Response.Listener<String>() {
    @Override
    public void onResponse(String response) {
        VolleyLog.v("Response:%n %s", response);
    }
}, new Response.ErrorListener() {
    @Override
    public void onErrorResponse(VolleyError error) {
        VolleyLog.e("Error: ", error.getMessage());
    }
});

// add the request object to the queue to be executed
ApplicationController.getInstance().addToRequestQueue(req);
复制代码

 

4.取消请求

Volley提供了强大的API取消未处理或正在处理的请求。取消请求最简单的方法是调用请求队列cancelAll（tag）的方法，前提是你在添加请求时设置了标记。这样就能使标签标记的请求挂起。

给请求设置标签：

request.setTag("My Tag");

使用ApplicationController添加使用了标签的请求到队列中：

ApplicationController.getInstance().addToRequestQueue(request, "My Tag");

取消所有指定标记的请求：

mRequestQueue.cancelAll("My Tag");

5.重试失败的请求，自定义请求超时

Volley中没有指定的方法来设置请求超时时间，可以设置RetryPolicy 来变通实现。DefaultRetryPolicy类有个initialTimeout参数，可以设置超时时间。要确保最大重试次数为1，以保证超时后不重新请求。

Setting Request Timeout

request.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));

设置请求头（HTTP headers）        如果你想失败后重新请求（因超时），您可以指定使用上面的代码，增加重试次数。注意最后一个参数，它允许你指定一个退避乘数可以用来实现“指数退避”来从RESTful服务器请求数据。

有时候需要给HTTP请求添加额外的头信息，一个常用的例子是添加 “Authorization”到HTTP 请求的头信息。Volley请求类提供了一个 getHeaers（）的方法，重载这个方法可以自定义HTTP 的头信息。

添加头信息：

复制代码 
JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),
           new Response.Listener<JSONObject>() {
               @Override
               public void onResponse(JSONObject response) {
                   // handle response
               }
           }, new Response.ErrorListener() {
               @Override
               public void onErrorResponse(VolleyError error) {
                   // handle error                        
               }
           }) {

       @Override
       public Map<String, String> getHeaders() throws AuthFailureError {
           HashMap<String, String> headers = new HashMap<String, String>();
           headers.put("CUSTOM_HEADER", "Yahoo");
           headers.put("ANOTHER_CUSTOM_HEADER", "Google");
           return headers;
       }
   };
复制代码

 

 

6.使用Cookies

Volley中没有直接的API来设置cookies，Volley的设计理念就是提供干净、简洁的API来实现RESTful HTTP请求，不提供设置cookies是合理的。

下面是修改后的ApplicationController类，这个类修改了getRequestQueue()方法，包含了 设置cookie方法，这些修改还是有些粗糙

复制代码 
// http client instance
private DefaultHttpClient mHttpClient;
public RequestQueue getRequestQueue() {
    // lazy initialize the request queue, the queue instance will be
    // created when it is accessed for the first time
    if (mRequestQueue == null) {
        // Create an instance of the Http client. 
        // We need this in order to access the cookie store
        mHttpClient = new DefaultHttpClient();
        // create the request queue
        mRequestQueue = Volley.newRequestQueue(this, new HttpClientStack(mHttpClient));
    }
    return mRequestQueue;
}

/**
 * Method to set a cookie
 */
public void setCookie() {
    CookieStore cs = mHttpClient.getCookieStore();
    // create a cookie
    cs.addCookie(new BasicClientCookie2("cookie", "spooky"));
}


// add the cookie before adding the request to the queue
setCookie();

// add the request to the queue
mRequestQueue.add(request);
复制代码

 

7.错误处理

正如前面代码看到的，在创建一个请求时，需要添加一个错误监听onErrorResponse。如果请求发生异常，会返回一个VolleyError实例。

以下是Volley的异常列表：

AuthFailureError：如果在做一个HTTP的身份验证，可能会发生这个错误。

NetworkError：Socket关闭，服务器宕机，DNS错误都会产生这个错误。

NoConnectionError：和NetworkError类似，这个是客户端没有网络连接。

ParseError：在使用JsonObjectRequest或JsonArrayRequest时，如果接收到的JSON是畸形，会产生异常。

SERVERERROR：服务器的响应的一个错误，最有可能的4xx或5xx HTTP状态代码。

TimeoutError：Socket超时，服务器太忙或网络延迟会产生这个异常。默认情况下，Volley的超时时间为2.5秒。如果得到这个错误可以使用RetryPolicy。

可以使用一个简单的Help类根据这些异常提示相应的信息：

复制代码 
public class VolleyErrorHelper {
     /**
     * Returns appropriate message which is to be displayed to the user 
     * against the specified error object.
     * 
     * @param error
     * @param context
     * @return
     */
  public static String getMessage(Object error, Context context) {
      if (error instanceof TimeoutError) {
          return context.getResources().getString(R.string.generic_server_down);
      }
      else if (isServerProblem(error)) {
          return handleServerError(error, context);
      }
      else if (isNetworkProblem(error)) {
          return context.getResources().getString(R.string.no_internet);
      }
      return context.getResources().getString(R.string.generic_error);
  }
  
  /**
  * Determines whether the error is related to network
  * @param error
  * @return
  */
  private static boolean isNetworkProblem(Object error) {
      return (error instanceof NetworkError) || (error instanceof NoConnectionError);
  }
  /**
  * Determines whether the error is related to server
  * @param error
  * @return
  */
  private static boolean isServerProblem(Object error) {
      return (error instanceof ServerError) || (error instanceof AuthFailureError);
  }
  /**
  * Handles the server error, tries to determine whether to show a stock message or to 
  * show a message retrieved from the server.
  * 
  * @param err
  * @param context
  * @return
  */
  private static String handleServerError(Object err, Context context) {
      VolleyError error = (VolleyError) err;
  
      NetworkResponse response = error.networkResponse;
  
      if (response != null) {
          switch (response.statusCode) {
            case 404:
            case 422:
            case 401:
                try {
                    // server might return error like this { "error": "Some error occured" }
                    // Use "Gson" to parse the result
                    HashMap<String, String> result = new Gson().fromJson(new String(response.data),
                            new TypeToken<Map<String, String>>() {
                            }.getType());

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

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

            default:
                return context.getResources().getString(R.string.generic_server_down);
            }
      }
        return context.getResources().getString(R.string.generic_error);
  }
}
复制代码

 

总结：

Volley是一个非常好的库，你可以尝试使用一下，它会帮助你简化网络请求，带来更多的益处。

我也希望更加全面的介绍Volley，以后可能会介绍使用volley加载图像的内容，欢迎关注

徐昊Xiho
关注
专栏目录
Volley修改超时时间和请求头源码
05-08
volley修改了请求头和请求的超时时间防止多次调用的问题。
Volley框架
03-07
Volley框架包含以下几个主要组件： 1. **RequestQueue**：这是Volley的入口点，负责管理和调度所有的网络请求。RequestQueue会根据请求的优先级对它们进行排序，并在适当的线程上执行。 2. **NetworkDispatcher**...
requests请求设置超时时间python
最新发布
NLP与推荐算法
09-11 754
要使用Python的requests库来发送一个HTTP请求，并且设置一个超时时间，使得如果请求在指定时间内未得到响应，则直接放弃请求并抛出异常，可以使用requests库中的timeout参数来实现。3. 发送请求：使用requests.get方法发送GET请求，并通过timeout参数设置请求的超时时间为10秒。• 如果请求的URL是一个较慢响应的服务器，那么在10秒之内没有返回的情况下，程序会立即进入requests.exceptions.Timeout异常处理部分，并输出相应的信息。
【开源项目13】Volley框架 以及 设置request超时时间
birthmarkqiqi的专栏
03-28 530
Volley提供了优美的框架，使android程序网络访问更容易、更快。 Volley抽象实现了底层的HTTP Client库，我们不需关注HTTP Client细节，专注于写出更加漂亮、干净的RESTful HTTP请求。 Volley请求会异步执行，不阻挡主线程。 Volley提供的功能 封装了异步的RESTful请求API一个优雅and稳健的请求队列一个可扩展的架构，
修改volley默认超时时间以及重连次数
u013680097的博客
12-31 1363
转自：http://blog.csdn.net/lonewolf521125/article/details/45477187 See com.android.volley.Request.setRetryPolicy() and the constructor for DefaultRetryPolicy, e.g.  代码如下： myRequest
android volley 超时,修改volley默认超时时间以及重连次数
weixin_39940688的博客
05-27 443
See com.android.volley.Request.setRetryPolicy() and the constructor for DefaultRetryPolicy, e.g.代码如下：myRequest.setRetryPolicy(new DefaultRetryPolicy(MY_SOCKET_TIMEOUT_MS,DefaultRetryPolicy.DEFAULT_MAX...
Volley框架的常用方法
05-24
在本文中，我们将深入探讨Volley框架的常用方法及其在Android开发中的应用场景。 1. **初始化Volley** 要使用Volley，首先需要在Application或Activity中创建一个RequestQueue实例。这通常通过` Volley....
Volley框架源码
10-26
在Volley框架中，主要有以下几个关键组件： 1. **RequestQueue**：这是Volley的核心组件，负责管理所有的网络请求。它维护了一个线程池，用于执行网络请求，并使用一个优先级队列来决定下一个要执行的请求。...
AndroidVolley框架使用源代码
03-01
这个压缩包文件 "Android_Volley" 很可能包含了Volley框架的源代码，使得开发者可以深入理解其内部机制，优化自定义的网络请求。 Volley 的主要特性包括： 1. **缓存策略**：Volley 提供了内存和磁盘两级缓存，...
python requests设置连接超时时间
人生苦短，何妨一试
05-19 3974
【代码】python requests设置连接超时时间。
python接口自动化20-requests获取响应时间(elapsed)与超时（timeout）
weixin_34186950的博客
12-13 1641
前言 requests发请求时，接口的响应时间，也是我们需要关注的一个点，如果响应时间太长，也是不合理的。 如果服务端没及时响应，也不能一直等着，可以设置一个timeout超时的时间 关于requests请求的响应时间，官网上没太多介绍，并且我百度搜了下，看很多资料写的是r.elapsed.microseconds获取的，然而都是错的！！！ elapsed官方文档 elapsed方法的官方文档地...
利用volley进行http设置请求头、超时及请求参数设置(post)
happyrabbit456的专栏
05-14 1448
这里以post请求说明，get请求相似设置请求头及超时。 1.自定义request，继承com.android.volley.Request 2.构造方法实现（basecallback,为自定义的监听，实现Response.Listener,ErrorListener接口）--post请求 public BaseRequest(String url,String para
requests 超时设置
热门推荐
wo446100076的专栏
12-12 1万+
一、超时 可以告诉 requests 在经过以 timeout 参数设定的秒数时间之后停止等待响应。 连接超时指的是在你的客户端实现到远端机器端口的连接时Request 会等待的秒数。一个很好的实践方法是把连接超时设为比 3 的倍数略大的一个数值，因为 TCP 数据包重传窗口 (TCP packet retransmission window) 的默认大小是 3 r = requests.get...
【某机构vip教程】Requests(6)：Requests模块_超时设置
02-23 1175
2023最新自动化测试自学教程新手小白26天入门最详细教程,目前已有300多人通过学习这套教程入职大厂！！_哔哩哔哩_bilibili2023最新合集Python自动化测试开发框架【全栈/实战/教程】合集精华，学完年薪40W+_哔哩哔哩_bilibili​​​​​​也方便你下次能够快速查找。如有不懂还要咨询下方小卡片，博主也希望和志同道合的测试人员一起学习进步在适当的年龄，选择适当的岗位，尽量去发挥好自己的优势。我的自动化测试开发之路，一路走来都离不每个阶段的计划，因为自己喜欢规划和总结，
Android Volley框架详解与源码深度剖析
此外，Volley框架还包括了ImageLoader用于图片加载，以及更复杂的请求如JsonArrayRequest和JsonObjectRequest，它们分别用于处理JSON数组和对象。Volley还支持自定义网络层，允许开发者扩展其行为，例如处理长连接、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值