Volley的使用(三)

一.概述

今天带大家从源码的角度来分析一下volley的缓存机制，目的就是为了家声理解。

我们知道，在创建请求队列的时候会使用如下的代码

RequestQueue queue = Volley.newRequestQueue(this);

方法定义如下

public static RequestQueue newRequestQueue(Context context) {
return newRequestQueue(context, null);
}

我们继续往下看

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 {
//如果版本小于9，添加userAgent,因为大于9以后，会默认自带userAgent
stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
}
}
Network network = new BasicNetwork(stack);
RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
queue.start();
return queue;
}

总结一下上面的步骤：

1.创建缓存目录，路径为data/data/包名/cache/volley

2.根据包名和版本号拼接userAgent

3.根据当前系统的版本号创建不同的HttpStack,HttpStack是用来执行请求的，当系统版本大于等于9的时候，创建HurlStack，底层使用的是HttpUrlConnection,小于9的时候，创建AndroidHttpClient，并传入userAgent,底层使用的是HttpClient

4.将创建好的httpstack对象封装到Network中，创建并启动请求队列

因为本篇是分析缓存的，我们重点看下面一行代码

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);

我们在创建请求队列的时候，传入了一个DiskBasedCache对象。并且把缓存路径传递给了DiskBasedCache。

DiskBasedCache相关源码分析

接下来我们分析一下DiskBasedCache的代码

首先会调用如下方法

public DiskBasedCache(File rootDirectory) {
this(rootDirectory, DEFAULT_DISK_USAGE_BYTES);
}

DEFAULT_DISK_USAGE_BYTES从字面上我们就可以知道是缓存默认使用的磁盘大小，

private static final int DEFAULT_DISK_USAGE_BYTES = 5 * 1024 * 1024;

我们可以看到是5M，我们也可以手动设定这个大小，在创建DiskBasedCache对象的时候我们调用下面的这个方法，传入自己设置的缓存大小即可，

public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {
mRootDirectory = rootDirectory;
mMaxCacheSizeInBytes = maxCacheSizeInBytes;
}

Volley是如何把从网络请求到的数据放到缓存中的

Volley每次会把网络请求的数据保存到本地的缓存路径中，我们看看是如何实现的，相关代码在NetworkDispatcher中

//解析结果
Response<?> response =
//解析数据
request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");

//判断是否需要缓存以及缓存是否不为空
if (request.shouldCache() && response.cacheEntry != null) {
//保存缓存
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
// 回调结果
request.markDelivered();
mDelivery.postResponse(request, response);

我们看重点代码，是下面这句

mCache.put(request.getCacheKey(), response.cacheEntry);

调用了mCache对象的put方法把响应的内容保存了起来，那么这个mCache对象是什么呢?直接告诉你，是DiskBasedCache，为什么，接下来我们验证一下

首先看mCache这个对象在哪里赋值的

public NetworkDispatcher(BlockingQueue<Request<?>> queue,
Network network, Cache cache,
ResponseDelivery delivery) {
mQueue = queue;
mNetwork = network;
mCache = cache;
mDelivery = delivery;
}

是在构造方法中，然后我们就应该看看构造方法在哪里调用了，我们在RequestQueue中发现了，

public void start() {
stop();  // 只允许一个缓存调度线程运行
//创建缓存调度线程
mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
mCacheDispatcher.start();

// 创建网络缓存线程
for (int i = 0; i < mDispatchers.length; i++) {
NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
mCache, mDelivery);
mDispatchers[i] = networkDispatcher;
networkDispatcher.start();
}
}

那么start方法中的mCache是什么东西呢？

我们知道，在创建请求队列的时候，会调用如下的方法

public RequestQueue(Cache cache, Network network) {
this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);//默认线程池容量为4
}

最终会调用

public RequestQueue(Cache cache, Network network, int threadPoolSize,
ResponseDelivery delivery) {
mCache = cache;
mNetwork = network;
mDispatchers = new NetworkDispatcher[threadPoolSize];
mDelivery = delivery;
}

我们看到mCache就是在这里赋值的，cache就是创建请求队列时传入的DiskBasedCache对象。这就验证了我们的结论。

结论：Volley每次从网络请求的数据，会调用DiskBasedCache对象的put方法保存到本地的缓存路径，方法如下

mCache.put(request.getCacheKey(), response.cacheEntry);

键为请求的Url，

public String getCacheKey() {
return getUrl();
}

值为响应内容，包含以下内容

/** The data returned from cache. */
public byte[] data;

/** ETag for cache coherency. */
public String etag;

/** Date of this response as reported by the server. */
public long serverDate;

/** The last modified date for the requested object. */
public long lastModified;

/** TTL for this record. */
public long ttl;

/** Soft TTL for this record. */
public long softTtl;

put方法分析

经过上面的分析之后，我们就该看看DiskBasedCache的put方法了

@Override
public synchronized void put(String key, Entry entry) {
pruneIfNeeded(entry.data.length);
File file = getFileForKey(key);
try {
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(file));
CacheHeader e = new CacheHeader(key, entry);
boolean success = e.writeHeader(fos);
if (!success) {
fos.close();
VolleyLog.d("Failed to write header for %s", file.getAbsolutePath());
throw new IOException();
}
fos.write(entry.data);
fos.close();
putEntry(key, e);
return;
} catch (IOException e) {
}
boolean deleted = file.delete();
if (!deleted) {
VolleyLog.d("Could not clean up file %s", file.getAbsolutePath());
}
}

首先调用了pruneIfNeeded这个方法，传入要保存的数据的长度

private void pruneIfNeeded(int neededSpace) {
//缓存未达到最大容量，不做处理
if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes) {
return;
}
if (VolleyLog.DEBUG) {
VolleyLog.v("Pruning old cache entries.");
}

long before = mTotalSize;
int prunedFiles = 0;//删除的文件个数
long startTime = SystemClock.elapsedRealtime();

Iterator<Map.Entry<String, CacheHeader>> iterator = mEntries.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, CacheHeader> entry = iterator.next();
CacheHeader e = entry.getValue();
boolean deleted = getFileForKey(e.key).delete();
if (deleted) {
mTotalSize -= e.size;
} else {
VolleyLog.d("Could not delete cache entry for key=%s, filename=%s",
e.key, getFilenameForKey(e.key));
}
iterator.remove();
prunedFiles++;

if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes * HYSTERESIS_FACTOR) {
break;
}
}

if (VolleyLog.DEBUG) {
VolleyLog.v("pruned %d files, %d bytes, %d ms",
prunedFiles, (mTotalSize - before), SystemClock.elapsedRealtime() - startTime);
}
}

首先说一下这个方法是干嘛的，是在缓存总大小不够用的时候，删除旧的缓存内容的，以保证我们新的缓存内容能够能加进来。

if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes) {
return;
}

判断当前容量加上需要的容量是否超出了最大缓存容量，没有超出，则什么都不做。

然后遍历mEntries，那么mEntries是什么呢？

private final Map<String, CacheHeader> mEntries =
new LinkedHashMap<String, CacheHeader>(16, .75f, true);

是一个LinkedHashMap对象，并且指定了默认容量为16，加载因子为0.75，最后一个参数为true,代表链接哈希映像将使用访问顺序而不是插入顺序来迭代各个映像

既然要遍历这个mEntries ，肯定要有值啊，我们在哪里为其添加数据了呢？就是在保存缓存的put方法里面，put方法内部会调用一个putEntry方法，为mEntries添加数据，我们看看

private void putEntry(String key, CacheHeader entry) {
if (!mEntries.containsKey(key)) {
mTotalSize += entry.size;
} else {
CacheHeader oldEntry = mEntries.get(key);
mTotalSize += (entry.size - oldEntry.size);
}
mEntries.put(key, entry);
}

如果当前集合指定的key不存在，在当前总容量的基础上加上内容的容量，如果指定的key存在，首先获取旧的缓存对象，然后当前总容量加上新的缓存大小减去旧的缓存大小。

在遍历的过程中，根据CacheHeader对象的key属性去删除对应的文件，这个key是什么呢？

static class CacheHeader {
/** The size of the data identified by this CacheHeader. (This is not
* serialized to disk. */
public long size;

/** The key that identifies the cache entry. */
public String key;

在源码中可以看到是标识缓存内容的

if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes * HYSTERESIS_FACTOR) {
break;
}

意思就是当当前的容量+需要的容量小于磁盘最大容量的百分之九十时就可以跳出循环了。不用在继续进行删除操作了，至于为什么要这么做，还不是很明白。

缓存内容的写入

既然要写入内容，肯定要先创建对应的文件价才对，首先我们看看文件夹的创建过程，在DiskBasedCache的initialize方法中进行了缓存目录的创建，那个这个方法是在哪里调用的呢，我们知道，在请求队列启动的时候，会创建缓存调度线程并且启动它，在run方法里就进行了缓存目录的创建。

@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
mCache.initialize();

接下来我们看看initialize方法的具体实现

public synchronized void initialize() {
//如果目录不存在，这个目录是data/data/包名/cache/volley文件夹
if (!mRootDirectory.exists()) {
//创建文件目录
if (!mRootDirectory.mkdirs()) {
VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());
}
return;
}
//获取缓存目录中的所有文件
File[] files = mRootDirectory.listFiles();
if (files == null) {
return;
}
for (File file : files) {
BufferedInputStream fis = null;
try {
fis = new BufferedInputStream(new FileInputStream(file));
//读取文件中的头信息
CacheHeader entry = CacheHeader.readHeader(fis);
entry.size = file.length();
//添加到缓存集合中
putEntry(entry.key, entry);
} catch (IOException e) {
if (file != null) {
file.delete();
}
} finally {
try {
if (fis != null) {
fis.close();
}
} catch (IOException ignored) { }
}
}
}

创建好了目录，接下来就是写入文件，写入之前先判断缓存容量是否足够，不够就删除一些文件，那么是删除哪些文件呢？会删除最近最少使用的文件，原因分析如下：

我们的缓存是存放在LinkedHashMap中的，在构造LinkedHashMap时候，是这样的

  private final Map<String, CacheHeader> mEntries =
new LinkedHashMap<String, CacheHeader>(16, .75f, true);

最后一个参数为true，代表将使用访问顺序而不是插入顺序来迭代各个映像

如果缓存没有达到指定容量，继续向里面存

File file = getFileForKey(key);

public File getFileForKey(String key) {
return new File(mRootDirectory, getFilenameForKey(key));
}

//根据url创建缓存文件名，这里的实现方式是把url长度分为两部分，分别陈胜hasCode，最后的文件名就是两部分hasCode的拼接
private String getFilenameForKey(String key) {
int firstHalfLength = key.length() / 2;
String localFilename = String.valueOf(key.substring(0, firstHalfLength).hashCode());
localFilename += String.valueOf(key.substring(firstHalfLength).hashCode());
return localFilename;
}

接下来是写入内容到文件

@Override
public synchronized void put(String key, Entry entry) {
pruneIfNeeded(entry.data.length);
//分居url获取创建对应文件
File file = getFileForKey(key);
try {
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream(file));
CacheHeader e = new CacheHeader(key, entry);
//将内容写入到文件中
boolean success = e.writeHeader(fos);
if (!success) {
fos.close();
VolleyLog.d("Failed to write header for %s", file.getAbsolutePath());
throw new IOException();
}
//将data写入到文件
fos.write(entry.data);
fos.close();
//将内容保存到集合
putEntry(key, e);
return;
} catch (IOException e) {
}
boolean deleted = file.delete();
if (!deleted) {
VolleyLog.d("Could not clean up file %s", file.getAbsolutePath());
}
}

NetworkDispatcher相关源码

启动请求队列以后，同时会启动四个网络调度线程，执行它的run方法

@Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
while (true) {
long startTimeMs = SystemClock.elapsedRealtime();
Request<?> request;
try {
//从请求队列中取出一个请求
request = mQueue.take();
} catch (InterruptedException e) {

if (mQuit) {
return;
}
continue;
}

try {
request.addMarker("network-queue-take");
// 如果请求被取消了，我们不执行网络请求
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}

addTrafficStatsTag(request);

// 执行网络请求，具体实现在BasicNetWork中.
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete");
// 如果服务器返回304并且我们已经投递了一个结果，不要投递两次相同的结果
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}

//在工作线程解析结果
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");

// 添加到缓存中
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
request.markDelivered();
//投递结果
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
VolleyError volleyError = new VolleyError(e);
volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
mDelivery.postError(request, volleyError);
}
}
}

上面再执行完请求之后调用了mDelivery对象的postResponse方法将结果投递。那么这个mDelivery是什么呢？是一个ExecutorDelivery对象，何时初始化的呢？我们创建请求队列的时候就进行了初始化。

public RequestQueue(Cache cache, Network network, int threadPoolSize) {
this(cache, network, threadPoolSize,
new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}

并且这个ExecutorDelivery持有主线程的Handler对象，接下来我们看看结果的投递

public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
}
};
}

@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}

调用了execute方法将一个runnable对象传递到了主线程，因为我们获取的handler是主线程的handler.接下来我们看看这个ResponseDeliveryRunnable，当执行handler.post(Runnable)时，就会执行Runnable对象的run方法，这是一种命令模式的体现。

我们看看ResponseDeliveryRunnable的run方法

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 (mResponse.intermediate) {
mRequest.addMarker("intermediate-response");
} else {
mRequest.finish("done");
}
if (mRunnable != null) {
mRunnable.run();
}
}