Volley源码解析
Posted showCar
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Volley源码解析相关的知识，希望对你有一定的参考价值。
很早之前就想写下关于Volley的源码解析。一开始学android网络访问都是使用HttpClient，刚接触么Volley的时候就瞬间爱不释手，虽说现在项目中使用OkHttp多些（Volley更新慢），但是作为google自家推出的网络框架，Volley还是有很多值得学习的地方。这篇博客是我对Volley源码分析后的一个总结。
Volley的使用
Volley的使用非常简单，相信大家都很熟悉。首先需要获取到一个RequestQueue对象。
RequestQueue mQueue = Volley.newRequestQueue(context); 如果想通过网络获取json，如下：
StringRequest stringRequest = new StringRequest("http://www.baidu.com",
new Response.Listener<String>()
@Override
public void onResponse(String response)
Log.d("TAG", response);
, new Response.ErrorListener()
@Override
public void onErrorResponse(VolleyError error)
Log.e("TAG", error.getMessage(), error);
); 只要在onResponse中处理返回的response即可。如果访问出错，则会调用onErrorResonse方法。 注意Volley是异步，是在子线程中进行网络访问，而onResponse里的代码是在主线程中执行。所以使用Volley的地方切记不要把它当成单线程，这是初学者经常犯错的地方。最后，将这个StringRequest对象添加到RequestQueue里面就可以了。
mQueue.add(stringRequest); 如果要加载图片，则首先要定义一个ImageCache，用于定义图片的缓存。通过ImageLoader来加载图片,ImageListener则用于指定ImageView以及加载失败和加载过程中默认图片 ：
private final LruCache<String, Bitmap> mLruCache = new LruCache<String, Bitmap>(
(int) (Runtime.getRuntime().maxMemory() / 10))
@Override
protected int sizeOf(String key, Bitmap value)
return value.getRowBytes() * value.getHeight();
;
@Override
public void putBitmap(String url, Bitmap bitmap)
mLruCache.put(url, bitmap);
@Override
public Bitmap getBitmap(String url)
return mLruCache.get(url);
);
ImageListener listener = ImageLoader.getImageListener(imageView,
R.drawable.default, R.drawable.failed);
imageLoader.get(imageurl, listener); 介绍完简单用法之后，就来分析源代码了。
Volley源码分析
先看下官网给出的介绍图：
这里我们先有个大概的介绍，蓝色是主线程，绿色是CacheDispatcher（硬盘缓存）线程，红色是NetworkDispatcher(网络请求线程)。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。接下来详细的进行分析。
不用说，入口肯定是Volley.newRequestQueue(context)。先看下newRequestQueue的代码：
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
// Prior to Gingerbread, HttpUrlConnection was unreliable.
// See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
stack = new HttpClientStack(AndroidHttpClient. newInstance(userAgent));
Network network = new BasicNetwork(stack);
RequestQueue queue = new RequestQueue( new DiskBasedCache(cacheDir), network);
queue.start();
return queue;
首先封装得到userAgent，User-Agent 字段设置为 App 的packageName/versionCode，如果异常则使用 “volley/0”。上面代码主要是实例化stack ，如果SDK版本大于9，使用HurlStack，否则使用HttpClientStack。实际上HurlStack的内部就是使用HttpURLConnection进行网络通讯的，而HttpClientStack的内部则是使用HttpClient进行网络通讯的。也就是说android2.2以上的都是使用HttpURLConnection，否则使用HttpClient。接着new了一个RequestQueue，并调用它的start方法。来看下它的RequestQueue构造方法：
/** Number of network request dispatcher threads to start. */
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
/** Cache interface for retrieving and storing responses. */
private final Cache mCache;
/** Network interface for performing requests. */
private final Network mNetwork;
/** Response delivery mechanism. */
private final ResponseDelivery mDelivery;
/** The network dispatchers. */
private NetworkDispatcher[] mDispatchers;
public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery)
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
初始化主要就是4个参数：mCache、mNetwork、mDispatchers、mDelivery。第一个是硬盘缓存；第二个主要用于Http相关操作；第三个用于转发请求的；第四个参数用于把结果转发到UI线程,通过它来对外声明接口。接下来看下start方法。
private static final int DEFAULT_NETWORK_THREAD_POOL_SIZE = 4;
/** Cache interface for retrieving and storing responses. */
private final Cache mCache;
/** Network interface for performing requests. */
private final Network mNetwork;
/** Response delivery mechanism. */
private final ResponseDelivery mDelivery;
/** The network dispatchers. */
private NetworkDispatcher[] mDispatchers;
/**
* Starts the dispatchers in this queue.
*/
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();
/**
* Stops the cache and network dispatchers.
*/
public void stop()
if (mCacheDispatcher != null)
mCacheDispatcher.quit();
for (int i = 0; i < mDispatchers.length; i++)
if (mDispatchers[i] != null)
mDispatchers[i].quit();
首先调用stop()方法，确保此时所有转发器都处于停止状态。接下来就new了一个CacheDispatcher转发器，它其实就是一个线程，用于硬盘缓存。再new了四个NetworkDispatcher转发器，用于网络请求。并分别调用这些线程的start()方法。如果是加载图片，我们还需定义一个imageLoader，来看看Volley中为我们定义的ImageLoader,主要看它的get方法：
public ImageContainer get(String requestUrl, ImageListener imageListener,
int maxWidth, int maxHeight)
// only fulfill requests that were initiated from the main thread.
throwIfNotOnMainThread();
final String cacheKey = getCacheKey(requestUrl, maxWidth, maxHeight);
// Try to look up the request in the cache of remote images.
Bitmap cachedBitmap = mCache.getBitmap(cacheKey);
if (cachedBitmap != null)
// Return the cached bitmap.
ImageContainer container = new ImageContainer(cachedBitmap, requestUrl, null, null);
imageListener.onResponse(container, true);
return container;
// The bitmap did not exist in the cache, fetch it!
ImageContainer imageContainer =
new ImageContainer(null, requestUrl, cacheKey, imageListener);
// Update the caller to let them know that they should use the default bitmap.
imageListener.onResponse(imageContainer, true);
// Check to see if a request is already in-flight.
BatchedImageRequest request = mInFlightRequests.get(cacheKey);
if (request != null)
// If it is, add this request to the list of listeners.
request.addContainer(imageContainer);
return imageContainer;
// The request is not already in flight. Send the new request to the network and
// track it.
Request<?> newRequest =
new ImageRequest(requestUrl, new Listener<Bitmap>()
@Override
public void onResponse(Bitmap response)
onGetImageSuccess(cacheKey, response);
, maxWidth, maxHeight,
Config.RGB_565, new ErrorListener()
@Override
public void onErrorResponse(VolleyError error)
onGetImageError(cacheKey, error);
);
mRequestQueue.add(newRequest);
mInFlightRequests.put(cacheKey,
new BatchedImageRequest(newRequest, imageContainer));
return imageContainer;
上面代码具体流程是这样，首先通过throwIfNotOnMainThread()方法限制必须在UI线程调用；然后根据传入的参数计算cacheKey，获取缓存;如果存在cache，直接将返回结果封装为一个ImageContainer，然后直接回调imageListener.onResponse(container, true);这时我们就可以设置图片了。如果不存在，那就初始化一个ImageContainer，然后直接回调imageListener.onResponse(imageContainer, true)，这里是为了让我们设置默认图片。所以，在实现listener的时候，要先判断resp.getBitmap()是否为null；接下来检查该url是否早已加入了请求对了，如果已加入，则将刚初始化的ImageContainer加入BatchedImageRequest。这就是加载图片时的内存缓存。
然后调用RequestQueue的add()方法将Request传入就可以完成网络请求操作了，让我们来看看add方法中到底做了什么事。
private final Map<String, Queue< Request<?>>> mWaitingRequests =
new HashMap<String, Queue< Request<?>>>();
/**
* The set of all requests currently being processed by this RequestQueue. A Request
* will be in this set if it is waiting in any queue or currently being processed by
* any dispatcher.
*/
private final Set<Request <?>> mCurrentRequests = new HashSet<Request<?>>();
/** The cache triage queue. */
private final PriorityBlockingQueue< Request<?>> mCacheQueue =
new PriorityBlockingQueue< Request<?>>();
/** The queue of requests that are actually going out to the network. */
private final PriorityBlockingQueue< Request<?>> mNetworkQueue =
new PriorityBlockingQueue< Request<?>>();
/**
* Adds a Request to the dispatch queue.
* @param request The request to service
* @return The passed -in request
*/
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;
这里首先将请求加入mCurrentRequests，这个mCurrentRequests是一个HashSet，它保存了所有需要处理的Request，主要为了提供cancel的入口。如果该请求不应该被缓存则直接加入mNetworkQueue，然后返回。request.shouldCache()在默认情况下，每条请求都是可以缓存的，当然我们也可以调用Request的setShouldCache(false)方法来改变这一默认行为。
接下来判断该请求是否有相同的请求正在被处理，如果有则加入mWaitingRequests；如果没有，则加入mWaitingRequests.put(cacheKey, null)，并将request加入到CacheQueue中。
有了队列，我们就来看看线程是如何执行的。先看CacheDispatcher。
public class CacheDispatcher extends Thread
private static final boolean DEBUG = VolleyLog.DEBUG;
/** The queue of requests coming in for triage. */
private final BlockingQueue<Request<?>> mCacheQueue;
/** The queue of requests going out to the network. */
private final BlockingQueue<Request<?>> mNetworkQueue;
/** The cache to read from. */
private final Cache mCache;
/** For posting responses. */
private final ResponseDelivery mDelivery;
/** Used for telling us to die. */
private volatile boolean mQuit = false;
/**
* Creates a new cache triage dispatcher thread. You must call @link #start()
* in order to begin processing.
*
* @param cacheQueue Queue of incoming requests for triage
* @param networkQueue Queue to post requests that require network to
* @param cache Cache interface to use for resolution
* @param delivery Delivery interface to use for posting responses
*/
public CacheDispatcher(
BlockingQueue<Request<?>> cacheQueue, BlockingQueue<Request<?>> networkQueue,
Cache cache, ResponseDelivery delivery)
mCacheQueue = cacheQueue;
mNetworkQueue = networkQueue;
mCache = cache;
mDelivery = delivery;
/**
* Forces this dispatcher to quit immediately. If any requests are still in
* the queue, they are not guaranteed to be processed.
*/
public void quit()
mQuit = true;
interrupt();
@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;
我们要知道CacheDispatcher是硬盘缓存，到此可知Volley也是有二级缓存的。重点看它的run方法。看到while(true)时，我们就知道，它是在不断的执行的。首先从mCacheQueue中取出缓存，如果没有取到，就把它加入mNetworkQueue中，再判断缓存是否过期，如果过期，也放入mNetworkQueue中。否则就取到了可用的缓存了，再调用request.parseNetworkResponse解析从缓存中取出的data和responseHeaders通过mDelivery.postResponse转发，然后回调到UI线程；我们看下mDelivery.postResponse方法：
@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable)
request.markDelivered();
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
主要看ResponseDeliveryRunnable。
public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable)
mRequest = request;
mResponse = response;
mRunnable = runnable;
@SuppressWarnings("unchecked")
@Override
public void run()
// If this request has canceled, finish it and don't deliver.
if (mRequest.isCanceled())
mRequest.finish("canceled-at-delivery");
return;
// Deliver a normal response or error, depending.
if (mResponse.isSuccess())
mRequest.deliverResponse(mResponse.result);
else
mRequest.deliverError(mResponse.error);
// If this is an intermediate response, add a marker, otherwise we're done
// and the request can be finished.
if (mResponse.intermediate)
mRequest.addMarker("intermediate-response");
else
mRequest.finish("done");
// If we have been provided a post-delivery runnable, run it.
if (mRunnable != null)
mRunnable.run();
在它的run方法中，如果访问成功会调用mRequest.deliverResponse(mResponse.result)方法，到这里就很明了了，因为每个request子类中都要重写deliverResponse，最后我们再在这个方法中将响应的数据回调到Response.Listener的onResponse()方法中就可以了。以StringRequest为例：
@Override
protected void deliverResponse(String response)
mListener.onResponse (response);
分析完缓存，我们来看下网络加载。它是在NetworkDispatcher线程中实现的。
public class NetworkDispatcher extends Thread
/** The queue of requests to service. */
private final BlockingQueue<Request<?>> mQueue;
/** The network interface for processing requests. */
private final Network mNetwork;
/** The cache to write to. */
private final Cache mCache;
/** For posting responses and errors. */
private final ResponseDelivery mDelivery;
/** Used for telling us to die. */
private volatile boolean mQuit = false;
/**
* Creates a new network dispatcher thread. You must call @link #start()
* in order to begin processing.
*
* @param queue Queue of incoming requests for triage
* @param network Network interface to use for performing requests
* @param cache Cache interface to use for writing responses to cache
* @param delivery Delivery interface to use for posting responses
*/
public NetworkDispatcher(BlockingQueue<Request<?>> queue,
Network network, Cache cache,
ResponseDelivery delivery)
mQueue = queue;
mNetwork = network;
mCache = cache;
mDelivery = delivery;
@Override
public void run()
Process.setThreadPriority(Process. THREAD_PRIORITY_BACKGROUND);
Request<?> request;
while ( true)
try
// Take a request from the queue.
request = mQueue.take();
catch (InterruptedException e)
// We may have been interrupted because it was time to quit.
if ( mQuit)
return;
continue;
try
request.addMarker( "network-queue-take" );
// If the request was cancelled already, do not perform the
// network request.
if (request.isCanceled())
request.finish( "network-discard-cancelled" );
continue;
addTrafficStatsTag(request);
// Perform the network request.
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker( "network-http-complete" );
// If the server returned 304 AND we delivered a response already,
// we're done -- don't deliver a second identical response.
if (networkResponse. notModified && request.hasHadResponseDelivered())
request.finish( "not-modified");
continue;
// Parse the response here on the worker thread.
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker( "network-parse-complete" );
// Write to cache if applicable.
// TODO: Only update cache metadata instead of entire record for 304s.
if (request.shouldCache() && response. cacheEntry != null )
mCache.put(request.getCacheKey(), response.cacheEntry );
request.addMarker( "network-cache-written" );
// Post the response back.
request.markDelivered();
mDelivery.postResponse(request, response);
catch (VolleyError volleyError)
parseAndDeliverNetworkError(request, volleyError);
catch (Exception e)
VolleyLog. e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
首先取出请求；然后通过mNetwork.performRequest(request)处理我们的请求，拿到NetworkResponse。看下performRequest方法：
public NetworkResponse performRequest(Request<?> request) throws VolleyError
long requestStart = SystemClock.elapsedRealtime();
while (true)
HttpResponse httpResponse = null;
byte[] responseContents = null;
Map<String, String> responseHeaders = new HashMap<String, String>();
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)
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry() == null ? null : request.getCacheEntry().data,
responseHeaders, true);
// 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);
catch (Exception e)
……
上面方法主要是网络请求的一些细节，所以如果要修改请求的细节就要到此处修改（后面会讲到）。
在这里服务器会返回的数据组装成一个NetworkResponse对象进行返回。在NetworkDispatcher中收到了NetworkResponse这个返回值后又会调用Request的parseNetworkResponse()方法来解析NetworkResponse中的数据，再将数据写入到缓存。parseNetworkResponse的实现是交给Request的子类来完成的，不同种类的Request解析的方式不同。如json与gson就有区别。最后与CacheDispatcher一样调用mDelivery.postResponse(request, response)返回回调，这里就不再分析了。
到这里volley的源码就分析完了，总结一下：
- 首先初始化RequestQueue，主要就是开启CacheDispatcher和NetworkDispatcher线程，线程会不断读取请求，没有消息则阻塞。
- 当我们发出请求以后，会根据url，ImageView属性等，构造出一个cacheKey，然后首先从LruCache中获取，这个缓存我们自己构建的，这就是内存缓存；如果没有取到，则判断是否存在硬盘缓存，这一步是从getCacheDir里面获取（默认5M）；如果没有取到，则从网络请求；
Volley的扩展
添加cookie头
volley跟httpClient不一样，它是不会自动添加cookie头的。但是cookie在应用中却很重要，它会保证登陆后的操作都处于一个会话中，有效的增加了安全性。那么如何在volley中自动添加cookie呢。
首先在新建Appliaction，当成全局的Application，然后在里面编写在http头参数中识别出cookie和添加cookie到Http头代码。
/**
* Checks the response headers for session cookie and saves it
* if it finds it.
* @param headers Response Headers.
*/
public static final void checkSessionCookie(Map<String, String> headers)
Log.e("TAG", "checkSessionCookie->headers:" + headers);
if (headers.containsKey(GlobalParams.SET_COOKIE_KEY) && headers.get(GlobalParams.SET_COOKIE_KEY).startsWith(GlobalParams.SESSION_COOKIE))
String cookie = headers.get(GlobalParams.SET_COOKIE_KEY);
if (cookie.length() > 0)
//形如Set-Cookie:JSESSIONID=18D6BCC01453C6EB39BB0C4208F389EE; Path=/smdb
//进行解析，取出JSESSIONID的value
String[] splitCookie = cookie.split(";");
String[] splitSessionId = splitCookie[0].split("=");
cookie = splitSessionId[1];
Editor prefEditor = preferences.edit();
prefEditor.putString(GlobalParams.SESSION_COOKIE, cookie);
prefEditor.commit();
else
if (null != httpclient.getCookieStore())
List<Cookie> cookies = httpclient.getCookieStore().getCookies();
for (Cookie cookie : cookies)
if ("JSESSIONID".equals(cookie.getName())) //取得session的value
String sessionId = cookie.getValue();
Editor prefEditor = preferences.edit();
prefEditor.putString(GlobalParams.SESSION_COOKIE, sessionId);
prefEditor.commit();
break;
if (!cookies.isEmpty())
for (int i = 0; i < cookies.size(); i++)
cookie = cookies.get(i);//保存cookie的信息使得HttpClient和WebView共享同一个cookie
接着就要在Request的子类中合适地方添加头信息，哪个地方合适。我们来看下HurlStack的performRequest方法。
@Override
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 = 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;
重点看到map.putAll(request.getHeaders());所以我们考虑到如果要给它添加头信息可以在request的getHeaders()方法中添加。至此我们以StringRequest为例，重写一个类叫MyStringRequest:
public class MyStringRequest extends StringRequest
private final Map<String, String> mParams;
/**
* @param method
* @param url
* @param params
* A @link HashMap to post with the request. Null is allowed
* and indicates no parameters will be posted along with request.
* @param listener
* @param errorListener
*/
public MyStringRequest(int method, String url, Map<String, String> params, Listener<String> listener,
ErrorListener errorListener)
super(method, url, listener, errorListener);
mParams = params;
@Override
protected Map<String, String> getParams()
return mParams;
/* (non-Javadoc)
* @see com.android.volley.toolbox.StringRequest#parseNetworkResponse(com.android.volley.NetworkResponse)
*/
@Override
protected Response<String> parseNetworkResponse(NetworkResponse response)
// since we don't know which of the two underlying network vehicles
// will Volley use, we have to handle and store session cookies manually
Log.e("TAG", "parseNetworkResponse->response.headers:" + response.headers);
GlobalApplication.checkSessionCookie(response.headers);
return super.parseNetworkResponse(response);
/* (non-Javadoc)
* @see com.android.volley.Request#getHeaders()
*/
@Override
public Map<String, String> getHeaders() throws AuthFailureError
Map<String, String> headers = super.getHeaders();
if (headers == null || headers.equals(Collections.emptyMap()))
headers = new HashMap<String, String>();
GlobalApplication.addSessionCookie(headers);
return headers;
在parseNetworkResponse中调用checkSessionCookie解析头信息中的cookie，然后重写getHeaders方法，调用addSessionCookie添加cookie。
添加重定向功能
网络访问经常要用到重定向，虽说在客户端中用得比较少。那Volley能不能进行自动重定向，答案是可以的，重要修改下源码。既然要重定向，那就要在请求返回的进行判断，毫无疑问要在BasicNetwork的performRequest中修改，先看下修改后的代码：
@Override
public NetworkResponse performRequest(Request<?> request) throws VolleyError
long requestStart = SystemClock.elapsedRealtime();
while (true)
HttpResponse httpResponse = null;
byte[] responseContents = null;
Map<String, String> responseHeaders = new HashMap<String, String>();
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)
return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry() == null ? null : request.getCacheEntry().data,
responseHeaders, true);
// Handle moved resources
//Line143-148为解决301/302重定向问题增加的代码。
//参考见https://github.com/elbuild/volley-plus/commit/4a65a4099d2b1d942f4d51a6df8734cf272564eb#diff-b4935f77d9f815bb7e0dba85e55dc707R150
if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY)
String newUrl = responseHeaders.get("Location");
request.setRedirectUrl(newUrl);
// 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];
以上是关于Volley源码解析的主要内容，如果未能解决你的问题，请参考以下文章