Android图片缓存分析（一）

Android中写应用时，经常会遇到加载图片的事，由于很多图片是网络上下载获取的，当我们进页面时，便会去网络下载图片，一两次可能没啥问题，但如果同一张图片每次都去网络拉取，不仅速度慢，更影响用户体验，同时会浪费用户的流量。

基于此，很多人便想到了图片缓存的方法。

现在比较普遍的图片缓存主要有以下几个步骤：

一、从缓存中获取图片

二、如果缓存中未获取图片，则从存储卡中获取

三、如果存储卡中未获取图片，则从网络中获取

一、从缓存中获取图片

我们知道，Android中分配给每个应用的内存空间是有限的，不能无限使用，所以我们使用缓存存储的图片也是有限的，为了更有效的利用的这有限的存储空间，程序员们便想出了使用硬引用和软引用两种方式存储图片。

首先介绍下硬引用和软引用：

硬引用：表示持有当前对象的引用是强关系的，即使oom了，gc也不会回收改对象。

软引用：如果内存空间足够，垃圾回收器不会回收它，当内存不足时，，就会回收这些对象的内存。

基于以上两种引用特性，在缓存中存储图片时，一般是先将图片存储到硬引用，当硬引用空间不足时，则将最早存储到硬引用的图片存储到软引用空间，对应代码如下：

package meizu.imagecachemanager;

import android.app.ActivityManager;
import android.content.Context;
import android.graphics.Bitmap;
import android.support.v4.util.LruCache;

import java.lang.ref.SoftReference;
import java.util.LinkedHashMap;

/**
 * Created by taomaogan on 15-3-30.
 */
public class ImageMemoryCache {
    private static final String TAG = "Cache";

    //软引用缓存容量
    private static final int SOFT_CACHE_SIZE = 15;
    //硬引用缓存
    private static LruCache<String, Bitmap> mLruCache;
    //软引用缓存
    private static LinkedHashMap<String, SoftReference> mSoftCache;
　　
    private int mLruCacheSize = -1;

    public ImageMemoryCache(Context context) {
        this(context, -1);
    }

    //硬引用缓存可配置
    public ImageMemoryCache(Context context, int lruCacheSize) {
        mLruCacheSize = lruCacheSize;
        if (mLruCacheSize <= 0) {
            //设置默认硬引用缓存大小
            int memoryClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
            mLruCacheSize = 1024 * 1024 * memoryClass / 4;
        }
        mLruCache = new LruCache<String, Bitmap>(mLruCacheSize) {

            @Override
            protected int sizeOf(String key, Bitmap value) {
                if (value != null) {
                    //计算每张图片的像素数量
                    return value.getRowBytes() * value.getHeight();
                }
                return 0;
            }

            @Override
            protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
                if (oldValue != null) {
                    //当强引用空间不足时，将图片存入软引用
                    android.util.Log.d(TAG, "I am from SoftReference save!------");
                    mSoftCache.put(key, new SoftReference(oldValue));
                }
            }
        };

        mSoftCache = new LinkedHashMap(SOFT_CACHE_SIZE, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Entry eldest) {
                if (size() > SOFT_CACHE_SIZE) {
                    return true;
                }
                return false;
            }
        };
    }

    public Bitmap getBitmapFromCache(String url) {
        Bitmap bitmap;
        //硬引用中获取图片
        synchronized (mLruCache) {
            bitmap = mLruCache.get(url);
            if (bitmap != null) {
                android.util.Log.d(TAG, "I am from LruCache!------");
                mLruCache.remove(url);
                mLruCache.put(url, bitmap);
                return bitmap;
            }
        }
        //当硬引用中未获取到图片时，从软引用中获取
        synchronized (mSoftCache) {
            SoftReference<Bitmap> bitmapReference = mSoftCache.get(url);
            if (bitmapReference != null) {
                bitmap = bitmapReference.get();
                if (bitmap != null) {
                    mLruCache.put(url, bitmap);
                    mSoftCache.remove(url);
                    android.util.Log.d(TAG, "I am from SoftCache!------");
                    return bitmap;
                } else {
                    mSoftCache.remove(url);
                }
            }
        }

        return null;
    }

    public void addBitmapToCache(String url, Bitmap bitmap) {
        if (bitmap != null) {
            synchronized (mLruCache) {
                android.util.Log.d(TAG, "I am from LruCache save!------");
                mLruCache.put(url, bitmap);
            }
        }
    }


}

上面代码getBitmapFromCache中可以看到程序首先去硬引用中寻找图片，当寻找不到时，则去软引用中寻找。

而在构造函数中mLruCache的初始化中可以看到，当硬引用空间不足时，图片会存储到软引用空间。

二、如果缓存中未获取图片，则从存储卡中获取

在缓存中查找不到图片时，我们会考虑从sd卡获取，代码如下：

package meizu.imagecachemanager;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Environment;
import android.os.StatFs;
import android.widget.Filter;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Comparator;

/**
 * Created by taomaogan on 15-3-30.
 */
public class ImageFileCache {
    private static final String TAG = "Cache";

    private static final String CACHE_DIR = "imageCache";
    private static final String WHOLESALE_CONV = ".cach";

    private static final int MB = 1024 * 1024;
    private static final int CACHE_SIZE = 10;
    private static final int FREE_SD_SPACE_NEEDED_TO_CACHE = 10;

    public ImageFileCache() {
        removeCache(getDirectory());
    }

    public Bitmap getImageFromFile(String url) {
        String path = getDirectory() + "/" + covertUrlToFileName(url);
        File file = new File(path);
        if (file.exists()) {
            Bitmap bitmap = BitmapFactory.decodeFile(path);
            if (bitmap == null) {
                file.delete();
            } else {
                updateFileTime(path);
                android.util.Log.d(TAG, "I am from FileCache!------");
                return bitmap;
            }
        }
        return null;
    }

    /**
     * 将图片存储到sd卡
     * @param url
     * @param bitmap
     */
    public void saveBitmap(String url, Bitmap bitmap) {
        if (bitmap == null) {
            return;
        }

        //保证存储控空间足够
        if (FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) {
            return;
        }

        //文件名
        String fileName = covertUrlToFileName(url);
        //sd卡路径
        String dir = getDirectory();
        File dirFile = new File(dir);
        //判断路径是否存在
        if (!dirFile.exists()) {
            dirFile.mkdirs();
        }

        File file = new File(dir + "/" + fileName);
        try {
            file.createNewFile();
            OutputStream outputStream = new FileOutputStream(file);
            //存储png图片,图片质量为最高,意味着当存储大图时，效率低，有可能oom
            bitmap.compress(Bitmap.CompressFormat.JPEG, 100, outputStream);
            android.util.Log.d(TAG, "I am from FileCache save!------");
            outputStream.flush();
            outputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private boolean removeCache(String dirPath) {
        File dir = new File(dirPath);
        File[] files = dir.listFiles();
        if (files == null) {
            return true;
        }
        //sd卡是否有读取权限
        if (!android.os.Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            return false;
        }

        int dirSize = 0;
        for (int i = 0; i < files.length; i++) {
            if (files[i].getName().contains(WHOLESALE_CONV)) {
                dirSize += files[i].length();
            }
        }

        if (dirSize > CACHE_SIZE * MB || FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) {
            int removeFactor = (int) ((0.4 * files.length) + 1);
            Arrays.sort(files, new FileLastModifSort());
            for (int i = 0; i < removeFactor; i++) {
                if (files[i].getName().contains(WHOLESALE_CONV)) {
                    files[i].delete();
                }
            }
        }
        //可用空间比需要的空间少
        if (freeSpaceOnSd() <= CACHE_SIZE) {
            return false;
        }

        return true;
    }

    public void updateFileTime(String path) {
        File file = new File(path);
        long newModifiedTime = System.currentTimeMillis();
        file.setLastModified(newModifiedTime);
    }

    private int freeSpaceOnSd() {
        StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getPath());
        double sdFreeMB = ((double) statFs.getAvailableBlocksLong() * (double) statFs.getBlockSizeLong()) / MB;
        return (int) sdFreeMB;
    }

    private String covertUrlToFileName(String url) {
        String[] strs = url.split("/");
        return strs[strs.length - 1] + WHOLESALE_CONV;
    }

    private String getDirectory() {
        String dir = getSDPath() + "/" + CACHE_DIR;
        return dir;
    }

    private String getSDPath() {
        File sdDir = null;
        boolean sdCardExist = Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED);
        if (sdCardExist) {
            sdDir = Environment.getExternalStorageDirectory();
        }
        if (sdDir != null) {
            return sdDir.toString();
        } else {
            return "";
        }
    }

    private class FileLastModifSort implements Comparator<File> {

        @Override
        public int compare(File lhs, File rhs) {
            if (lhs.lastModified() > rhs.lastModified()) {
                return 1;
            } else if (lhs.lastModified() == rhs.lastModified()) {
                return 0;
            } else {
                return -1;
            }
        }
    }
 }

上面的代码很简单，saveBitmap是存储图片，存储图片之前，检查一下sd卡权限，sd卡空间大小，并去从上面的注释中我们可以看到，其实本篇文章其实是不适合大图片存储的；getImageFromFile则是从存储卡中读取图片。

如果经过缓存，sd卡还是未获取到图片，最后只能通过网络获取了。

三、如果存储卡中未获取图片，则从网络中获取

网络下载图片，这里仅支持通过http获取，代码如下：

package meizu.imagecachemanager;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.DefaultHttpClient;

import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;

/**
 * Created by taomaogan on 15-3-30.
 */
public class ImageGetFromHttp {
    private static final String TAG = "Cache";

    public static Bitmap downloadBitmap(String url) {
        final HttpClient httpClient = new DefaultHttpClient();
        final HttpGet httpGet = new HttpGet(url);

        try {
            HttpResponse httpResponse = httpClient.execute(httpGet);
            int statusCode = httpResponse.getStatusLine().getStatusCode();
            if (statusCode != HttpStatus.SC_OK) {
                return null;
            }

            final HttpEntity httpEntity = httpResponse.getEntity();
            if (httpEntity != null) {
                InputStream inputStream = null;
                try {
                    inputStream = httpEntity.getContent();
                    FilterInputStream fileInputStream = new FlushedInputStream(inputStream);
                    android.util.Log.d(TAG, "I am from Http!------");
                    return BitmapFactory.decodeStream(fileInputStream);
                } finally {
                    if (inputStream != null) {
                        inputStream.close();
                    }

                    httpEntity.consumeContent();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalStateException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private static class FlushedInputStream extends FilterInputStream {

        /**
         * Constructs a new {@code FilterInputStream} with the specified input
         * stream as source.
         * <p/>
         * <p><strong>Warning:</strong> passing a null source creates an invalid
         * {@code FilterInputStream}, that fails on every method that is not
         * overridden. Subclasses should check for null in their constructors.
         *
         * @param in the input stream to filter reads on.
         */
        protected FlushedInputStream(InputStream in) {
            super(in);
        }

        @Override
        public long skip(long byteCount) throws IOException {
            long totalBytesSkipped = 0l;
            while (totalBytesSkipped < byteCount) {
                long bytesSkipped = in.skip(byteCount - totalBytesSkipped);
                if (bytesSkipped == 0l) {
                    int by = read();
                    if (by < 0) {
                        break;
                    } else {
                        bytesSkipped = 1;
                    }
                }
                totalBytesSkipped += bytesSkipped;
            }
            return totalBytesSkipped;
        }
    }
}

以上便是3种获取图片的流程，汇总如下：

public Bitmap getBitmap(String url) {
        Bitmap bitmap = mImageMemoryCache.getBitmapFromCache(url);
        if (bitmap == null) {
            bitmap = mImageFileCache.getImageFromFile(url);
            if (bitmap == null) {
                bitmap = ImageGetFromHttp.downloadBitmap(url);
                if (bitmap != null) {
                    mImageFileCache.saveBitmap(url, bitmap);
                    mImageMemoryCache.addBitmapToCache(url, bitmap);
                }
            } else {
                mImageMemoryCache.addBitmapToCache(url, bitmap);
            }
        }
        return bitmap;
    }

以上代码是先从缓存读取图片，然后从文件读取图片，最后从网络下载图片，需要注意的是，从网络下载图片成功后，分别将其存储到sd卡和缓存中，不然以上实现的缓存便无意义了。

以上便是图片缓存的比较简单流程了，可以在demo中使用，为什么是仅仅在demo中使用呢？因为真正的图片下载缓存还需要用到线程池，像以上图片下载每次都需要手动新建线程，还是比较麻烦。

上面图片缓存的优点是：增强了用户体验，节省了用户流量

　　　　　　　缺点是：加载大图片时容易产生oom问题

关于以上问题，以后会继续分析。

引用：

http://keegan-lee.diandian.com/post/2012-12-06/40047548955

源码：

https://github.com/taothreeyears/ImageCache