Glide作为当下火爆的图片加载框架之一，相信大部分小伙伴们都有使用过的经历，当然我也是经常使用到。至于它的详细用法我们今天就不一一介绍了，相信在网上已经有很多优秀的文章可以参考，没有使用过的小伙伴们可以去自己搜索查看下。好的，我们直接进入正题，我们接下来来分析Glide的缓存机制，并参考Gilde的缓存机制手写一个自己的图片缓存框架。
口说无凭，通过查阅资料：https://muyangmin.github.io/glide-docs-cn/doc/caching.html#glide里的缓存Glide的缓存分为：
1.活动资源(Active Resources) -当前页面正在显示的图片资源
2. 内存缓存(Memory cache) -内存缓存
3. 资源类型（Resource） -其实指的就是磁盘缓存
4. 数据来源(Data) -网络、文件等数据源
一般图片加载的过程中（如果没有禁止使用缓存），应用会按照1,2,3,4的顺序来依次进行数据加载。需要注意一点是内存缓存还对应着一个Bitmap的复用池，当内存缓存需要舍弃图片时，如果图片是复用对象，是不会被立即回收掉的，而是会被暂时放在复用池当中。接下来我们就站在巨人的肩膀上，开始我们的构建我们自己的图片缓存框架，缓存结构包括：内存缓存，磁盘缓存，网络缓存。
在开始之前我们需要做些知识的储备：
1. Java弱引用 与 引用队列
2. LruCache的用法
3. DiskLruCache的用法
4. Bitmap复用机制
完成准备工作之后，接下来我们就进入正题。第一步根据需求，我们来定义一个接口，方便对方法进行管理
package com.example.learnglide;
import android.graphics.Bitmap;
/**
* 创建者:qinyafei
* 创建时间: 2019/6/20
* 描述: 图片缓存相关接口
* 版本信息：1.0.0
**/
public interface IImgaeCache {
/**
* 初始化方法，因为要做磁盘缓存，所以我们在这里传入文件路径
*
* @param dir
*/
void init(String dir);
/**
* 将图片放入内存缓存
*
* @param key
* @param bitmap
*/
void putSrc2MemoryCache(String key, Bitmap bitmap);
/**
* 从内存缓存中取得图片
*
* @param key
* @return
*/
Bitmap getBitmapFromMemory(String key);
/**
* 从复用池中获取图片数据
*
* @param width 所需图片宽度
* @param height 所需图片高度
* @param simpleSize 缩放大小
* @return
*/
Bitmap getSrcFromReuseableBimtmapPool(int width, int height, int simpleSize);
/**
* 将图片数据放入磁盘缓存
* @param key
* @param bitmap
*/
void putBitmap2DiskCache(String key, Bitmap bitmap);
/**
* 从磁盘中获取图片，要考虑复用问题
* @param reuseable
* @return
*/
Bitmap getSrcFromDiskCache(String key,Bitmap reuseable);
/**
* 清除缓存
*/
void clearCache();
}
新建一个接口的实现类MyImageCache ,类采用单例模式。具体代码如下
package com.example.learnglide;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.util.LruCache;
import com.example.learnglide.disk.DiskLruCache;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
/**
* 创建者:qinyafei
* 创建时间: 2019/6/20
* 描述:
* 版本信息：1.0.0
**/
public class MyImageCache implements IImgaeCache {
private static final int CACHE_SIZE = 10 * 1024 * 1024;
private static MyImageCache instance;
private Context context;
private LruCache<String, Bitmap> memoryCache;// 内存缓存
private DiskLruCache diskLruCache;// 磁盘缓存
private BitmapFactory.Options options = new BitmapFactory.Options();
public static Set<WeakReference<Bitmap>> reuseablePool;// 复用池
ReferenceQueue referenceQueue; // 当弱引用被弃用时，会放到此队列中
Thread gcThread;// 手动回收线程
boolean shutDown;
private MyImageCache(Context context) {
this.context = context.getApplicationContext();// 为避免内存泄漏
}
public static MyImageCache getInstance(Context context) {
if (null == instance) {
synchronized (MyImageCache.class) {
if (null == instance) {
instance = new MyImageCache(context);
}
}
}
return instance;
}
@Override
public void init(String dir) {
// 构建一个线程安全的复用池，考虑到图片加载多在子线程中进行
reuseablePool = Collections.synchronizedSet(new HashSet<WeakReference<Bitmap>>());
intiReferenceQueue();
memoryCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
/**
* @return 图片占用内存大小
*/
@Override
protected int sizeOf(String key, Bitmap value) {
//19之前必需同等大小，才能复用 inSampleSize=1
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {
return value.getAllocationByteCount();
}
return value.getByteCount();
}
@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
if (oldValue.isMutable()) {
// 如果是可复用的，不直接回收，而是暂时放于复用池中
reuseablePool.add(new WeakReference<Bitmap>(oldValue, referenceQueue));
} else {
oldValue.recycle();
}
}
};
try {
diskLruCache = DiskLruCache.open(new File(dir), BuildConfig.VERSION_CODE, 1, 10 * 1024 * 1024);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 初始化引用队列 && 回收线程
*/
private void intiReferenceQueue() {
if (null == referenceQueue) {
referenceQueue = new ReferenceQueue<Bitmap>();
//开启一个回收线程，在检测到有可回收对象时，
// 手动回收，避免了GC的等待时间，让内存处理更高效
gcThread = new Thread(new Runnable() {
@Override
public void run() {
while (!shutDown) {
try {
Reference<Bitmap> reference = referenceQueue.remove();
Bitmap bitmap = reference.get();
if (null != bitmap && !bitmap.isRecycled()) {
bitmap.recycle();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
gcThread.start();
}
}
@Override
public void putSrc2MemoryCache(String key, Bitmap bitmap) {
memoryCache.put(key, bitmap);
}
@Override
public Bitmap getBitmapFromMemory(String key) {
return memoryCache.get(key);
}
@Override
public Bitmap getSrcFromReuseableBimtmapPool(int width, int height, int simpleSize) {
// api 11 之前是不存在Bitmap服用的
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
Bitmap reuseable = null;
Iterator<WeakReference<Bitmap>> iterator = reuseablePool.iterator();
while (iterator.hasNext()) {
Bitmap bitmap = iterator.next().get();
if (null != bitmap) {
if (isBitmapCanResueable(bitmap, width, height, simpleSize)) {
reuseable = bitmap;
iterator.remove();
break;
} else {
iterator.remove();
}
}
}
return reuseable;
}
return null;
}
@Override
public void putBitmap2DiskCache(String key, Bitmap bitmap) {
DiskLruCache.Snapshot snapshot = null;
OutputStream os = null;
try {
snapshot = diskLruCache.get(key);
//如果缓存中已经有这个文件 不理他
if (null == snapshot) {
//如果没有这个文件，就生成这个文件
DiskLruCache.Editor editor = diskLruCache.edit(key);
if (null != editor) {
os = editor.newOutputStream(0);
bitmap.compress(Bitmap.CompressFormat.JPEG, 50, os);
editor.commit();
}
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != snapshot) {
snapshot.close();
}
if (null != os) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
@Override
public Bitmap getSrcFromDiskCache(String key, Bitmap reuseable) {
DiskLruCache.Snapshot snapshot = null;
Bitmap bitmap = null;
try {
snapshot = diskLruCache.get(key);
if (null == snapshot) {
return null;
}
InputStream is = snapshot.getInputStream(0);
options.inMutable = true;
options.inBitmap = reuseable;
bitmap = BitmapFactory.decodeStream(is, null, options);
if (null != bitmap) {
memoryCache.put(key, bitmap);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (null != snapshot) {
snapshot.close();
}
}
return bitmap;
}
@Override
public void clearCache() {
memoryCache.evictAll();
}
/**
* 检查图片是否可以进行复用
*
* @param bitmap
* @param w
* @param h
* @param inSampleSize
* @return
*/
private boolean isBitmapCanResueable(Bitmap bitmap, int w, int h, int inSampleSize) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
return bitmap.getWidth() == w && bitmap.getHeight() == h && inSampleSize == 1;
}
if (inSampleSize >= 1) {
w /= inSampleSize;
h /= inSampleSize;
}
int byteCount = w * h * getPixelsCount(bitmap.getConfig());
return byteCount <= bitmap.getAllocationByteCount();
}
/**
* 获取每个像素的字节数目
*
* @param config
* @return
*/
private int getPixelsCount(Bitmap.Config config) {
if (config == Bitmap.Config.ARGB_8888) {
return 4;
}
return 2;
}
}
至此有关缓存的代码就书写完成了，接下来定义一个类来使用这些缓存，代码如下：
public class ImageLoadUtil {
/**
* 加载图片
* @param context
* @param key
* @param width
* @param height
* @param simpleSize 缩放比例
* @return
*/
public static Bitmap loadImage(Context context, String key, int width, int height, int simpleSize) {
Bitmap bitmap = MyImageCache.getInstance(context).getBitmapFromMemory(key);// 从内存中找
if (null == bitmap) {
Bitmap reuseable = MyImageCache.getInstance(context).getSrcFromReuseableBimtmapPool(width, height, simpleSize);
bitmap = MyImageCache.getInstance(context).getSrcFromDiskCache(key, reuseable);
if (null == bitmap) { //如果磁盘中也没缓存,就从网络下载,这里使用本地图片模拟网络图片
Log.e("Img_Test", "从网络加载: ");
bitmap = resizeBitmap(context, R.drawable.test, 80, 80, false, reuseable);
MyImageCache.getInstance(context).putBitmap2DiskCache(key, bitmap);
MyImageCache.getInstance(context).putSrc2MemoryCache(key, bitmap);
}else {
Log.e("Img_Test", "从磁盘加载: ");
}
}else {
Log.e("Img_Test", "从内存加载: ");
}
return bitmap;
}
}
大功告成，如有什么错误和不足的地方，还望各位指正。最后附上Demo地址：GitHub - qinyafeiii/LearnGlide: 参照Glide，手写图片缓存框架
