[Android]Volley源码分析（四）

 1  @Override
 2     public NetworkResponse performRequest(Request<?> request) throws VolleyError {
 3         long requestStart = SystemClock.elapsedRealtime();
 4         while (true) {
 5             HttpResponse httpResponse = null;
 6             byte[] responseContents = null;
 7             Map<String, String> responseHeaders = new HashMap<String, String>();
 8             try {
 9                 // Gather headers.
10                 Map<String, String> headers = new HashMap<String, String>();
11                 addCacheHeaders(headers, request.getCacheEntry());
12                 httpResponse = mHttpStack.performRequest(request, headers);
13                 StatusLine statusLine = httpResponse.getStatusLine();
14                 int statusCode = statusLine.getStatusCode();
15 
16                 responseHeaders = convertHeaders(httpResponse.getAllHeaders());
17                 // Handle cache validation.
18                 if (statusCode == HttpStatus.SC_NOT_MODIFIED) {
19                     return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
20                             request.getCacheEntry() == null ? null : request.getCacheEntry().data,
21                             responseHeaders, true);
22                 }
23 
24                 // Some responses such as 204s do not have content.  We must check.
25                 if (httpResponse.getEntity() != null) {
26                   responseContents = entityToBytes(httpResponse.getEntity());
27                 } else {
28                   // Add 0 byte response as a way of honestly representing a
29                   // no-content request.
30                   responseContents = new byte[0];
31                 }
32 
33                 // if the request is slow, log it.
34                 long requestLifetime = SystemClock.elapsedRealtime() - requestStart;
35                 logSlowRequests(requestLifetime, request, responseContents, statusLine);
36 
37                 if (statusCode < 200 || statusCode > 299) {
38                     throw new IOException();
39                 }
40                 return new NetworkResponse(statusCode, responseContents, responseHeaders, false);
41             } 
　　　　　　　　　　　　　//一堆catch...
　　　　　　}

 1 @Override
 2     public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
 3             throws IOException, AuthFailureError {
 4         HttpUriRequest httpRequest = createHttpRequest(request, additionalHeaders);
 5         addHeaders(httpRequest, additionalHeaders);
 6         addHeaders(httpRequest, request.getHeaders());
 7         onPrepareRequest(httpRequest);
 8         HttpParams httpParams = httpRequest.getParams();
 9         int timeoutMs = request.getTimeoutMs();
10         // TODO: Reevaluate this connection timeout based on more wide-scale
11         // data collection and possibly different for wifi vs. 3G.
12         HttpConnectionParams.setConnectionTimeout(httpParams, 5000);
13         HttpConnectionParams.setSoTimeout(httpParams, timeoutMs);
14         return mClient.execute(httpRequest);
15     }
16 
17     /**
18      * Creates the appropriate subclass of HttpUriRequest for passed in request.
19      */
20     @SuppressWarnings("deprecation")
21     /* protected */ static HttpUriRequest createHttpRequest(Request<?> request,
22             Map<String, String> additionalHeaders) throws AuthFailureError {
23         switch (request.getMethod()) {
24             case Method.DEPRECATED_GET_OR_POST: {
25                 // This is the deprecated way that needs to be handled for backwards compatibility.
26                 // If the request‘s post body is null, then the assumption is that the request is
27                 // GET.  Otherwise, it is assumed that the request is a POST.
28                 byte[] postBody = request.getPostBody();
29                 if (postBody != null) {
30                     HttpPost postRequest = new HttpPost(request.getUrl());
31                     postRequest.addHeader(HEADER_CONTENT_TYPE, request.getPostBodyContentType());
32                     HttpEntity entity;
33                     entity = new ByteArrayEntity(postBody);
34                     postRequest.setEntity(entity);
35                     return postRequest;
36                 } else {
37                     return new HttpGet(request.getUrl());
38                 }
39             }
40             case Method.GET:
41                 return new HttpGet(request.getUrl());
42             case Method.DELETE:
43                 return new HttpDelete(request.getUrl());
44             case Method.POST: {
45                 HttpPost postRequest = new HttpPost(request.getUrl());
46                 postRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
47                 setEntityIfNonEmptyBody(postRequest, request);
48                 return postRequest;
49             }
50             case Method.PUT: {
51                 HttpPut putRequest = new HttpPut(request.getUrl());
52                 putRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
53                 setEntityIfNonEmptyBody(putRequest, request);
54                 return putRequest;
55             }
56             case Method.HEAD:
57                 return new HttpHead(request.getUrl());
58             case Method.OPTIONS:
59                 return new HttpOptions(request.getUrl());
60             case Method.TRACE:
61                 return new HttpTrace(request.getUrl());
62             case Method.PATCH: {
63                 HttpPatch patchRequest = new HttpPatch(request.getUrl());
64                 patchRequest.addHeader(HEADER_CONTENT_TYPE, request.getBodyContentType());
65                 setEntityIfNonEmptyBody(patchRequest, request);
66                 return patchRequest;
67             }
68             default:
69                 throw new IllegalStateException("Unknown request method.");
70         }
71     }

 1 @Override
 2     public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
 3             throws IOException, AuthFailureError {
 4         String url = request.getUrl();
 5         HashMap<String, String> map = new HashMap<String, String>();
 6         map.putAll(request.getHeaders());
 7         map.putAll(additionalHeaders);
 8         if (mUrlRewriter != null) {
 9             String rewritten = mUrlRewriter.rewriteUrl(url);
10             if (rewritten == null) {
11                 throw new IOException("URL blocked by rewriter: " + url);
12             }
13             url = rewritten;
14         }
15         URL parsedUrl = new URL(url);
16         HttpURLConnection connection = openConnection(parsedUrl, request);
17         for (String headerName : map.keySet()) {
18             connection.addRequestProperty(headerName, map.get(headerName));
19         }
20         setConnectionParametersForRequest(connection, request);
21         // Initialize HttpResponse with data from the HttpURLConnection.
22         ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);
23         int responseCode = connection.getResponseCode();
24         if (responseCode == -1) {
25             // -1 is returned by getResponseCode() if the response code could not be retrieved.
26             // Signal to the caller that something was wrong with the connection.
27             throw new IOException("Could not retrieve response code from HttpUrlConnection.");
28         }
29         StatusLine responseStatus = new BasicStatusLine(protocolVersion,
30                 connection.getResponseCode(), connection.getResponseMessage());
31         BasicHttpResponse response = new BasicHttpResponse(responseStatus);
32         response.setEntity(entityFromConnection(connection));
33         for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {
34             if (header.getKey() != null) {
35                 Header h = new BasicHeader(header.getKey(), header.getValue().get(0));
36                 response.addHeader(h);
37             }
38         }
39         return response;
40     }

 1 public class Volley {
 2 
 3     /** Default on-disk cache directory. */
 4     private static final String DEFAULT_CACHE_DIR = "volley";
 5 
 6     /**
 7      * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
 8      *
 9      * @param context A {@link Context} to use for creating the cache dir.
10      * @param stack An {@link HttpStack} to use for the network, or null for default.
11      * @return A started {@link RequestQueue} instance.
12      */
13     public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
14         File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
15 
16         String userAgent = "volley/0";
17         try {
18             String packageName = context.getPackageName();
19             PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
20             userAgent = packageName + "/" + info.versionCode;
21         } catch (NameNotFoundException e) {
22         }
23 
24         if (stack == null) {
25             if (Build.VERSION.SDK_INT >= 9) {
26                 stack = new HurlStack();
27             } else {
28                 // Prior to Gingerbread, HttpUrlConnection was unreliable.
29                 // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
30                 stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
31             }
32         }
33 
34         Network network = new BasicNetwork(stack);
35 
36         RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
37         queue.start();
38 
39         return queue;
40     }
41 
42     /**
43      * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
44      *
45      * @param context A {@link Context} to use for creating the cache dir.
46      * @return A started {@link RequestQueue} instance.
47      */
48     public static RequestQueue newRequestQueue(Context context) {
49         return newRequestQueue(context, null);
50     }
51 }

1 public static void init(Context context) {
2         mRequestQueue = Volley.newRequestQueue(context);
3     }