设计一个简易图片缓存组件
在UI界面加载一张图片时很简单，然而如果需要加载多张较大的图像，事情就会变得更加复杂。在许多情况下（如ListView、RecyclerView或ViewPager等的组件），屏幕上的图片的总数伴随屏幕的滚动会大大增加，且基本上是无限的。为了使内存使用保持在稳定范围内，防止出现OOM，这些组件会在子 View划出屏幕后，对其进行资源回收，并重新显示新出现的图片，垃圾回收机制会释放掉不再显示的图片的内存空间。但是这样频繁地处理图片的加载和回收不利于操作的流畅性，而内存或者磁盘的Cache就会帮助解决这个问题，实现快速加载已加载的图片。在缓存上，主要有两种级别的Cache：LruCache和DiskLruCache，即内存缓存与磁盘缓存。我们就来借助内存缓存和磁盘缓存来实现一个简易的图片缓存框架。
概要设计
代码实现
BitMapLruCache.java:
1import android.content.Context;
2import android.graphics.Bitmap;
3import android.graphics.BitmapFactory;
4import android.graphics.Matrix;
5import android.util.Log;
6import android.util.LruCache;
7import android.widget.ImageView;
8
9import java.io.File;
10import java.io.FileInputStream;
11import java.io.FileOutputStream;
12import java.io.IOException;
13import java.io.InputStream;
14import java.net.HttpURLConnection;
15import java.net.URL;
16import java.security.MessageDigest;
17import java.security.NoSuchAlgorithmException;
18import java.util.concurrent.ExecutorService;
19import java.util.concurrent.LinkedBlockingDeque;
20import java.util.concurrent.ThreadPoolExecutor;
21import java.util.concurrent.TimeUnit;
22
23public class BitMapLruCache {
24 private static MemoryCacheUtils memoryCacheUtils;
25 private static ExecutorService executor;
26
27 private static final String TAG = "BitMapLruCache";
28
29 private BitMapLruCache(){}
30
31 /**
32 * 外部私有缓存文件夹
33 */
34 private static File cacheDir;
35
36 /**
37 * 初始化BitMapLruCache，必须在App启动完成后调用！
38 * @param context context
39 */
40 public static void init(Context context){
41 cacheDir = context.getExternalCacheDir();
42 memoryCacheUtils = new MemoryCacheUtils();
43 executor = new ThreadPoolExecutor(
44 4, 8,
45 10, TimeUnit.SECONDS, new LinkedBlockingDeque<>(128));
46 }
47
48 /**
49 * 根据URL获取一张图片
50 * @param url URL
51 * @param imageView {@link ImageView}
52 * @param listener {@link LoadBitMapListener} 加载BitMap的监听器
53 */
54 public static void getBitMap(String url, ImageView imageView, LoadBitMapListener listener) {
55 // 先从内存找
56 Bitmap fromMemory = memoryCacheUtils.getBitmapFromMemory(url);
57 if(fromMemory != null){
58 listener.success(fromMemory, imageView);
59 }else {
60 // 找不到就从磁盘找
61 Bitmap bitmap = getBitMapFromDisk(url);
62 if(bitmap != null){
63 listener.success(bitmap, imageView);
64 // 找到就保存到内存
65 memoryCacheUtils.setBitmapToMemory(url, bitmap);
66 }else{
67 // 找不到从网络加载 & 保存到内存
68 GetFromNetWorkTask task = new GetFromNetWorkTask(url, imageView, listener);
69 executor.submit(task);
70 }
71 }
72 }
73
74 /**
75 * 根据URL从磁盘加载BitMap
76 * @param url 图片URL
77 * @return bitmap {@link Bitmap}
78 */
79 private static Bitmap getBitMapFromDisk(String url) {
80 File file = new File(cacheDir, calcMD5(url));
81 if(file.exists()){
82 try {
83 return BitmapFactory.decodeStream(new FileInputStream(file));
84 } catch (IOException e) {
85 Log.e(TAG, "getBitMapFromDisk: ", e);
86 }
87 }
88 return null;
89 }
90
91 /**
92 * 保存BitMap到磁盘
93 * @param url 图片URL
94 * @param bitmap {@link Bitmap}
95 */
96 private static void saveBitMapToDisk(String url, Bitmap bitmap) {
97 //url convert
98 try {
99 File file = new File(cacheDir, calcMD5(url));
100 Log.i(TAG, "saveBitMapToDisk: file' path = " + file.getAbsolutePath());
101 FileOutputStream out = new FileOutputStream(file);
102 bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out);
103 } catch (IOException e) {
104 Log.e(TAG, "saveBitMapToDisk: ", e);
105 }
106 }
107
108 /**
109 * 加载BitMap过程中的监听器
110 */
111 public interface LoadBitMapListener{
112 void success(Bitmap bitmap, ImageView imageView);
113 void failed();
114 }
115
116 /**
117 * 从网络加载的Task
118 */
119 static private class GetFromNetWorkTask implements Runnable {
120 String urlStr;
121 ImageView imageView;
122 LoadBitMapListener listener;
123
124 public GetFromNetWorkTask(String urlStr, ImageView imageView, LoadBitMapListener listener) {
125 this.urlStr = urlStr;
126 this.imageView = imageView;
127 this.listener = listener;
128 }
129
130 @Override
131 public void run() {
132 try {
133 URL url = new URL(urlStr);
134 HttpURLConnection conn = (HttpURLConnection) url.openConnection();
135 conn.setRequestMethod("GET");
136 InputStream connInputStream = conn.getInputStream();
137 Bitmap baseBitmap = BitmapFactory.decodeStream(connInputStream);
138 // 比例压缩
139 Bitmap bitmap = imageCompressL(baseBitmap);
140 listener.success(bitmap, imageView);
141 memoryCacheUtils.setBitmapToMemory(urlStr, bitmap);
142 saveBitMapToDisk(urlStr, bitmap);
143 } catch (IOException e) {
144 listener.failed();
145 }
146 }
147 }
148
149 /**
150 * 将URL转换为MD5
151 * @param str URL
152 * @return MD5
153 */
154 private static String calcMD5(String str) {
155 if (str == null || str.length() == 0) {
156 throw new IllegalArgumentException("String cannot be null or zero length");
157 }
158 StringBuilder hexString = new StringBuilder();
159 try {
160 MessageDigest md = MessageDigest.getInstance("MD5");
161 md.update(str.getBytes());
162 byte[] hash = md.digest();
163 for (byte b : hash) {
164 if ((0xff & b) < 0x10) {
165 hexString.append("0").append(Integer.toHexString((0xFF & b)));
166 } else {
167 hexString.append(Integer.toHexString(0xFF & b));
168 }
169 }
170 } catch (NoSuchAlgorithmException e) {
171 e.printStackTrace();
172 }
173 return hexString.toString();
174 }
175
176
177 /**
178 * 计算Bitmap大小，如果超过64kb，则进行压缩
179 * @param bitmap 源BitMap {@link Bitmap}
180 * @return 压缩后的Bitmap {@link Bitmap}
181 */
182 private static Bitmap imageCompressL(Bitmap bitmap) {
183 double targetWidth = Math.sqrt(64.00 * 1000);
184 if (bitmap.getWidth() > targetWidth || bitmap.getHeight() > targetWidth) {
185 // 创建操作图片用的matrix对象
186 Matrix matrix = new Matrix();
187 // 计算宽高缩放率
188 float x = (float) Math.max(targetWidth / bitmap.getWidth(), targetWidth / bitmap.getHeight());
189 // 缩放图片动作
190 matrix.postScale(x, x);
191 bitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(),
192 bitmap.getHeight(), matrix, true);
193 }
194 return bitmap;
195 }
196
197 /**
198 * LRUCache操作工具类
199 */
200 private static class MemoryCacheUtils {
201 private static final String TAG = "MemoryCacheUtils";
202 private final LruCache<String, Bitmap> mMemoryCache;
203
204 public MemoryCacheUtils(){
205 // 得到手机最大允许内存的1/8，即超过指定内存，则开始回收
206 long maxMemory = Runtime.getRuntime().maxMemory()/8;
207 Log.i(TAG, "MemoryCacheUtils: maxMemory = " + maxMemory);
208 // 需要传入允许的内存最大值，虚拟机默认内存24M
209 mMemoryCache = new LruCache<String,Bitmap>((int) maxMemory){
210 @Override
211 protected int sizeOf(String key, Bitmap value) {
212 return value.getByteCount();
213 }
214 };
215 }
216
217 /**
218 * 从内存中读图片
219 * @param url 图片URL
220 * @return {@link Bitmap}
221 */
222 public Bitmap getBitmapFromMemory(String url) {
223 return mMemoryCache.get(url);
224 }
225
226 /**
227 * 往内存中写图片
228 * @param url 图片URL
229 * @param bitmap BitMap
230 */
231 public void setBitmapToMemory(String url, Bitmap bitmap) {
232 mMemoryCache.put(url,bitmap);
233 }
234 }
235}
LRUCache本身就是基于LinkHashMap实现的，关于更多LRUCache的内容可以看我的另一篇博客： 《LinkHashMap与LRU》
需要注意的是使用此组件需要外部存储的权限与网络访问权限（如果是Android6.0之后的设备还需要动态权限申请）：
1<uses-permission android:name="android.permission.INTERNET" />
2<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
3<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
关于图片压缩
我们在在展示高分辨率图片的时候，最好先将图片进行压缩。压缩后的图片大小应该和用来展示它的控件大小相近，因为在一个很小的ImageView上显示一张超大的图片不会带来任何视觉上的好处，但却会占用我们相当多宝贵的内存，而且在性能上还可能会带来负面影响。下面我们就来看一看，如何对一张大图片进行适当的压缩，让它能够以最佳大小显示的同时，还能防止OOM的出现。
1W/System.err: java.lang.RuntimeException: Canvas: trying to draw too large(552960000bytes) bitmap.
BitmapFactory这个类提供了多个解析方法(decodeByteArray, decodeFile, decodeResource等)用于创建Bitmap对象，我们应该根据图片的来源选择合适的方法。比如SD卡中的图片可以使用decodeFile方法，网络上的图片可以使用decodeStream方法，资源文件中的图片可以使用decodeResource方法。这些方法会尝试为已经构建的bitmap分配内存，这时就会很容易导致OOM出现。为此每一种解析方法都提供了一个可选的BitmapFactory.Options参数，将这个参数的inJustDecodeBounds属性设置为true就可以让解析方法禁止为bitmap分配内存，返回值也不再是一个Bitmap对象，而是null。虽然Bitmap是null了，但是BitmapFactory.Options的outWidth、outHeight和outMimeType属性都会被赋值。这个技巧让我们可以在加载图片之前就获取到图片的长宽值和MIME类型，从而根据情况对图片进行压缩。如下代码所示：
1BitmapFactory.Options options = new BitmapFactory.Options();
2options.inJustDecodeBounds = true;
3BitmapFactory.decodeResource(getResources(), R.id.myimage, options);
4int imageHeight = options.outHeight;
5int imageWidth = options.outWidth;
6String imageType = options.outMimeType;
为了避免OOM异常，最好在解析每张图片的时候都先检查一下图片的大小，除非你非常信任图片的来源，保证这些图片都不会超出你程序的可用内存。
现在图片的大小已经知道了，我们就可以决定是把整张图片加载到内存中还是加载一个压缩版的图片到内存中。以下几个因素是我们需要考虑的：
1、预估一下加载整张图片所需占用的内存 2、为了加载这一张图片你所愿意提供多少内存 3、用于展示这张图片的控件的实际大小 4、当前设备的屏幕尺寸和分辨率
比如，你的ImageView只有128×96像素的大小，只是为了显示一张缩略图，这时候把一张1024×768像素的图片完全加载到内存中显然是不值得的。通过设置BitmapFactory.Options中inSampleSize的值就可以实现。比如我们有一张2048×1536像素的图片，将inSampleSize的值设置为4，就可以把这张图片压缩成512×384像素。原本加载这张图片需要占用13M的内存，压缩后就只需要占用0.75M了(假设图片是ARGB_8888类型，即每个像素点占用4个字节)。下面的方法可以根据传入的宽和高，计算出合适的inSampleSize值：
1public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
2 // 源图片的高度和宽度
3 final int height = options.outHeight;
4 final int width = options.outWidth;
5 int inSampleSize = 1;
6 if (height > reqHeight || width > reqWidth) {
7 // 计算出实际宽高和目标宽高的比率
8 final int heightRatio = Math.round((float) height / (float) reqHeight);
9 final int widthRatio = Math.round((float) width / (float) reqWidth);
10 // 选择宽和高中最小的比率作为inSampleSize的值，这样可以保证最终图片的宽和高
11 // 一定都会大于等于目标的宽和高。
12 inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
13 }
14 return inSampleSize;
15}
使用这个方法，首先你要将BitmapFactory.Options的inJustDecodeBounds属性设置为true，解析一次图片。然后将BitmapFactory.Options连同期望的宽度和高度一起传递到到calculateInSampleSize方法中，就可以得到合适的inSampleSize值了。之后再解析一次图片，使用新获取到的inSampleSize值，并把inJustDecodeBounds设置为false，就可以得到压缩后的图片了:
1public static Bitmap decodeSampledBitmapFromResource(Resources res, int resId,
2 int reqWidth, int reqHeight) {
3 // 第一次解析将inJustDecodeBounds设置为true，来获取图片大小
4 final BitmapFactory.Options options = new BitmapFactory.Options();
5 options.inJustDecodeBounds = true;
6 BitmapFactory.decodeResource(res, resId, options);
7 // 调用上面定义的方法计算inSampleSize值
8 options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
9 // 使用获取到的inSampleSize值再次解析图片
10 options.inJustDecodeBounds = false;
11 return BitmapFactory.decodeResource(res, resId, options);
12}
下面的代码非常简单地将任意一张图片压缩成100×100的缩略图，并在ImageView上展示：
1mImageView.setImageBitmap(decodeSampledBitmapFromResource(getResources(), R.id.myimage, 100, 100));
解决RecyclerView加载图片错乱
因为有ViewHolder的重用机制，每一个Item在移出屏幕后都会被重新使用以节省资源，避免滑动卡顿。所以当使用异步任务加载图片的时候就可能会发生图片加载错乱的问题，既然弄清楚了原因，那么下面就给出解决方式：
1.先将图片预设为本地一个占位图片。（重要！很多错位情况在于复用了其他位置的图片缓存，而当前图片迟迟加载不出来，导致当前图片错位。所以解决之道是先用本地占位图片，快速刷新当前图片。等加载完毕之后，就可以替换掉占位图）;
2.通过ImageView.setTag，把url记录在图片内部;
3.把url放进一个请求队列，（这是避免图片很大，请求耗时很长，重复发起url请求）;
4.如果请求队列存在url，则将老的url对应图片控件，替换为本次请求图片控件，返回;
5.如果当前url和第一步ImageView.getTag一致，则用新的数据源更新图片,否则返回;
6.如果是重复使用的图片，最好就是访问之后，写入到本地存储上，避免耗时网络请求。
下面给出具体代码实现：（里面的BitMapLruCache正是用的上面的BitMapLruCache）
1public class PictureAdapter extends RecyclerView.Adapter<PictureAdapter.MyViewHolder>{
2 private Context context;
3 private List<PictureItem> array;
4
5 public PictureAdapter(Context context, List<PictureItem> array) {
6 this.context = context;
7 this.array = array;
8 }
9
10 @NonNull
11 @Override
12 public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
13 View view = LayoutInflater.from(context).inflate(R.layout.picture_item, parent, false);
14 return new MyViewHolder(view);
15 }
16
17 @Override
18 public void onBindViewHolder(@NonNull MyViewHolder holder, int position) {
19 PictureItem item = array.get(position);
20 // 图片准备之前设置Tag
21 holder.pictureImageView.setTag(item.getImgUrl());
22 BitMapLruCache.getBitMap(item.getImgUrl(), holder.pictureImageView, new BitMapLruCache.LoadBitMapListener() {
23 @Override
24 public void success(Bitmap bitmap, ImageView imageView) {
25 String tag = (String) imageView.getTag();
26 // 加载图片的时候判断Tag
27 if(item.getImgUrl().equals(tag)){
28 holder.pictureImageView.setImageBitmap(bitmap);
29 }
30 }
31
32 @Override
33 public void failed() {
34 holder.pictureImageView.setImageResource(R.drawable.ic_launcher_background);
35 }
36 });
37 }
38
39 @Override
40 public int getItemCount() {
41 return array.size();
42 }
43
44 static class MyViewHolder extends RecyclerView.ViewHolder{
45 ImageView pictureImageView;
46 public MyViewHolder(@NonNull View itemView) {
47 super(itemView);
48 pictureImageView = itemView.findViewById(R.id.item_picture_iv);
49 pictureImageView.setImageResource(R.drawable.ic_launcher_background);
50 }
51 }
52}
53