由LruCache和DiskLruCache提供三级缓存支持的ImageLoader

从三天前一直报错到今天中午，总算出了个能用的版本了。

一如既往先发链接：

https://github.com/mlxy/ImageLoader

缓存处理

·LruCacheHelper:

封装第一级缓存，也就是内存缓存的处理。

LruCache是Android自带的缓存处理类，如名字所说，和使用软引用的映射相比，优势在于可以忽略缓存上限处理的细节问题，初始化时在构造函数中给一个缓存上限即可。一般做法是使用最大内存的八分之一：

Runtime.getRuntime().maxMemory() / 8

但是我觉得八分之一实在太少，所以干脆给了三分之一。

另外在初始化时需要重写LruCache类的sizeOf方法来自行计算图片的大小并返回，默认情况返回的是图片数量。

封装类给出四个接口，分别是打开和关闭，保存和读取。

没什么好说的，直接放代码。

public class LruCacheHelper {
    private LruCacheHelper() {}

    private static LruCache<String, Bitmap> mCache;

    /** 初始化LruCache。 */
    public static void openCache(int maxSize) {
        mCache = new LruCache<String, Bitmap>((int) maxSize) {
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight();
            }
        };
    }

    /** 把图片写入缓存。 */
    public static void dump(String key, Bitmap value) {
        mCache.put(key, value);
    }

    /** 从缓存中读取图片数据。 */
    public static Bitmap load(String key) {
        return mCache.get(key);
    }

    public static void closeCache() {
        // 暂时没事干。
    }
}

·DiskLruCacheHelper:

DiskLruCache工具的使用以及这个类的基本介绍可以参考我前两天写的基于Demo解析缓存工具DiskLruCache。

为了适应这个工程的需要对这个封装类做了一点变动，直接保存和读取Bitmap。

依然没什么好说的，直接看代码。

public class DiskLruCacheHelper {
    private DiskLruCacheHelper() {}

    private static DiskLruCache mCache;

    /** 打开DiskLruCache。 */
    public static void openCache(Context context, int appVersion, int maxSize) {
        try {
            if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())
                    || !Environment.isExternalStorageRemovable()) {
                mCache = DiskLruCache.open(context.getExternalCacheDir(), appVersion, 1, maxSize);
            } else {
                mCache = DiskLruCache.open(context.getCacheDir(), appVersion, 1, maxSize);
            }
        } catch (IOException e) { e.printStackTrace(); }
    }

    /** 写出缓存。 */
    public static void dump(Bitmap bitmap, String keyCache) throws IOException {
        if (mCache == null) throw new IllegalStateException("Must call openCache() first!");

        DiskLruCache.Editor editor = mCache.edit(Digester.hashUp(keyCache));

        if (editor != null) {
            OutputStream outputStream = editor.newOutputStream(0);
            boolean success = bitmap.compress(Bitmap.CompressFormat.PNG, 100, outputStream);

            if (success) {
                editor.commit();
            } else {
                editor.abort();
            }
        }
    }

    /** 读取缓存。 */
    public static Bitmap load(String keyCache) throws IOException {
        if (mCache == null) throw new IllegalStateException("Must call openCache() first!");

        DiskLruCache.Snapshot snapshot = mCache.get(Digester.hashUp(keyCache));

        if (snapshot != null) {
            InputStream inputStream = snapshot.getInputStream(0);
            Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
            return bitmap;
        }

        return null;
    }

    /** 检查缓存是否存在。 */
    public static boolean hasCache(String keyCache) {
        try {
            return mCache.get(Digester.hashUp(keyCache)) != null;
        } catch (IOException e) {
            e.printStackTrace();
        }

        return false;
    }

    /** 同步日志。 */
    public static void syncLog() {
        try {
            mCache.flush();
        } catch (IOException e) { e.printStackTrace(); }
    }

    /** 关闭DiskLruCache。 */
    public static void closeCache() {
        syncLog();
    }
}

ImageLoader主类

从接口说起，类依然是四个接口，初始化，关闭，载入图片，取消载入。

载入分三步，逐级访问三级缓存。

·一：

首先使用内存缓存的封装类调取内存缓存，如果内存中有，就直接显示。

/** 从内存缓存中加载图片。 */
private boolean loadImageFromMemory(View parent, String url) {
    Bitmap bitmap = LruCacheHelper.load(url);
    if (bitmap != null) {
        setImage(parent, bitmap, url);
        return true;
    }

    return false;
}

返回一个标志位用以判断是否已经加载成功。

如果没成功就要访问第二级缓存也即磁盘缓存了，使用封装类检查缓存存在与否，之后分成两个分支。

·二：

如果磁盘缓存已经存在了，就启动读取磁盘缓存的任务。

启动时记得把任务加入一个HashMap中，用于在被外部中断或程序执行结束时取消任务。

任务使用Android自带的AsyncTask异步任务类。

编写一个类，继承AsyncTask并指定泛型。

class LoadImageDiskCacheTask extends AsyncTask<String, Void, Bitmap>

泛型第一位是启动任务时传入的参数类型，我们这里要传入的是图片的URL，所以用String。

这个参数在用AsyncTask.execute(Params...)启动任务时传入，在继承AsyncTask类必须重写的抽象方法doInBackground(Params...)中接收。

第二位是进度的类型。在任务执行的过程中，可以调用publishProgress(Progress)方法不断更新任务进度，比如已下载的文件大小或者已经删除的文件数量之类。

之后重写onProgressUpdate(Progress)方法，在进度更新时做出相应处理，比如修改进度条的值。

在这里我们不需要进度的处理，所以直接给Void，注意V大写。

泛型第三位就是任务结束后返回的结果的类型了。

重写onPostExecute(Result)方法，参数就是doInBackground方法返回的结果。在这里接收图片并显示就可以了。

注意，doInBackground方法是在新线程中执行，而onPostExecute是在主线程中执行的，这也是这个类高明的地方之一，使用AsyncTask类从头至尾都不需要手动处理线程问题，只需要关注业务逻辑。

之后可能研究一下这个类再单独写一篇博文。

在磁盘缓存读取成功之后我们也在内存缓存中保存一份。

·三：

如果没有磁盘缓存，比如第一次打开应用程序的时候，就需要从网络上重新下载图片了。

依旧是继承AsyncTask类，在doInBackground方法中联网下载图片，下载成功后分别保存到磁盘缓存和内存缓存，之后再onPostExecute方法中显示图片。

逻辑和第二步是一样的。

·显示图片：

但是。

如果就这么不管不顾地开始用，比如用在一个纯图片的ListView中，就会发现在滑动ListView的时候有时图片会显示不出来，有时还会不停闪烁。

问题就出在多线程上。

如果使用Google官方推荐的ListView优化方式，也就是在列表适配器中的getView方法里复用convertView

if (convertView == null) {
    imageView = (ImageView) View.inflate(MainActivity.this, R.layout.image_view, null);

    convertView = imageView;
} else {
    imageView = (ImageView) convertView;
}

的话，由于读取图片需要一定的时间，当图片读取完毕时，传给ImageLoader的那个ImageView可能已经不是当初的那个ImageView了。

我在解决这个问题时，发现网上多数的建议是给ImageView绑定URL作为Tag，然后在显示图片时检查Tag和URL是否一致，不一致就不显示。

但是不显示明显不行啊。

我的解决办法是改变思路。

在调用ImageLoader.load时传入的不是符合直觉的ImageView和URL，而是getView的第三个参数，ImageView的父视图parent和URL，到了显示图片的时候再在主线程中用View.findViewWithTag方法来现场获取ImageView并设置图片。

这样就成功地避免了图片的显示错位。

·OutOfMemory异常：

其实这个异常在正常情况下不是很容易出现了，这里只提供一个思路。

给ListView绑定RecyclerListener，实现onMovedToScrapHeap(View)方法，这个方法在列表项移出屏幕外时会被调用，我们在这个方法中取消图片的加载任务，始终保持只加载屏幕内的图片，基本就不会出现内存不够用的情况了。

当然，如果图片实在太大，那就要在解析Bitmap的时候配合Options来自行缩放图片大小，那就是另一回事了。

最后还是代码说话：

public class ImageLoader {
    private static final int MEMORY_CACHE_SIZE_LIMIT =
            (int) (Runtime.getRuntime().maxMemory() / 3);
    private static final int LOCAL_CACHE_SIZE_LIMIT =
            100 * 1024 * 1024;

    private static final int NETWORK_TIMEOUT = 5000;

    private HashMap<String, AsyncTask> taskMap = new HashMap<>();

    public ImageLoader(Context context) {
        initMemoryCache();
        initDiskCache(context);
    }

    /** 初始化内存缓存器。 */
    private void initMemoryCache() {
        LruCacheHelper.openCache(MEMORY_CACHE_SIZE_LIMIT);
    }

    /** 初始化磁盘缓存器。 */
    private void initDiskCache(Context context) {
        int appVersion = 1;
        try {
            appVersion = context.getPackageManager().getPackageInfo(context.getPackageName(), 0).versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }

        DiskLruCacheHelper.openCache(context, appVersion, LOCAL_CACHE_SIZE_LIMIT);
    }

    /** 载入图片。
     *  @param parent 要显示图片的视图的父视图。
     *  @param url 要显示的图片的URL。
     * */
    public void load(View parent, String url) {
        // 尝试从内存缓存载入图片。
        boolean succeeded = loadImageFromMemory(parent, url);
        if (succeeded) return;

        boolean hasCache = DiskLruCacheHelper.hasCache(url);
        if (hasCache) {
            // 有磁盘缓存。
            loadImageFromDisk(parent, url);
        } else {
            // 联网下载。
            loadFromInternet(parent, url);
        }
    }

    /** 取消任务。 */
    public void cancel(String tag) {
        AsyncTask removedTask = taskMap.remove(tag);
        if (removedTask != null) {
            removedTask.cancel(false);
        }
    }

    /** 从内存缓存中加载图片。 */
    private boolean loadImageFromMemory(View parent, String url) {
        Bitmap bitmap = LruCacheHelper.load(url);
        if (bitmap != null) {
            setImage(parent, bitmap, url);
            return true;
        }

        return false;
    }

    /** 从磁盘缓存中加载图片。 */
    private void loadImageFromDisk(View parent, String url) {
        LoadImageDiskCacheTask task = new LoadImageDiskCacheTask(parent);
        taskMap.put(url, task);
        task.execute(url);
    }

    /** 从网络上下载图片。 */
    private void loadFromInternet(View parent, String url) {
        DownloadImageTask task = new DownloadImageTask(parent);
        taskMap.put(url, task);
        task.execute(url);
    }

    /** 把图片保存到内存缓存。 */
    private void putImageIntoMemoryCache(String url, Bitmap bitmap) {
        LruCacheHelper.dump(url, bitmap);
    }

    /** 把图片保存到磁盘缓存。 */
    private void putImageIntoDiskCache(String url, Bitmap bitmap) throws IOException {
        DiskLruCacheHelper.dump(bitmap, url);
    }

    /** 重新设置图片。 */
    private void setImage(final View parent, final Bitmap bitmap, final String url) {
        parent.post(new Runnable() {
            @Override
            public void run() {
                ImageView imageView = findImageViewWithTag(parent, url);
                if (imageView != null) {
                    imageView.setImageBitmap(bitmap);
                }
            }
        });
    }

    /** 根据Tag找到指定的ImageView。 */
    private ImageView findImageViewWithTag(View parent, String tag) {
        View view = parent.findViewWithTag(tag);
        if (view != null) {
            return (ImageView) view;
        }

        return null;
    }

    /** 读取图片磁盘缓存的任务。 */
    class LoadImageDiskCacheTask extends AsyncTask<String, Void, Bitmap> {
        private final View parent;
        private String url;

        public LoadImageDiskCacheTask(View parent) {
            this.parent = parent;
        }

        @Override
        protected Bitmap doInBackground(String... params) {
            Bitmap bitmap = null;

            url = params[0];
            try {
                bitmap = DiskLruCacheHelper.load(url);

                if (bitmap != null && !isCancelled()) {
                    // 读取完成后保存到内存缓存。
                    putImageIntoMemoryCache(url, bitmap);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            // 显示图片。
            if (bitmap != null) setImage(parent, bitmap, url);
            // 移除任务。
            if (taskMap.containsKey(url)) taskMap.remove(url);
        }
    }

    /** 下载图片的任务。 */
    class DownloadImageTask extends AsyncTask<String, Void, Bitmap> {
        private final View parent;
        private String url;

        public DownloadImageTask(View parent) {
            this.parent = parent;
        }

        @Override
        protected Bitmap doInBackground(String... params) {
            Bitmap bitmap = null;

            url = params[0];
            try {
                // 下载并解析图片。
                InputStream inputStream = NetworkAdministrator.openUrlInputStream(url, NETWORK_TIMEOUT);
                bitmap = BitmapFactory.decodeStream(inputStream);

                if (bitmap != null && !isCancelled()) {
                    // 保存到缓存。
                    putImageIntoMemoryCache(url, bitmap);
                    putImageIntoDiskCache(url, bitmap);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

            return bitmap;
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            // 显示图片。
            if (bitmap != null) setImage(parent, bitmap, url);
            // 移除任务。
            if (taskMap.containsKey(url)) taskMap.remove(url);
        }
    }

    /** 使用完毕必须调用。 */
    public void close() {
        for (Map.Entry<String, AsyncTask> entry : taskMap.entrySet()) {
            entry.getValue().cancel(true);
        }

        DiskLruCacheHelper.closeCache();
        LruCacheHelper.closeCache();
    }
}

碎碎念

我怎么觉得我今天行文风格有点异常……