Android-Universal-Imageloader源码完全解析
现在网上对此Imageloader图片加载的开源框架的解析有好多文章，有好多只是简单分析它的实现，此篇文章是通过自己对其源码的分析，对它的实现方式进行分析，针对它用到的重点知识点进行重点介绍，以及自己对于此框架的理解。下面的分析从以下两个方面进行分析。
Imageloader的初始化
Imageloader加载图片的实现方式分析
1.Imageloader的初始化
Imageloader是在Application的onCreate()方法中进行初始化的，在官方的demo 中的初始化方式如下：
ImageLoaderConfiguration.Builder config = new ImageLoaderConfiguration.Builder(context); config.threadPriority(Thread.NORM_PRIORITY - 2); config.denyCacheImageMultipleSizesInMemory(); config.diskCacheFileNameGenerator(new Md5FileNameGenerator()); config.diskCacheSize(50 * 1024 * 1024); // 50 MiB config.tasksProcessingOrder(QueueProcessingType.LIFO); config.writeDebugLogs(); // Remove for release app // Initialize ImageLoader with configuration. ImageLoader.getInstance().init(config.build());从上面我们能看出，官方的demo对指定的配置选项进行了配置，当然，没有设置的选项，系统也会采用默认的方式进行实现。可以通过config.build()方法中实现的，会调用initEmptyFieldsWithDefaultValues()方法会将那些必要的并且没有设置的配置参数进行初始化，比如downloader(执行下载的对象)，decoder（执行解码的对象）等等，如果想了解，可以自己查看更多默认参数，下面分析在加载的图片的流程中，用到这些对象会对其进行详细的分析。
2.Imageloader加载图片的实现方式分析
本文主要对displayImage()方法进行分析，其实其他方式原理都一样，就不过多描述了。实现看displayImage()参数列表如下：
public void displayImage(String uri, ImageView imageView, DisplayImageOptions options, ImageLoadingListener listener, ImageLoadingProgressListener progressListener)其实其中，需要了解的也就是参数三的DisplayImageOptions了，这是对显示的图片的配置信息，我们来看官方demo的实现方式如下：
options = new DisplayImageOptions.Builder() .showImageOnLoading(R.drawable.ic_stub) .showImageForEmptyUri(R.drawable.ic_empty) .showImageOnFail(R.drawable.ic_error) .cacheInMemory(true) .cacheOnDisk(true) .considerExifParams(true) .displayer(new CircleBitmapDisplayer(Color.WHITE, 5)) .build();其中重点需要说一下的就是设置displayer(),这里实现的是显示圆形图片，系统还提供了其他几种Displayer，都是继承Bitmap Displayer进行扩展实现的。内部的实现是通过Drawable实现，而不是对ImageView进行操作了，这样性能会更好。实现原理就是将Bitmap画到Drawable，然后直接将Drawable设置给ImageVIew即可。我记得好像之前看到鸿阳有一篇文件就是写的这方面，想要了解的可以看一下。这里代码的具体实现：
public void display(Bitmap bitmap, ImageAware imageAware, LoadedFrom loadedFrom) {
<span style="white-space:pre"> </span>if (!(imageAware instanceof ImageViewAware)) {
throw new IllegalArgumentException("ImageAware should wrap ImageView. ImageViewAware is expected.");
}
imageAware.setImageDrawable(new CircleDrawable(bitmap, strokeColor, strokeWidth));
}内部有一个CircleDrawable的静态内部泪，它继承自Drawable，具体实现，以及原理，大家可以自己查看，以及查阅相关资料，这个不是这里的重点。
继续上面displayImage()的分析，其他最后它真正调用的方法是：
public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,
ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {
相信，大家看完这个参数列表，都会好奇，为什么原来的ImageVIew在这里变成了ImageAware，这个究竟是什么，其实它是这个框架一个值得称赞的地方，它其实是将ImageView包裹起来，并且是用 弱引用包裹起来的。为什么这样呢，这样的好处又是什么呢。首先要先明白弱引用在这里的作用：为了防止由于ImageView被当前Imageloader引用着，造成其他引用它的地方内存也无法释放掉，造成内存泄漏（例如一个场景：ImageView所在的父view已经没用，可以被销毁掉了，但是由于，Imageloader的线程还在下载等待将图片设置给ImageVIew，所以此ImageVIew就被Imageloader引用着，释放不掉，同时造成引用它的父view也释放不掉。），关于弱引用的原理和作用，这里就不做介绍，大家可以查阅相关资料。
下面分析其内部代码的实现（只截取重要部分）：
if (targetSize == null) {
//根据 ImageView的宽高 和 设置的最大图片宽高 计算出 目标图片的尺寸(如果图片宽(高)等于0,那么会取configuration中的设置的最大图片的尺寸(默认去屏幕尺寸))
targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());
}
//根据 uri 和 图片尺寸计算出 缓存的key
String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);
engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);//存储起来(Map存储,key:imageView的hashcode;value:计算出来的 cachekey)
listener.onLoadingStarted(uri, imageAware.getWrappedView());//回调函数的回调
//第一层缓存(内存缓存)
Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);//普通的基于lru算法的缓存(使用LinkedHashMap实现)
if (bmp != null && !bmp.isRecycled()) {//缓存中有,就直接取出来,不去通过网络获取了
L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);
if (options.shouldPostProcess()) {//是否设置了BitmapProcessor(Bitmap处理器,对 Bitmap获取到的Bitmap做相应的处理)
ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
options, listener, progressListener, engine.getLockForUri(uri));
ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,
defineHandler(options));//这是一个Runnable任务,run主体方法中,会调用Options中设置的BitmapProcessor处理图片,然后加入到engine的线程池中执行对应显示图片的任务
if (options.isSyncLoading()) {//同步执行,直接调用
displayTask.run();
} else {//异步执行,添加到线程池中,等待异步执行
engine.submit(displayTask);
}
} else {
options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);//根据设置Displayer直接为ImageView设置Drawable(根据要求,通过Bitmap创建对应的Drawable)
listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);//回调方法的调用
}
} else {// 内存缓存没有,走 第二层磁盘缓存
if (options.shouldShowImageOnLoading()) {//设置正在加载的图片
imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));
} else if (options.isResetViewBeforeLoading()) {//如果设置加载之前,重置图片,那么就将ImageView的 图像设置为null
imageAware.setImageDrawable(null);
}
ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,
options, listener, progressListener, engine.getLockForUri(uri));//最后一个参数:创建url对应的线程锁
LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,
defineHandler(options));//创建下载任务
if (options.isSyncLoading()) {//同步
displayTask.run();//直接调用 Runable的 run()方法
} else {//异步执行(默认)(运行在子线程中,将其添加到线程池中)
engine.submit(displayTask);
}
}
代码都已经加上注释，其实它也是采用的两级级缓存，通过之前的配置选项也可以看出来，内存，本地磁盘这两级缓存来优化体验。每个代码的内部具体实现，自己查阅内部代码实现吧，我就不详细分析其内部实现，下面重点分析LoadAndDisplayImageTask这个任务中的具体实现，其实它内部就是先从磁盘缓存中查找是否含有对应的缓存，有的话直接取出来，进行处理解码设置给ImageView，否者调用对应的downloader去下载对应的资源。主要看它run()方法的实现：
loadFromUriLock.lock();//线程安全
Bitmap bmp;
try {
checkTaskNotActual();//判断当前ImageView是否回首掉了,是否正在被其他线程使用
bmp = configuration.memoryCache.get(memoryCacheKey);//从缓存中获取数据
if (bmp == null || bmp.isRecycled()) {//没有从缓存中获取数据,或者bitmap已经回收掉了
bmp = tryLoadBitmap();//先从缓存中获取数据,如果没有,再从网络下载,然后存储在到本地(如果设置缓存在本地)
if (bmp == null) return; // listener callback already was fired
checkTaskNotActual();
checkTaskInterrupted();
if (options.shouldPreProcess()) {
L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);
bmp = options.getPreProcessor().process(bmp);//提前处理器,对Bitmap进行相应的处理(这个需要自己配置,并且需要自己实现对应的PreProcessor)
if (bmp == null) {
L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);
}
}
//如果设置缓存到内存中,将数据缓存到内存中.(存储到内存中的是已经压缩处理后的图片)
if (bmp != null && options.isCacheInMemory()) {
L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);
configuration.memoryCache.put(memoryCacheKey, bmp);
}
} else {
loadedFrom = LoadedFrom.MEMORY_CACHE;
L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);
}
if (bmp != null && options.shouldPostProcess()) {
L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);
bmp = options.getPostProcessor().process(bmp);//如果配置,执行对Bitmap的处理操作
if (bmp == null) {
L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);
}
}
checkTaskNotActual();
checkTaskInterrupted();
} catch (TaskCancelledException e) {
fireCancelEvent();
return;
} finally {
loadFromUriLock.unlock();
}
DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);//为Imageview设置图片的task,内部是调用displayer实现的
runTask(displayBitmapTask, syncLoading, handler, engine);//如果是异步操作,并且handler不为null,用handler执行此task,也就是设置图片的操作要运行在主线程中
下面主要对tryLoadBitmap()方法内部进行分析，其内部会先从内存中获取图片，如果有处理之后返回，如果没有，使用downloader去下载图片。
File imageFile = configuration.diskCache.get(uri);//下载之前从缓存中获取(可能已经存在,其他线程现在了相同的图片)
if (imageFile != null && imageFile.exists() && imageFile.length() > 0) {
L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);
loadedFrom = LoadedFrom.DISC_CACHE;
checkTaskNotActual();
bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));//decodeImage()操作:读取数据流,然后调整图片的应该缩小的大小(使用BitmapFactory.Options实现,
// 里面使用BufferInputStream来存储数据流,重复使用)
}
if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);
loadedFrom = LoadedFrom.NETWORK;
String imageUriForDecoding = uri;
//第一个判断:是否缓存到本地,只有第一个判断为true,才会执行第二个判断方法
if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {//tryCacheImageOnDisk()下载图片,并缓存本地
imageFile = configuration.diskCache.get(uri);
if (imageFile != null) {
imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());
}
}
checkTaskNotActual();
//如果没有设置缓存本地,那么执行下面的方法的时候,imageUriForDecoding 还是 http,还是会调用 Downloader的 getStream()方法,
//此方法会判断uri是什么开头的,可以处理http,file,content,assets等
bitmap = decodeImage(imageUriForDecoding);
if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {
fireFailEvent(FailType.DECODING_ERROR, null);
}
}
首先对decodeImage()方法进行分析，此方法就是调用decoder的decode()方法进行实现，所以直接看官方demo使用的BaseImageDecoder的decode()方法的实现：
InputStream imageStream = getImageStream(decodingInfo);//如果没有下载,下载图片,否则获取到缓存到本地的file的流
if (imageStream == null) {
L.e(ERROR_NO_IMAGE_STREAM, decodingInfo.getImageKey());
return null;
}
try {
imageInfo = defineImageSizeAndRotation(imageStream, decodingInfo);//创建一个file info(计算出图片流的图片的实际尺寸)
//这里很重要;因为上面已经decodeStream()已经将上面的流给读取了,当前流指定的位置已经改变了,所以下面的流要重置一下(两种方式,如果支持mark(),那么就reset()之前的位置)
//如果不支持,那么就重新下载这个流
imageStream = resetStream(imageStream, decodingInfo);//重置图片流,如果图片流可以重置到之前读取的位置,那么就reset(),如果不能,就重新下载这个流
//创建缩放的比例,然后赋值创建Options返回
Options decodingOptions = prepareDecodingOptions(imageInfo.imageSize, decodingInfo);//参数1:图片流的大小,
decodedBitmap = BitmapFactory.decodeStream(imageStream, null, decodingOptions);//根据流创建对应的Bitmap(如果这里的图片源太大,此方法会报异常,亲测结果)
} finally {
IoUtils.closeSilently(imageStream);//不要忘记:将数据流关闭
}
if (decodedBitmap == null) {
L.e(ERROR_CANT_DECODE_IMAGE, decodingInfo.getImageKey());
} else {
decodedBitmap = considerExactScaleAndOrientatiton(decodedBitmap, decodingInfo, imageInfo.exif.rotation,
imageInfo.exif.flipHorizontal);
}
return decodedBitmap;
有两个地方需要注意一下，第一个：getImageStream()获取的输入流是缓冲输入流，支持markSupport()和reset()和mark()方法，如果一个流都到末尾之后，可以调用reset()将读取位置重置到头部，这个流就可以继续读取数据。在BitmapFactory.decodeStream()第一次获取图片的尺寸的时候，已经将流读到末尾了；第二次BitmapFactory.decodeStream()的之前必须调用这个输入流的reset()方法重置这个流，才能继续使用这个流。第二个：BitmapFactory.decodeStream()方法报异常，由于图片太大，没找到解决方法（希望哪位大神了解的，告知小弟）。
下面分析，磁盘缓存没有对应的缓存的时候，执行的方法：tryCacheImageOnDisk().
loaded = downloadImage();//下载图片,并将图片缓存到本地缓存中
if (loaded) {
int width = configuration.maxImageWidthForDiskCache;
int height = configuration.maxImageHeightForDiskCache;
if (width > 0 || height > 0) {
L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);
resizeAndSaveImage(width, height);// 调整图片大小，并将调整后的图片的Bitmap缓存在本地缓存中<span style="font-family: Arial, Helvetica, sans-serif;">// TODO : process boolean result</span>
}
}
首先看downloadImage()方法的实现：
InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader());
if (is == null) {
L.e(ERROR_NO_IMAGE_STREAM, memoryCacheKey);
return false;
} else {
try {
return configuration.diskCache.save(uri, is, this);//下载完成之后,缓存在本地(没有经过处理和压缩的图片流)
} finally {
IoUtils.closeSilently(is);//释放数据流
}
}
紧接着看getDownloader.getStream()的实现，官方demo采用的是BaseImageDownloader 的 getStream()的实现：
switch (Scheme.ofUri(imageUri)) {
case HTTP:
case HTTPS://网络获取
return getStreamFromNetwork(imageUri, extra);
case FILE://本地文件中获取
<span style="white-space:pre"> </span> return getStreamFromFile(imageUri, extra);
case CONTENT://ContentProvider
return getStreamFromContent(imageUri, extra);
case ASSETS://assets文件夹中获取
return getStreamFromAssets(imageUri, extra);
case DRAWABLE://从资源文件中获取
return getStreamFromDrawable(imageUri, extra);
case UNKNOWN:
default:
return getStreamFromOtherSource(imageUri, extra);
}
主要看从网络获取图片实现：
<span style="white-space:pre"> </span>HttpURLConnection conn = createConnection(imageUri, extra);
int redirectCount = 0;
while (conn.getResponseCode() / 100 == 3 && redirectCount < MAX_REDIRECT_COUNT) {
conn = createConnection(conn.getHeaderField("Location"), extra);
redirectCount++;
}
InputStream imageStream;
try {
imageStream = conn.getInputStream();
} catch (IOException e) {
// Read all data to allow reuse connection (http://bit.ly/1ad35PY)
IoUtils.readAndCloseStream(conn.getErrorStream());
throw e;
}
if (!shouldBeProcessed(conn)) {//状态码!=200
IoUtils.closeSilently(imageStream);
throw new IOException("Image request failed with response code " + conn.getResponseCode());
}
//注意它将外层包裹了 BufferedInputStream(使用缓冲输入流,它可以markSupport()返回true,支持mark()和reset()操作,可以重复读取流数据)
//解决问题:在BitmapFactory.decode()执行之后,读取的位置到达了流的结尾,如果是这个对象,就可以调用reset()方法之后继续使用这个流
return new ContentLengthInputStream(new BufferedInputStream(imageStream, BUFFER_SIZE), conn.getContentLength());
下面看resizeAndSaveImage()方法的实现，内部调整存储在本地的图片流的大小，生成对应的Bitmap存储到磁盘缓存中。
<span style="white-space:pre"> </span>File targetFile = configuration.diskCache.get(uri);
if (targetFile != null && targetFile.exists()) {
ImageSize targetImageSize = new ImageSize(maxWidth, maxHeight);
DisplayImageOptions specialOptions = new DisplayImageOptions.Builder().cloneFrom(options)
.imageScaleType(ImageScaleType.IN_SAMPLE_INT).build();
ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey,
Scheme.FILE.wrap(targetFile.getAbsolutePath()), uri, targetImageSize, ViewScaleType.FIT_INSIDE,
getDownloader(), specialOptions);
Bitmap bmp = decoder.decode(decodingInfo);
if (bmp != null && configuration.processorForDiskCache != null) {
L.d(LOG_PROCESS_IMAGE_BEFORE_CACHE_ON_DISK, memoryCacheKey);
bmp = configuration.processorForDiskCache.process(bmp);
if (bmp == null) {
L.e(ERROR_PROCESSOR_FOR_DISK_CACHE_NULL, memoryCacheKey);
}
}
if (bmp != null) {
saved = configuration.diskCache.save(uri, bmp);//将处理完的Bitmap存储到本地缓存
bmp.recycle();
}
}
全部分析到此结束，如果哪里有错误，欢迎纠正。其实关于progressListener的调用没有分析到，其实在调用diskCache的save()方法将从网络获取的输入流写入到本地的输出流中，这个过程是下载图片真正运行的过程，并且save()方法会将LoadAndDisplayImage这个类的this对象传递进去，这个类实现了IoUtils.CopyListener接口，在save()将输入流写入到输出流的过程会调用onByteCopies()回调方法，此方法会调用 progressListener。