Volley网络请求框架

最新推荐文章于 2021-05-27 08:35:56 发布

苏白2016

最新推荐文章于 2021-05-27 08:35:56 发布

阅读量523

点赞数

CC 4.0 BY-SA版权

分类专栏：三方开源框架

本文链接：https://blog.youkuaiyun.com/kakaxi1o1/article/details/51592825

三方开源框架专栏收录该内容

35 篇文章

订阅专栏

本文详细解析了Volley网络请求的实现过程，包括其内部结构、网络请求的交互层及HttpURLConnection封装等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

接上一章来讲网络请求的大体过程，Volley是如何封装并使用HttpURLConnection和HttpClient的。

网络请求的基本逻辑

网络请求的交互层—>BasicNetwork

封装HttpURLConnection实现网络连接

RequestQueue.java

从通过Volley我们能学到什么?(1) — 工作原理与设计模式的NetworkDispatcher.java中的调用网络请求开始讲起。。

[java]view plaincopy 
    
 NetworkResponse networkResponse = mNetwork.performRequest(request);  

Volley中网络请求一共分为三层，大体结构如下：

1、NetworkDispatcher获取Request对象并分发给BasicNetwork；

2、BasicNetwork得到Request对象后，配置头文件等配置信息分发给HttpStack;

3、HttpStack得到Request对象和配置信息后进行真正的网络请求；

4、HttpStack将网络请求的结果返回给BasicNetwork；

5、BasicNetwork得到返回结果，如果成功则返回给NetworkDispatcher，否则处理其他异常情况；

第一层NetworkDispatcher已讲完，这篇主要讲第二层(BasicNetwork)和第三层(HttpStack)。

网络请求的交互层 —>BasicNetwork

BasicNetwork.java

这一行代码直接调用的是BasicNetwork.java中的performRequest()方法

[java]view plaincopy 
     
 public NetworkResponse performRequest(Request<?> request) throws VolleyError {  
     long requestStart = SystemClock.elapsedRealtime();  
     while (true) {  
         HttpResponse httpResponse = null;  
         byte[] responseContents = null;  
         Map<String, String> responseHeaders = Collections.emptyMap();  
         try {  
             // Gather headers.  
             Map<String, String> headers = new HashMap<String, String>();  
             addCacheHeaders(headers, request.getCacheEntry());  
             httpResponse = mHttpStack.performRequest(request, headers);  
             StatusLine statusLine = httpResponse.getStatusLine();  
             int statusCode = statusLine.getStatusCode();  
             responseHeaders = convertHeaders(httpResponse.getAllHeaders());  
             // Handle cache validation.  
             if (statusCode == HttpStatus.SC_NOT_MODIFIED) {  
                 Entry entry = request.getCacheEntry();  
                 if (entry == null) {  
                     return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,  
                             responseHeaders, true,  
                             SystemClock.elapsedRealtime() - requestStart);  
                 }  
                 // A HTTP 304 response does not have all header fields. We  
                 // have to use the header fields from the cache entry plus  
                 // the new ones from the response.  
                 // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5  
                 entry.responseHeaders.putAll(responseHeaders);  
                 return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,  
                         entry.responseHeaders, true,  
                         SystemClock.elapsedRealtime() - requestStart);  
             }  
   
             // Some responses such as 204s do not have content.  We must check.  
             if (httpResponse.getEntity() != null) {  
               responseContents = entityToBytes(httpResponse.getEntity());  
             } else {  
               // Add 0 byte response as a way of honestly representing a  
               // no-content request.  
               responseContents = new byte[0];  
             }  
   
             // if the request is slow, log it.  
             long requestLifetime = SystemClock.elapsedRealtime() - requestStart;  
             logSlowRequests(requestLifetime, request, responseContents, statusLine);  
   
             if (statusCode < 200 || statusCode > 299) {  
                 throw new IOException();  
             }  
             return new NetworkResponse(statusCode, responseContents, responseHeaders, false,  
                     SystemClock.elapsedRealtime() - requestStart);  
         } catch (SocketTimeoutException e) {  
             attemptRetryOnException("socket", request, new TimeoutError());  
         } catch (ConnectTimeoutException e) {  
             attemptRetryOnException("connection", request, new TimeoutError());  
         } catch (MalformedURLException e) {  
             throw new RuntimeException("Bad URL " + request.getUrl(), e);  
         } catch (IOException e) {  
             int statusCode = 0;  
             NetworkResponse networkResponse = null;  
             if (httpResponse != null) {  
                 statusCode = httpResponse.getStatusLine().getStatusCode();  
             } else {  
                 throw new NoConnectionError(e);  
             }  
             VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());  
             if (responseContents != null) {  
                 networkResponse = new NetworkResponse(statusCode, responseContents,  
                         responseHeaders, false, SystemClock.elapsedRealtime() - requestStart);  
                 if (statusCode == HttpStatus.SC_UNAUTHORIZED ||  
                         statusCode == HttpStatus.SC_FORBIDDEN) {  
                     attemptRetryOnException("auth",  
                         request, new AuthFailureError(networkResponse));  
                 } else {  
                     // TODO: Only throw ServerError for 5xx status codes.  
                     throw new ServerError(networkResponse);  
                 }  
             } else {  
                 throw new NetworkError(networkResponse);  
             }  
         }  
     }  
 }  

1、首先创建循环机制，使请求失败可以再次请求(3行)；

2、添加头部信息(9 - 10行)；

3、调用HttpStack对象进行网络请求，进入网络请求的第三层(11行)；

4、获取请求结果的状态(12 - 13行)；

5、更新头部信息(14行)；

6、如果获取的状态行是304则说明之前已获取过数据且服务器未做修改，直接返回上次请求的数据(16 - 32行)；

7、将数据内容写入到responseContents里(35 - 41行)；

8、请求完成，如果访问总时长超过3秒将访问的详细信息打印出来(44 - 45行)；

9、如果状态码返回是异常，报IO异常，跳转到下面的catch中(47 - 49)；

10、如果是连接异常则重新连接(53、55行)；

11、如果超时，则跳出循环向上抛异常，超时时间最大值可设置(56行)；

12、处理IO异常，如果是因为访问无权限或禁止访问这种认证问题，可以再给一次机会，否则直接抛异常(59 - 80行)；

多次网络请求机制

BasicNetwork.java

接下来我们来看一下Volley多次访问逻辑，入口为attemptRetryOnException()方法。

[java]view plaincopy 
     
 private static void attemptRetryOnException(String logPrefix, Request<?> request,  
             VolleyError exception) throws VolleyError {  
         RetryPolicy retryPolicy = request.getRetryPolicy();  
         int oldTimeout = request.getTimeoutMs();  
   
         try {  
             retryPolicy.retry(exception);  
         } catch (VolleyError e) {  
             request.addMarker(  
                     String.format("%s-timeout-giveup [timeout=%s]", logPrefix, oldTimeout));  
             throw e;  
         }  
         request.addMarker(String.format("%s-retry [timeout=%s]", logPrefix, oldTimeout));  
     }  

1、获取Request对象里面的RetryPolicy对象，并获取超时时间(3 - 4行)；

2、调用RetryPolicy对象的retry()方法来检测是否需要重新访问(7行)；

向下看retry()的源码

DefaultRetryPolicy.java

[java]view plaincopy 
     
 public void retry(VolleyError error) throws VolleyError {  
     mCurrentRetryCount++;  
     mCurrentTimeoutMs += (mCurrentTimeoutMs * mBackoffMultiplier);  
     if (!hasAttemptRemaining()) {  
         throw error;  
     }  
 }  

1、重新访问次数加一(2行)；

2、累加超时时间(3行)；

3、判断重新访问次数是否大于最大访问次数(默认是1，可自定义)，大于最大值报异常跳出循环(4行)；

封装HttpURLConnection实现网络连接(HttpClient暂不整理)

如果是Android2.3即以上版本调用上面HttpStack对象的performRequest()方法的会映射到HurlStack类里面的performRequest()方法来实现网络连接。

HurlStack.java

[java]view plaincopy 
     
 public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)  
             throws IOException, AuthFailureError {  
         String url = request.getUrl();  
         HashMap<String, String> map = new HashMap<String, String>();  
         map.putAll(request.getHeaders());  
         map.putAll(additionalHeaders);  
         if (mUrlRewriter != null) {  
             String rewritten = mUrlRewriter.rewriteUrl(url);  
             if (rewritten == null) {  
                 throw new IOException("URL blocked by rewriter: " + url);  
             }  
             url = rewritten;  
         }  
         URL parsedUrl = new URL(url);  
         HttpURLConnection connection = openConnection(parsedUrl, request);  
         for (String headerName : map.keySet()) {  
             connection.addRequestProperty(headerName, map.get(headerName));  
         }  
         setConnectionParametersForRequest(connection, request);  
         // Initialize HttpResponse with data from the HttpURLConnection.  
         ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);  
         int responseCode = 0;  
         try {  
             responseCode = connection.getResponseCode();  
         } catch (IOException e) {  
             connection.getErrorStream();  
             responseCode = connection.getResponseCode();  
         }  
   
         if (responseCode == -1) {  
             // -1 is returned by getResponseCode() if the response code could not be retrieved.  
             // Signal to the caller that something was wrong with the connection.  
             throw new IOException("Could not retrieve response code from HttpUrlConnection.");  
         }  
         StatusLine responseStatus = new BasicStatusLine(protocolVersion,  
                 connection.getResponseCode(), connection.getResponseMessage());  
         BasicHttpResponse response = new BasicHttpResponse(responseStatus);  
         response.setEntity(entityFromConnection(connection));  
         for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {  
             if (header.getKey() != null) {  
                 Header h = new BasicHeader(header.getKey(), header.getValue().get(0));  
                 response.addHeader(h);  
             }  
         }  
         return response;  