图片缓存LruCache和DiskLruCache的使用

前言

作为一个Android技术小白，感觉自己各方面知识与技能都存在欠缺、不足，知识体系不够系统。是时候整理一下学习知识和技术点，慢慢梳理，架构体系，如此才能有利于自身技术的更好发展。Android属于开源操作系统，若要快速开发App，最好是学会很好的使用各种优秀的开源框架，一方面完成工作项目，同行也是提升自己代码能力。
今天就先从内存缓存的优秀框架DiskLruCache和LruCache开始学习，毕竟Android新手开发都会经历一个OOM的处理问题，一个优秀的App开发中必须考虑资源优化的问题。闲言少续，言归正传。
这里声明学习了郭霖大神的几篇文章LruCache、DiskLruCache以及两者结合使用的Demo解析。
在此膜拜一下~~。

LruCache

Android开发中我们都知道，大量的加载图片会导致内存泄露，也就是OOM，通常我们都会根据原始图片尺寸、设备屏幕尺寸、分辨率以及显示图片的view控件的大小，来使用图片压缩方式，减少资源占用。
然而尽管如此，大量的图片资源消耗的内存也是相当惊人的。不论是listView还是GridView中，我们都会做定期的资源缓存和无用资源清理。
若是从网络段加载图片，我们就要考虑到用户流量的问题，流量也是资源！除了使用图片压缩，就需要结合使用图片内存缓存技术了。

/**
 * 解析图片，生成Bitmap对象。
 */
public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,  
        int reqWidth, int reqHeight) {  
    // 第一次解析将inJustDecodeBounds设置为true，来获取图片大小  
    final BitmapFactory.Options options = new BitmapFactory.Options();  
    options.inJustDecodeBounds = true;  
    BitmapFactory.decodeResource(res, resId, options);  
    // 调用下面定义的方法计算inSampleSize值  
    options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);  
    // 使用获取到的inSampleSize值再次解析图片  
    options.inJustDecodeBounds = false;  
    return BitmapFactory.decodeResource(res, resId, options);  
}  
/**
 * 计算图片缩放比例
 */
public static int calculateInSampleSize(BitmapFactory.Options options,  
        int reqWidth, int reqHeight) {  
    // 源图片的高度和宽度  
    final int height = options.outHeight;  
    final int width = options.outWidth;  
    int inSampleSize = 1;  
    if (height > reqHeight || width > reqWidth) {  
        // 计算出实际宽高和目标宽高的比率  
        final int heightRatio = Math.round((float) height / (float) reqHeight);  
        final int widthRatio = Math.round((float) width / (float) reqWidth);  
        // 选择宽和高中最小的比率作为inSampleSize的值，这样可以保证最终图片的宽和高  
        // 一定都会大于等于目标的宽和高。  
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;  
    }  
    return inSampleSize;  
}  

注：此处找到一个关于图片压缩的比较不错的博客一叶飘舟–Bitmap压缩。
LruCache是Google官方提供的内存缓存类，其内部源码详解请移步上面大牛的博客。此处仅作简单的使用说明：

private LruCache<String, Bitmap> mMemoryCache;  //LruCache对象

@Override  
protected void onCreate(Bundle savedInstanceState) {  
    // 获取到可用内存的最大值，使用内存超出这个值会引起OutOfMemory异常。  
    // LruCache通过构造函数传入缓存值，以KB为单位。  
    int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);  
    // 使用最大可用内存值的1/8作为缓存的大小。  
    int cacheSize = maxMemory / 8;  
    mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {  
        @Override  
        protected int sizeOf(String key, Bitmap bitmap) {  
            // 重写此方法来衡量每张图片的大小，默认返回图片数量。  
            return bitmap.getByteCount() / 1024;  
        }  
    };  
}  
//首次使用，将图片资源添加到内存中
public void addBitmapToMemoryCache(String key, Bitmap bitmap) {  
    if (getBitmapFromMemCache(key) == null) {  
        mMemoryCache.put(key, bitmap);  
    }  
}  
//从内存缓存获取图片资源
public Bitmap getBitmapFromMemCache(String key) {  
    return mMemoryCache.get(key);  
}  

//加载图片时候，会看看有没有缓存，没有的话，在重新构建，有则使用缓存
public void loadBitmap(int resId, ImageView imageView) {  
    final String imageKey = String.valueOf(resId);  
    final Bitmap bitmap = getBitmapFromMemCache(imageKey);  
    if (bitmap != null) {  
        imageView.setImageBitmap(bitmap);  
    } else {  
        imageView.setImageResource(R.drawable.image_placeholder);  
        BitmapWorkerTask task = new BitmapWorkerTask(imageView);  
        task.execute(resId);  
    }  
}  

//后台Task加载图片资源
class BitmapWorkerTask extends AsyncTask<Integer, Void, Bitmap> {  
    // 在后台加载图片。  
    @Override  
    protected Bitmap doInBackground(Integer... params) {  
        final Bitmap bitmap = decodeSampledBitmapFromResource(  
                getResources(), params[0], 100, 100);  
        addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);  
        return bitmap;  
    }  
}

在此说明一下，以前认为的使用什么软引用、弱引用来保存资源引用的方式，不再提倡，而且也不能保证优化效果了，因为高版本的Android中Java回收机制，会偏向于回收这些引用，从而并不能很好的起到缓存的作用。

DiskLruCache

DiskLruCache类似于LruCache，其是将资源缓存在外部存储磁盘上，而不是内存，这样就可以有相对更为充足的资源空间，缓存更多的数据。具体的原理介绍，同样烦请移步上面大神的博客。此处仅作简要使用说明：

• 先贴出DiskLruCache中使用到的工具类文件

//DiskLruCache中使用到的工具方法
public class Utils {
    /**
     * 获取缓存文件夹，这里优先选择SD卡下面的android/data/packageName/cache/路径，若没有SD卡，就选择data/data/packageName/cache
     *
     * @param context    上下文环境
     * @param uniqueName 缓存文件夹名称
     * @return 返回缓存文件
     */
    public static File getDiskCacheDir(Context context, String uniqueName) {
        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 + uniqueName);
    }

    /**
     * 获取本App的版本号
     *
     * @param context context上下文
     * @return 返回版本号
     */
    public static int getAppVersion(Context context) {
        try {
            PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
            return info.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 1;
    }

    /**
     * 给字符串来个md5加密，
     * @param key 需要加密的string
     * @return 返回加密后的string ，或者加密失败，就返回string的哈希值
     */
    public static String hashKeyForDisk(String key) {
        String cacheKey;
        try {
            //md5加密
            MessageDigest mDigest = MessageDigest.getInstance("MD5");
            mDigest.update(key.getBytes());
            cacheKey = bytesToHexString(mDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            //若md5加密失败，就用哈希值
            cacheKey = String.valueOf(key.hashCode());
        }
        return cacheKey;
    }

    /**
     * 字节数组转为十六进制字符串
     * @param bytes 字节数组
     * @return 返回十六进制字符串
     */
    private static String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length()==1){
                sb.append('0');
            }
            sb.append(hex);
        }
        return sb.toString();
    }
}

• DiskLruCache的使用

public class MainActivity extends AppCompatActivity {
    DiskLruCache mDiskLruCache = null;//diskLruCache的对象
    String imgUrl = "https://img-my.csdn.net/uploads/201309/01/1378037235_7476.jpg";//图片链接

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化缓存配置
        openCache();
    }

    /**
     * 初始化缓存配置
     */
    private void openCache() {
        try {
            //缓存图片数据的文件夹
            File cacheDir = Utils.getDiskCacheDir(this, "bitmap");
            if (!cacheDir.exists()) {
                //使用mkdirs可以连同上级文件夹一同创建，否则mkdir可能会报错
                cacheDir.mkdirs();
            }
            //参数，1、缓存目录；2、app版本号，因为它认为版本升级，缓存就没必要保存。3、一个key值对应多少个缓存文件，一般1个。4、单个缓存多大，10M就够了。
            //超过最大缓存限制的，就会被自动清除了，所以一般不用程序中调用removeCache。
            mDiskLruCache = DiskLruCache.open(cacheDir, Utils.getAppVersion(this), 1, 10 * 1024 * 1024);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 写入缓存
     */
    public void writeCache(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                //将图片的url地址md5 加密后，生成的key来作为缓存的唯一标志key，那么就可以实现图片和缓存对应起来。
                String key = Utils.hashKeyForDisk(imgUrl);
                try {
                    DiskLruCache.Editor editor = mDiskLruCache.edit(key);
                    if (editor != null) {
                        //此处传入0参数的含义是，缓存的编号，因为DiskLruCache.open时候，传入了最大缓存个数为1，所以次数就是0就好。
                        OutputStream outputStream = editor.newOutputStream(0);
                        //根据现在成功与否，来决定是否提交缓存
                        if (downloadImage(imgUrl, outputStream)) {
                            editor.commit();
                        } else {
                            editor.abort();
                        }
                    }
                    //刷新，写入
                    mDiskLruCache.flush();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }


    /**
     * 下载图片
     *
     * @param imgUrl       图片网址链接
     * @param outputStream 输出流对象
     * @return 返回时候完成下载成功
     */
    private boolean downloadImage(String imgUrl, OutputStream outputStream) {
        HttpURLConnection urlConnection = null;
        BufferedOutputStream out = null;
        BufferedInputStream in = null;

        try {
            URL url = new URL(imgUrl);
            urlConnection = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(urlConnection.getInputStream(), 8 * 1024);//Buffer输入流，8M大小的缓存
            out = new BufferedOutputStream(outputStream, 8 * 1024);
            int b;//正在读取的byte
            while ((b = in.read()) != -1) {
                out.write(b);
            }
            return true;
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //关闭资源
        finally {
            if (urlConnection != null) {
                urlConnection.disconnect();
            }
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    /**
     * 读取缓存
     *
     * @param view
     */
    public void readCache(View view) {
        //使用DiskLruCache获取缓存，需要传入key，而key是imageUrl加密后的字符串，
        String key = Utils.hashKeyForDisk(imgUrl);
        try {
            //通过key获取的只是一个快照，需要从快照获取输入流，转化为数据对象
            DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
            if (snapshot != null) {
                InputStream inputStream = snapshot.getInputStream(0);//类似写缓存时候，传入的是缓存的编号
                //可以使用bitmapFactory
                Drawable drawable = Drawable.createFromStream(inputStream, "drawable");
                ImageView imageView = (ImageView) findViewById(R.id.iv_cache);
                imageView.setImageDrawable(drawable);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    /**
     * 清除缓存
     *
     * @param view
     */
    public void removeCache(View view) {
        String key = Utils.hashKeyForDisk(imgUrl);
        try {
            //清除指定key的缓存
            mDiskLruCache.remove(key);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 演示DiskLruCache的其他api
     */
    public void otherAPI() {
        //缓存目录大小
        mDiskLruCache.size();
        //将内存中的操作记录，同步到日志文件（journal），一般不要频繁操作，在Activity的onPause中调用于此就好。
        try {
            mDiskLruCache.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //关闭缓存,一般在Activity的onDestroy中调用就好
        try {
            mDiskLruCache.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        //清空缓存，不同于remove，这是清空全部缓存
        try {
            mDiskLruCache.delete();
        } catch (IOException e) {
            e.printStackTrace();
        }

        /*
         * journal文件分析
         * 前五行基本就是open相关的参数的配置信息
         * 第六行开始，DIRTY开头的，表示脏数据记录，每次调用DiskLruCache.edit都会有一个记录，
         * 调用commit时候，会写入CLEAN记录，而调用abort，则写入REMOVE记录。
         * 日志里item还会记录缓存的大小。READ就是调用get时候写入的记录。journal的记录不知无止境的，2000条左右计数，就会重构。
         */
    }

单独的使用内存缓存或者外部缓存，都未必是是最好的，一个优秀的开发者，必然会考虑到两者的结合使用。上面大神也有提供一个演示用的demo，在其博客中也有简介。