很早之前就想写下关于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];                  }                    // 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 (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);                  }                  //Line143-148为解决301/302重定向问题增加的代码。                  if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||                           statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {                      VolleyLog.e("Request at %s has been redirected to %s", request.getOriginUrl(), request.getUrl());                  } else {                      VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());                  }                  if (responseContents != null) {                      networkResponse = new NetworkResponse(statusCode, responseContents,                              responseHeaders, false);                      if (statusCode == HttpStatus.SC_UNAUTHORIZED ||                              statusCode == HttpStatus.SC_FORBIDDEN) {                          attemptRetryOnException("auth",                                  request, new AuthFailureError(networkResponse));                      } else if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY ||                                   statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {                          //else if语句为解决301/302重定向问题增加的代码。设置重连请求。                           attemptRetryOnException("redirect",                                  request, new AuthFailureError(networkResponse));                      } else {                          // TODO: Only throw ServerError for 5xx status codes.                          throw new ServerError(networkResponse);                      }                  } else {                      throw new NetworkError(networkResponse);                  }              }          }      }

其实重点添加了以下的代码：

 if (statusCode == HttpStatus.SC_MOVED_PERMANENTLY || statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {                      String newUrl = responseHeaders.get("Location");                      request.setRedirectUrl(newUrl);                  }

上面的代码就是判断返回code是否是301或302，如果是就获取重定向的Url，再设置重定向，很简单。到此Volley常见的扩展功能就讲完了。
源码解析的文章都会有点长，写完也要有耐心。继续坚持。