使用okhttp3做Android图片框架Picasso的下载器和缓存器
最近项目里把图片加载框架从xUtils换到了Picasso，一些下载和缓存的策略也因此发生变化，Picasso的缓存没有xUtils自动化那么高，使用起来遇到了一些困难，但是好在Picasso的源码非常清晰易读，很快就从源码上对Picasso的缓存策略有的大概的了解。
首先要明确一下几个概念，这里是以Picasso2.5.2+okhttp3为基础：
1、Picasso默认只有LRU缓存，也就是内存里面的缓存，Picasso默认不会将下载好的图片存储到磁盘上。（如果不信请往下看）
2、Picasso默认不会使用okhttp3作为自己的图片下载和缓存框架。（虽然官网上说如果项目中已经有了okhttp，会自动使用okhttp下载和缓存）
3、Picasso默认使用的下载工具是HttpURLConnection。
4、如果想实现Picasso的磁盘缓存并使用okhttp3作为下载器，需要手动编写代码，并且所有的磁盘缓存都交给okhttp3进行处理，Picasso没有和缓存有关的代码。说白了，Picasso的磁盘缓存主要靠Http框架完成。
好了这里总结出一个重要结论：Picasso负责内存中的LRU图片缓存，Http框架负责磁盘缓存。如果没有手动的指定Http框架的缓存，那么重启app之后又没有联网的话，之前下载好的图片也不会显示。
（注：如果想看Picasso+Okhttp3的实现效果，可以去下载我github上的一个demo：https://github.com/AlexZhuo/AlxPicassoProgress
这个项目中使用Picasoo2+Okhttp3实现了下载进度显示功能，Flash缓存功能等。）
那么如何指定okhttp3作为图片下载和缓存的框架，Picasso声称的自动支持okhttp为什么是不准确的呢，请看代码，先从Picasso的初始化代码看起
一般来说，普通的Picasso的用法是下面的一行代码
Picasso.with(context).load(url).error(默认图片).tag(context).into(imageView, callback);public static Picasso with(Context context) {
if (singleton == null) {
synchronized (Picasso.class) {
if (singleton == null) {
singleton = new Builder(context).build();
}
}
}
return singleton;
}public Picasso build() {
Context context = this.context;
if (downloader == null) {//如果没有手动指定下载器
downloader = Utils.createDefaultDownloader(context);
}
if (cache == null) {//如果没有手动指定缓存策略
cache = new LruCache(context);//LRU内存缓存
}
if (service == null) {//如果没有手动指定线程池，那就用Picasso自己的默认线程池
service = new PicassoExecutorService();
}
if (transformer == null) {
transformer = RequestTransformer.IDENTITY;
}
Stats stats = new Stats(cache);
Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);//初始化分发器
return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
}
}static Downloader createDefaultDownloader(Context context) {
try {
Class.forName("com.squareup.okhttp.OkHttpClient");
return OkHttpLoaderCreator.create(context);
} catch (ClassNotFoundException ignored) {
}
return new UrlConnectionDownloader(context);
}可问题是，okhttp3的类名已经不是这个了，而是换成了okhttp3.OkHttpClient，那么这个反射方法必然会失败，虽然你部署了okhttp3，但是Picasoo是不会用他的。
那么问题又来了，Picasso只给了两个downloader，旧版的okhttp和HttpURLConnection，那么如何让Picasso支持okhttp3呢？答案也很简单，自己写一个okhttp3的downloader就好了，因为Picasso已经给出了换downloader的api，换起来非常方便。并且在修改Downloader的时候，还可以自定义okhttp3的缓存策略和下载策略，做一些很有意思的自定义下载方法。
用户可以照着旧版的okHttpDownLoader自己写，也可以去网上下载一个现成的，这里我推荐一个github项目
https://github.com/JakeWharton/picasso2-okhttp3-downloader
这个项目里面只有一个java文件OkHttp3Downloader.java，把这个文件拷贝到自己的项目中去，然后这样用：
public static Picasso picasso = new Picasso.Builder(context)
.downloader(new OkHttp3Downloader(context))
.build()调用方法：
picasso.load(url).placeholder(R.drawable.qraved_bg_default).error(R.drawable.qraved_bg_default).tag(context).into(target, null);
注意：这里的picasso一定要做成单例模式，不然LRU内存缓存会失效，那时候你滚动一个listView，滚下去再滚上来，原本下载好的图片会重新下一遍的
Picasso的LRU缓存工作分析
前面说过，Picasso只负责内存中LRU缓存的读写，那么Picasso是怎样控制的呢？
每次在Picasso第一次加载某张图片的时候，会执行downloader的load()方法，现在我把okhttp3Downloader的该方法实现贴出来：
@Override public Response load(Uri uri, int networkPolicy) throws IOException {
CacheControl cacheControl = null;
if (networkPolicy != 0) {
if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
cacheControl = CacheControl.FORCE_CACHE;//不要轻易设置成force_catche，可能会下载不到图片
} else {
CacheControl.Builder builder = new CacheControl.Builder();
if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
builder.noCache();
}
if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
builder.noStore();
}
cacheControl = builder.build();
}
}
Request.Builder builder = new Request.Builder().url(uri.toString());
if (cacheControl != null) {//这个对象为null并不影响okhttp3的缓存效果
builder.cacheControl(cacheControl);
}
okhttp3.Response response = client.newCall(builder.build()).execute();//正式发起网络请求
int responseCode = response.code();
if (responseCode >= 300) {
response.body().close();
throw new ResponseException(responseCode + " " + response.message(), networkPolicy,
responseCode);//显示下载失败的默认图片
}
boolean fromCache = response.cacheResponse() != null;//这里的fromCache为true则说明该图片是从okhttp3的磁盘缓存中读出来的，一般重启app加载同一个url的图片会这样，反之就是从网上现下的
ResponseBody responseBody = response.body();//这里body就是jpg文件的字节流
return new Response(responseBody.byteStream(), fromCache, responseBody.contentLength());
}Bitmap hunt() throws IOException {
Bitmap bitmap = null;
if (shouldReadFromMemoryCache(memoryPolicy)) {
bitmap = cache.get(key);
if (bitmap != null) {//如果从LRU缓存中得到了相应的bitmap
stats.dispatchCacheHit();
loadedFrom = MEMORY;
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_DECODED, data.logId(), "from cache");
}
return bitmap;
}
}
//如果没用从LRU中读到bitmap，那么就联网下载（可能会经过okhttp3的磁盘缓存）
data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
RequestHandler.Result result = requestHandler.load(data, networkPolicy);//同步访问网络
if (result != null) {
loadedFrom = result.getLoadedFrom();
exifRotation = result.getExifOrientation();
bitmap = result.getBitmap();
// If there was no Bitmap then we need to decode it from the stream.
if (bitmap == null) {
InputStream is = result.getStream();
try {
bitmap = decodeStream(is, data);
} finally {
Utils.closeQuietly(is);
}
}
}
if (bitmap != null) {
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_DECODED, data.logId());
}
stats.dispatchBitmapDecoded(bitmap);
if (data.needsTransformation() || exifRotation != 0) {
synchronized (DECODE_LOCK) {
if (data.needsMatrixTransform() || exifRotation != 0) {
bitmap = transformResult(data, bitmap, exifRotation);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
}
}
if (data.hasCustomTransformations()) {
bitmap = applyCustomTransformations(data.transformations, bitmap);
if (picasso.loggingEnabled) {
log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
}
}
}
if (bitmap != null) {
stats.dispatchBitmapTransformed(bitmap);
}
}
}
return bitmap;
}现在来写一个流程图方便大家理解
第一次获取图片：搜索本地LRU缓存发现没有-->>分发器调用okhttp3下载图片-->>okhttp3自动将图片缓存为文件-->>picasoo解码jpg文件为bitmap-->>Picasoo显示图片-->>Picasso将自己的图片缓存到LRU内存中
第二次加载同一个URL：搜索本地LRU缓存发现存在-->>分发器获得bitmap-->>显示bitmap
第二次加载同一个URL但LRU缓存失效: 搜索本地LRU缓存发现已经失效-->>分发器调用okhttp-->>okhttp扫描磁盘缓存发现存在-->>okhttp读取磁盘缓存将输出流交给Picasso-->>Picasso解码并显示
注意：观察okhttp是不是从磁盘中读取的缓存，可以打印downloader的load()方法的 boolean fromCache = response.cacheResponse() != null;这个布尔值
注意：picasso对象一定要是单例模式，不然LRU缓存会失效
okhttp3的缓存玩法
Picasso偷懒之处在于它不做sd卡的磁盘图片缓存，所以每次重启app上次加载好的图片会丢失，Picasso依赖Http加载框架为它做磁盘缓存。
在使用okhttp3下载器的时候发现，okhttp3已经自动帮我们实现了大文件下载的缓存，这样就实现了我们关闭app重启之后，原来下载好的图片即使不联网也能显示，但是Picasso默认使用的URLConnectionDownloader不支持这一点。但是okhttp3普通的GET方法却不会自动的缓存，但是如果okhttp3没有实现图片下载的缓存，或者想实现在没有联网的情况下让okhttp3直接抓取上一次的缓存内容应该怎么办呢？
注：查看okhttp3是否从缓存加载的图片方法是打印downloader的load()方法的 boolean fromCache = response.cacheResponse() != null;
现在需要我们对okhttp3的缓存控制有一定了解，并修改上面github上的那个okhttp3的下载器的一个构造函数如下：
private static OkHttpClient defaultOkHttpClient(File cacheDir, long maxSize) {
Interceptor REWRITE_CACHE_CONTROL_INTERCEPTOR = new Interceptor() {
@Override
public okhttp3.Response intercept(Chain chain) throws IOException {
okhttp3.Response originalResponse = chain.proceed(chain.request());
return originalResponse.newBuilder()
.removeHeader("Pragma")//去掉一个header
.header("Cache-Control", String.format("max-age=%d", 480))//添加本地缓存过期时间，单位是秒
.build();
}
};
return new OkHttpClient.Builder()
.cache(new okhttp3.Cache(cacheDir, maxSize))
.addNetworkInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
.build();
}这样就手动配置了okhttp3磁盘缓存的过期时间，也就是在过期时间到达之前，okhttp3会把已经下载好的jpg文件存在sd卡中，等待下次相同url的调用。同样可以根据这个配置，可以解决一些棘手的情况如服务器端的图像已经改变了，但是客户端由于缓存的原因没变的问题
下面是okhttp3缓存位置和大小的配置代码
private static final String PICASSO_CACHE = "picasso-cache";
private static final int MIN_DISK_CACHE_SIZE = 5 * 1024 * 1024; // 5MB
private static final int MAX_DISK_CACHE_SIZE = 50 * 1024 * 1024; // 50MB
private static File createDefaultCacheDir(Context context) {
File cache = new File(context.getApplicationContext().getCacheDir(), PICASSO_CACHE);
if (!cache.exists()) {
//noinspection ResultOfMethodCallIgnored
cache.mkdirs();
}
return cache;
}
private static long calculateDiskCacheSize(File dir) {
long size = MIN_DISK_CACHE_SIZE;
try {
StatFs statFs = new StatFs(dir.getAbsolutePath());
long available = ((long) statFs.getBlockCount()) * statFs.getBlockSize();
// Target 2% of the total space.
size = available / 50;
} catch (IllegalArgumentException ignored) {
}
// Bound inside min/max size for disk cache.
return Math.max(Math.min(size, MAX_DISK_CACHE_SIZE), MIN_DISK_CACHE_SIZE);
}Picasso下载器的高级玩法——自动重定向：
项目里面遇到这样一个需求，下载一张照片需要经过三个服务器，一个是提供假url的数据库服务器，一个是将假url翻译成真url的解密服务器，一个是存放有图片的CDN服务器
数据库服务器（给假url） 解密服务器 CDN服务器
现在需要实现这样一个流程，从数据库服务器通过json获得一个假url，然后把假url发给解密服务器获得一个真url，然后用真url去CDN服务器下载照片那么问题来了，Picasso的LRU缓存是以url为key，bitmap为value的，如果我用真url去下载，而用假url做key，那么Picasso的缓存就没用啦，这样用户体验就完蛋了，那么能不能我直接将假url给Picasso，让后Picasso自动的去获取真url并自动下载呢（并以假url做key）？通过自定义下载器可以非常容易的实现这一点，方法还是修改下载器的load()方法，让他在一个load()中请求两次网络，一次是解密服务器获取String字符串url，第二次是拿着真的url去CDN服务器下载图片，代码如下
@Override public Response load(Uri uri, int networkPolicy) throws IOException {
JLogUtils.i("AlexImage","假的uri是->"+uri+" 缓存策略是"+networkPolicy);
CacheControl cacheControl = null;
if (networkPolicy != 0) {
if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
JLogUtils.i("AlexImage","准备强制缓存");
cacheControl = CacheControl.FORCE_CACHE;
} else {
CacheControl.Builder builder = new CacheControl.Builder();
if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
builder.noCache();
}
if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
builder.noStore();
}
cacheControl = builder.build();
}
}
Request.Builder php_builder = new Request.Builder().url(uri.toString());
if (cacheControl != null) {
php_builder.cacheControl(cacheControl);
}
long startTime = System.currentTimeMillis();
okhttp3.Response php_response = client.newCall(php_builder.build()).execute();//执行第一次http请求连接解密服务器
int php_responseCode = php_response.code();
JLogUtils.i("AlexImage","解密服务器响应码是"+php_responseCode);
if (php_responseCode >= 300) {
php_response.body().close();
throw new ResponseException(php_responseCode + " " + php_response.message(), networkPolicy, php_responseCode);
}
boolean fromPhpCache = php_response.cacheResponse() != null;
JLogUtils.i("AlexImage","解密服务器的响应是不是从缓存拿的呀？"+fromPhpCache);
JLogUtils.i("AlexImage","全部的header是"+php_response.headers());
if(php_response.header("Content-Type").equals("text/plain")){//如果php发来的是cdn的图片url,这里通过header进行区分
JLogUtils.i("AlexImage","现在是从php取得的url字符串而不是jpg");
String cdnUrl = php_response.body().string();
JLogUtils.i("AlexImage","php服务器响应时间"+(System.currentTimeMillis() - startTime));
JLogUtils.i("AlexImage","CDN的imageUrl是->"+cdnUrl);
Request.Builder cdn_builder = new Request.Builder().url(cdnUrl);
if (cacheControl != null) {
cdn_builder.cacheControl(cacheControl);
}
long cdnStartTime = System.currentTimeMillis();
okhttp3.Response cdn_response = client.newCall(cdn_builder.build()).execute();//执行第二次http请求连接CDN服务器
int cdn_responseCode = cdn_response.code();
JLogUtils.i("AlexImage","cdn的响应码是"+cdn_responseCode);
if (cdn_responseCode >= 300) {
cdn_response.body().close();
throw new ResponseException(cdn_responseCode + " " + cdn_response.message(), networkPolicy,
cdn_responseCode);
}
JLogUtils.i("AlexImage","cdn响应时间"+(System.currentTimeMillis() - cdnStartTime));
boolean fromCache = cdn_response.cacheResponse() != null;
ResponseBody cdn_responseBody = cdn_response.body();
JLogUtils.i("AlexImage","cdn的图片是不是从缓存拿的呀？fromCache = "+fromCache);
return new Response(cdn_responseBody.byteStream(), fromCache, cdn_responseBody.contentLength());
}else {//如果php发来的不是图片的URL，那就直接用php发来的图片
JLogUtils.i("AlexImage","准备直接用PHP的图片！！！");
boolean fromCache = php_response.cacheResponse() != null;
ResponseBody responseBody = php_response.body();
return new Response(responseBody.byteStream(), fromCache, responseBody.contentLength());
}
}这样通过自定义Picasso的下载器就完成了一个复杂的url自动重定向的功能！