Android异步加载全解析之引入二级缓存

为啥要二级缓存

前面我们有了一级缓存，为啥还要二级缓存呢？说白了，这就和电脑是一样的，我们电脑有内存和硬盘，内存读取速度快，所以CPU直接读取内存中的数据，但是，内存资源有限，所以我们可以把数据保存到硬盘上，这就是二级缓存，硬盘虽然读取速度慢，但是人家容量大。

Android的缓存技术也是使用了这样一个特性，总的来说，使用二级缓存的方案，就是先从一级缓存——内存中拿，没有的话，再去二级缓存——手机中拿，如果还没有，那就只能去下载了。

有了 DiskLruCache，我们就可以很方便的将一部分内容缓存到手机存储中，做暂时的持久化保存，像我们经常用的一些新闻聚合类App、ZARKER等，基本都利用了 DiskLruCache，浏览过的网页，即使在没有网络的情况下，也可以浏览。

DiskLruCache

配置

DiskLruCache，听名字就知道是 LruCache的兄弟，只不过这个应该是Google的私生子，还没有像 LruCache一样添加到API中，所以我们只能去官网上下载 DiskLruCache的代码，其实也就一个类。下载地址：

https://developer.android.com/samples/DisplayingBitmaps/src/com.example.android.displayingbitmaps/util/DiskLruCache.html#l22

在工程中使用 DiskLruCache非常简单，只需要在项目中新建一个libcore.io的包，并将DiskLruCache.java文件copy过去即可。

初始化

在使用 DiskLruCache之前，我们需要对缓存的目录进行下配置， DiskLruCache并不需要限定缓存保存的位置，但一般情况下，我们的缓存都保存在缓存目录下： /sdcard/Android/data/package name/cache，当然，如果没有sdcard，那么我们就使用内置存储的缓存区域：/data/data/package name/cache。

在设置好缓存目录后，我们就可以使用DiskLruCache.open方法来创建DiskLruCache：

File cacheDir = getFileCache(context, "disk_caches");
if (!cacheDir.exists()) {
    cacheDir.mkdirs();
}
try {
    mDiskCaches = DiskLruCache.open(cacheDir, 1, 1, 10 * 1024 * 1024);
} catch (IOException e) {
    e.printStackTrace();
}

private File getFileCache(Context context, String cacheFileName) {
    String cachePath;
    if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
            || !Environment.isExternalStorageRemovable()) {
        cachePath = context.getExternalCacheDir().getPath();
    } else {
        cachePath = context.getCacheDir().getPath();
    }
    return new File(cachePath + File.separator + cacheFileName);
}

DiskLruCache.open方法有这样几个参数：

缓存目录

程序版本号：版本更新后，缓存清0

valueCount

缓存大小：随意，但也不能太任性，按字节算

应该不用解释了，唯一值得说的是valueCount这个参数，它是说同一个key可以对应Value的个数，一般都是1，基本没用。最后我们来看看最后返回的：

return new File(cachePath + File.separator + cacheFileName)

这里通过cacheFileName在缓存目录下再创建一个目录是干嘛呢？这个目录是用来对不同的缓存对象进行区分的，例如images、text等等。我们可以通过size()方法来获取所有缓存数据的大小。也可以使用delete()方法来删除所有缓存。

写入缓存

权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

都说了写缓存，那读写权限肯定是不能少了。

DiskLruCache写入缓存与使用SharedPreferences方法类似，需要使用Editor对象：

DiskLruCache.Editor editor = mDiskCaches.edit(key);

传入的key，就是我们需要下载的url地址，例如图片的地址，但是，url经常具有很多非法字符，这些会对我们的解析工作造成很多困难，而且，有时候我们的url地址也是需要保密的，所以我们经常通过MD5来进行url的加密，这样不仅可以加密，而且可以让所有的URL都变为规则的十六进制字符串。下面我们展示一个经典的写入缓存模板代码：

String key = toMD5String(url);

/////////////////////////////////////////////////////////////////////////////////
DiskLruCache.Editor editor = mDiskCaches.edit(key);
if (editor != null) {
    OutputStream outputStream = editor.newOutputStream(0);
    if (getBitmapUrlToStream(url, outputStream)) {
        editor.commit();
    } else {
        editor.abort();
    }
}
mDiskCaches.flush();
/////////////////////////////////////////////////////////////////////////////////

public String toMD5String(String key) {
    String cacheKey;
    try {
        final MessageDigest digest = MessageDigest.getInstance("MD5");
        digest.update(key.getBytes());
        cacheKey = bytesToHexString(digest.digest());
    } catch (NoSuchAlgorithmException e) {
        cacheKey = String.valueOf(key.hashCode());
    }
    return cacheKey;
}

private String bytesToHexString(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < bytes.length; i++) {
        String hex = Integer.toHexString(0xFF & bytes[i]);
        if (hex.length() == 1) {
            sb.append('0');
        }
        sb.append(hex);
    }
    return sb.toString();
}

private static boolean getBitmapUrlToStream(String urlString, OutputStream outputStream) {
    HttpURLConnection urlConnection = null;
    BufferedOutputStream out = null;
    BufferedInputStream in = null;
    try {
        final URL url = new URL(urlString);
        urlConnection = (HttpURLConnection) url.openConnection();
        in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
        out = new BufferedOutputStream(outputStream, 8 * 1024);
        int b;
        while ((b = in.read()) != -1) {
            out.write(b);
        }
        return true;
    } catch (final IOException e) {
        e.printStackTrace();
    } finally {
        if (urlConnection != null) {
            urlConnection.disconnect();
        }
        try {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        } catch (final IOException e) {
            e.printStackTrace();
        }
    }
    return false;
}

这里唯一的需要注意的是，下载的方法与我们之前使用的方法有所不同，主要是为了通用性，DiskLruCache将对应URL的内容以流的形式进行存储，文件名就是MD5加密后的字符串。

读取缓存

读取缓存的方法大家应该也能想到了，自然是调用get方法：

DiskLruCache.Snapshot snapShot = mDiskCaches.get(key);

不过它返回的是DiskLruCache的Snapshot对象。当我们获取到了Snapshot对象，就可以从它里面获取输出流，从而取出缓存的数据：

DiskLruCache.Snapshot snapShot = mDiskCaches.get(key);
InputStream is = snapShot.getInputStream(0);  
Bitmap bitmap = BitmapFactory.decodeStream(is);  
mImageView.setImageBitmap(bitmap);

移除缓存

移除缓存，我们可以猜到，我们需要使用remove方法来实现：

mDiskCache.remove(key);

当然，DiskLruCache并不希望我们手动去移除缓存，因为人家用了Lru算法，跟我们在内存中使用的算法一样，该死的时候，它自己会死。

与生命周期绑定

DiskLruCache在使用时，经常与我们的Activity的生命周期进行绑定，例如在onPause()方法中调用flush()方法，将内容与journal日志文件同步，在onDestroy()方法中去调用close()方法结束 DiskLruCache的open。

日志同步

通过前面的方法，我们已经可以缓存一个来自网络的图片了。下面我们进入缓存的文件夹，并查看里面的数据：

我们可以发现，这些文件，就是以MD5命名的缓存文件，它的最后面，有一个journal文件，我们通过cat命令打开：

这里我们选取一类记录，这些记录总是以dirty开头，然后clean，最后read。这个是什么意思呢？第一行dirty代表我们准备开始缓存数据，clean代表我们缓存到数据了，后面的30405代表缓存的大小，最后的read代表进行了读取操作。

看到这里，相信大家已经想起了我们非常熟悉的sqlite，它实际上也是利用文件来进行存储的。DiskLruCache实际上就是模拟了一个简化的sqlite，它的实现机制与sqlite基本类似。

引入二级缓存

ok，我们回到原来的项目，给工程增加二级缓存，导入DiskLruCache的源文件，这里就不讲了。我们在前面一级缓存的基础上，修改下ImageLoaderWithCaches类，创建ImageLoaderWithDoubleCaches类，这里面我们只需要在构造方法中增加对DiskLruCache的初始化，在AsyncTask中，我们来修改二级缓存的逻辑。前面的步骤相同，在取图像的时候都从内存缓存中取，如果取不到，那么在AsyncTask在硬盘缓存中取，如果还取不到，那就去下载，同时，将下载好的图像加入内存缓存，如果硬盘缓存中有，那么就直接加入内存缓存。看起来其实还是非常简单的，只要修改下AsyncTask即可。

package com.imooc.listviewacyncloader;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Environment;
import android.util.LruCache;
import android.widget.ImageView;
import android.widget.ListView;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashSet;
import java.util.Set;

import libcore.io.DiskLruCache;


public class ImageLoaderWithDoubleCaches {

    private Set<ASyncDownloadImage> mTasks;
    private LruCache<String, Bitmap> mMemoryCaches;
    private DiskLruCache mDiskCaches;
    private ListView mListView;

    public ImageLoaderWithDoubleCaches(Context context, ListView listview) {
        this.mListView = listview;
        mTasks = new HashSet<>();
        int maxMemory = (int) Runtime.getRuntime().maxMemory();
        int cacheSize = maxMemory / 10;
        mMemoryCaches = new LruCache<String, Bitmap>(cacheSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };

        File cacheDir = getFileCache(context, "disk_caches");
        if (!cacheDir.exists()) {
            cacheDir.mkdirs();
        }
        try {
            mDiskCaches = DiskLruCache.open(cacheDir, 1, 1, 10 * 1024 * 1024);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void showImage(String url, ImageView imageView) {
        Bitmap bitmap = getBitmapFromMemoryCaches(url);
        if (bitmap == null) {
            imageView.setImageResource(R.drawable.ic_launcher);
        } else {
            imageView.setImageBitmap(bitmap);
        }
    }

    public Bitmap getBitmapFromMemoryCaches(String url) {
        return mMemoryCaches.get(url);
    }

    public void addBitmapToMemoryCaches(String url, Bitmap bitmap) {
        if (getBitmapFromMemoryCaches(url) == null) {
            mMemoryCaches.put(url, bitmap);
        }
    }

    public void loadImages(int start, int end) {
        for (int i = start; i < end; i++) {
            String url = Images.IMAGE_URLS[i];
            Bitmap bitmap = getBitmapFromMemoryCaches(url);
            if (bitmap == null) {
                ASyncDownloadImage task = new ASyncDownloadImage(url);
                mTasks.add(task);
                task.execute(url);
            } else {
                ImageView imageView = (ImageView) mListView.findViewWithTag(url);
                imageView.setImageBitmap(bitmap);
            }
        }
    }

    private File getFileCache(Context context, String cacheFileName) {
        String cachePath;
        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
                || !Environment.isExternalStorageRemovable()) {
            cachePath = context.getExternalCacheDir().getPath();
        } else {
            cachePath = context.getCacheDir().getPath();
        }
        return new File(cachePath + File.separator + cacheFileName);
    }

    private static boolean getBitmapUrlToStream(String urlString, OutputStream outputStream) {
        HttpURLConnection urlConnection = null;
        BufferedOutputStream out = null;
        BufferedInputStream in = null;
        try {
            final URL url = new URL(urlString);
            urlConnection = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);
            out = new BufferedOutputStream(outputStream, 8 * 1024);
            int b;
            while ((b = in.read()) != -1) {
                out.write(b);
            }
            return true;
        } catch (final IOException e) {
            e.printStackTrace();
        } finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (final IOException e) {
                e.printStackTrace();
            }
        }
        return false;
    }

    public void cancelAllTasks() {
        if (mTasks != null) {
            for (ASyncDownloadImage task : mTasks) {
                task.cancel(false);
            }
        }
    }

    public String toMD5String(String key) {
        String cacheKey;
        try {
            final MessageDigest digest = MessageDigest.getInstance("MD5");
            digest.update(key.getBytes());
            cacheKey = bytesToHexString(digest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(key.hashCode());
        }
        return cacheKey;
    }

    private String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }

    public void flushCache() {
        if (mDiskCaches != null) {
            try {
                mDiskCaches.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    class ASyncDownloadImage extends AsyncTask<String, Void, Bitmap> {

        private String url;

        public ASyncDownloadImage(String url) {
            this.url = url;
        }

        @Override
        protected Bitmap doInBackground(String... params) {
            url = params[0];
            FileDescriptor fileDescriptor = null;
            FileInputStream fileInputStream = null;
            DiskLruCache.Snapshot snapShot = null;
            String key = toMD5String(url);
            try {
                snapShot = mDiskCaches.get(key);
                if (snapShot == null) {
                    DiskLruCache.Editor editor = mDiskCaches.edit(key);
                    if (editor != null) {
                        OutputStream outputStream = editor.newOutputStream(0);
                        if (getBitmapUrlToStream(url, outputStream)) {
                            editor.commit();
                        } else {
                            editor.abort();
                        }
                    }
                    snapShot = mDiskCaches.get(key);
                }
                if (snapShot != null) {
                    fileInputStream = (FileInputStream) snapShot.getInputStream(0);
                    fileDescriptor = fileInputStream.getFD();
                }
                Bitmap bitmap = null;
                if (fileDescriptor != null) {
                    bitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor);
                }
                if (bitmap != null) {
                    addBitmapToMemoryCaches(params[0], bitmap);
                }
                return bitmap;
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (fileDescriptor == null && fileInputStream != null) {
                    try {
                        fileInputStream.close();
                    } catch (IOException e) {
                    }
                }
            }
            return null;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            ImageView imageView = (ImageView) mListView.findViewWithTag(url);
            if (imageView != null && bitmap != null) {
                imageView.setImageBitmap(bitmap);
            }
            mTasks.remove(this);
        }
    }
}

整体代码与之前使用一级缓存的代码基本相同，大家只要在AsyncTask修改一定逻辑就好了。

再次运行程序，与之前使用一级缓存的图相同，这里就不贴了，只是这里在断网后，同样可以加载缓存中的图片。

以上，未完待续，后面我们会进一步优化>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

代码下载地址 http://download.csdn.net/detail/x359981514/8562525

Android异步加载全解析之引入二级缓存

Android异步加载全解析之引入二级缓存

为啥要二级缓存

DiskLruCache

配置

初始化

写入缓存

读取缓存

移除缓存

与生命周期绑定

日志同步

引入二级缓存

热门文章

最新文章

相关课程

相关电子书

相关实验场景

推荐镜像