图片加载框架之图片加载框架选型（一）上篇

最新推荐文章于 2024-08-16 20:21:37 发布

功勋Web工程师

最新推荐文章于 2024-08-16 20:21:37 发布

阅读量808

点赞数 15

分类专栏： Android程序员文章标签： spring java 后端

本文链接：https://blog.csdn.net/m0_61549781/article/details/136793894

版权

Android程序员专栏收录该内容

10 篇文章 0 订阅

订阅专栏

而这里Editor封装了文件的写入情况OutputStream，Snapshot封装了文件的读取情况InputStream。

回头看回LruDiskCache

public class LruDiskCache implements DiskCache {

protected DiskLruCache cache;

private File reserveCacheDir;

protected final FileNameGenerator fileNameGenerator;

…

public LruDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator, long cacheMaxSize,

int cacheMaxFileCount) throws IOException {

…

this.reserveCacheDir = reserveCacheDir;

this.fileNameGenerator = fileNameGenerator;

initCache(cacheDir, reserveCacheDir, cacheMaxSize, cacheMaxFileCount);

}

private void initCache(File cacheDir, File reserveCacheDir, long cacheMaxSize, int cacheMaxFileCount)

…

cache = DiskLruCache.open(cacheDir, 1, 1, cacheMaxSize, cacheMaxFileCount);

…

}

@Override

public File get(String imageUri) {

DiskLruCache.Snapshot snapshot = null;

try {

snapshot = cache.get(getKey(imageUri));

return snapshot == null ? null : snapshot.getFile(0);

}

…

}

@Override

public boolean save(String imageUri, Bitmap bitmap) throws IOException {

DiskLruCache.Editor editor = cache.edit(getKey(imageUri));

…

OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize);

boolean savedSuccessfully = false;

try {

savedSuccessfully = bitmap.compress(compressFormat, compressQuality, os);

}

…

return savedSuccessfully;

}

首先LruDiskCache内部成员变量带有DiskLruCache还有文件的保存目录等，在它的构造方法中调用DiskLruCache.open方法创建了DiskLruCache对象，而在它的open方法里，则根据文件的目录情况创建了对应的文件系统。

再看它的save方法，先调用getKey方法将uri转换为对应的key，而在cache,edit中

private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {

…

Entry entry = lruEntries.get(key);

if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null

|| entry.sequenceNumber != expectedSequenceNumber)) {

return null; // Snapshot is stale.

}

if (entry == null) {

entry = new Entry(key);

lruEntries.put(key, entry);

} else if (entry.currentEditor != null) {

return null; // Another edit is in progress.

}

Editor editor = new Editor(entry);

entry.currentEditor = editor;

…

return editor;

}

则是根据指定的key先判断缓存文件中有没有相应的key，如果没有则创建一个Entry对象持有它，之后保存在lruEntries之后，创建一个当前Entry的编辑对象Editor，以便之后写入到文件中。

s之后调用了

OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize);

在editor.newOutputStream则是根据当前目录和key创建出一个文件，之后打开这个文件的一个输出流情况，获取到之后就进行Bitmap的写入。

同理，看下LruDiskCache的get方法

@Override

public File get(String imageUri) {

DiskLruCache.Snapshot snapshot = null;

try {

snapshot = cache.get(getKey(imageUri));

return snapshot == null ? null : snapshot.getFile(0);

}

…

}

调用了cache,get

public synchronized Snapshot get(String key) throws IOException {

。。。

Entry entry = lruEntries.get(key);

…

File[] files = new File[valueCount];

InputStream[] ins = new InputStream[valueCount];

try {

File file;

for (int i = 0; i < valueCount; i++) {

file = entry.getCleanFile(i);

files[i] = file;

ins[i] = new FileInputStream(file);

}

…

return new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);

}

在get方法中，先根据key拿到对应的Entry，再拿到对应的文件打开输入流，之后传入到Snapshot，

而在snapshot.getFile中

/** Returns file with the value for {@code index}. */

public File getFile(int index) {

return files[index];

}

返回的则是对应的文件。

BaseDiskCache

BaseDiskCache同样也是直接实现了DiskCache方法，实现的方法也比较简单

public abstract class BaseDiskCache implements DiskCache {

…

protected final File cacheDir;

protected final File reserveCacheDir;

protected final FileNameGenerator fileNameGenerator;

public BaseDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator) {

…

this.cacheDir = cacheDir;

this.reserveCacheDir = reserveCacheDir;

this.fileNameGenerator = fileNameGenerator;

}

@Override

public boolean save(String imageUri, Bitmap bitmap) throws IOException {

File imageFile = getFile(imageUri);

File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);

OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);

boolean savedSuccessfully = false;

try {

savedSuccessfully = bitmap.compress(compressFormat, compressQuality, os);

} finally {

IoUtils.closeSilently(os);

if (savedSuccessfully && !tmpFile.renameTo(imageFile)) {

savedSuccessfully = false;

}

if (!savedSuccessfully) {

tmpFile.delete();

}

bitmap.recycle();

return savedSuccessfully;

}

@Override

public File get(String imageUri) {

return getFile(imageUri);

}

protected File getFile(String imageUri) {

String fileName = fileNameGenerator.generate(imageUri);

File dir = cacheDir;

if (!cacheDir.exists() && !cacheDir.mkdirs()) {

if (reserveCacheDir != null && (reserveCacheDir.exists() || reserveCacheDir.mkdirs())) {

dir = reserveCacheDir;

}

return new File(dir, fileName);

}

比较简单，根据对应的文件去打开获取。它的两个子类LimitedAgeDiskCache和UnlimitedDiskCache也都不一一扩展开了。

三、Universal-Image-Loader解析之源代码解析

===================================================================================================

当我们配置好ImageConfiguration和ImageLoader后，我们就会开始调用

ImageLoader.getInstance().loadImage(…);

ImageLoader.getInstance().displayImage(…);

这两个方法其中一个来显示图片。

先看loadImage

public void loadImage(String uri, ImageSize targetImageSize, DisplayImageOptions options,

ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {

checkConfiguration();

if (targetImageSize == null) {

targetImageSize = configuration.getMaxImageSize();

}

if (options == null) {

options = configuration.defaultDisplayImageOptions;

}

NonViewAware imageAware = new NonViewAware(uri, targetImageSize, ViewScaleType.CROP);

displayImage(uri, imageAware, options, listener, progressListener);

}

首先调用了checkConfiguration用来判断是否有初始化ImageLoaderConfiguration

如果有设置ImageView的大小，则设置，没则默认Configuration的大小。

如果没有设置DisplayImageOptions，则设置上一个默认的options

之后创建了个NonViewAware，再调用displayImage。

也就是说，loadImage最终还是调用到了displayImage。

ImageAware

这里的NonViewAware实现了ImageAware接口。先来看个结构图

ImageAware是一个接口，内部提供了一系列操作图片的一些方法。

对于NonViewAware来说，它内部只是简单的保存图片一些必要的数据，比如图片大小尺寸，URI，ScaleType这些。主要封装成ImageAware来给displayImage调用。

看下displayImage的使用

public void displayImage(String uri, ImageView imageView) {

displayImage(uri, new ImageViewAware(imageView), null, null, null);

}

这里把ImageView封装成ImageViewAware再去调用displayImage这个就跟loadImage一样。

而这里ImageViewAware继承与ViewAware,ViewAware则实现了ImageAware接口。

与NonViewAware不同的是ViewAware内部持有一个Reference<View> viewRef的成员变量，它是用来保存当前ImageView的一个弱引用，以便之后来直接设置显示图片。

ViewAware很多方法都是依赖于这个View

@Override

public boolean setImageDrawable(Drawable drawable) {

if (Looper.myLooper() == Looper.getMainLooper()) {

View view = viewRef.get();

if (view != null) {

setImageDrawableInto(drawable, view);

return true;

}

} else {

L.w(WARN_CANT_SET_DRAWABLE);

}

return false;

}

之后就可以在ImageViewAware中设置显示。

好了回过头看他们最终调用的方法。

这个方法有点长，我们拆分成一部分一部分来看

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,

ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {

checkConfiguration();

if (imageAware == null) {

throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);

}

if (listener == null) {

listener = defaultListener;

}

if (options == null) {

options = configuration.defaultDisplayImageOptions;

}

if (TextUtils.isEmpty(uri)) {

engine.cancelDisplayTaskFor(imageAware);

listener.onLoadingStarted(uri, imageAware.getWrappedView());

if (options.shouldShowImageForEmptyUri()) {

imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));

} else {

imageAware.setImageDrawable(null);

}

listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);

return;

}

…//下一部分看

}

首先先检查是否有初始化设置ImageLoaderConfiguration没则抛出异常，没设置listener和DisplayImageOptions则设置一个默认值。

之后调用TextUtils.isEmpty(uri)判断是否当前的uri为空，则调用

engine.cancelDisplayTaskFor(imageAware);

之后则用listener通知开始和结束，也比较好理解，主要是这个engine。

这个engine就是ImageLoaderEngine，主要用来负责显示加载图片的一个类。

ImageLoaderEngine中存在一个HashMap,用来记录正在加载的任务，加载图片的时候会将ImageView的id和图片的url加上尺寸加入到HashMap中，加载完成之后会将其移除。

接着看下面

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,

ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {

…//前一部分

if (targetSize == null) {

targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());

}

String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);

engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);

listener.onLoadingStarted(uri, imageAware.getWrappedView());

Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);

if (bmp != null && !bmp.isRecycled()) {

L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);

if (options.shouldPostProcess()) {

ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,

options, listener, progressListener, engine.getLockForUri(uri));

ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,

defineHandler(options));

if (options.isSyncLoading()) {

displayTask.run();

} else {

engine.submit(displayTask);

}

} else {

options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);

listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);

}

…//下一部分

}

当URI不为空的时候来加载显示。首先根据uri获取对应uri对应唯一的一个Key，之后调用engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);来记录当前加载的任务，开启listener的start回调，接着调用Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);来获取内存缓存中的图片，这里默认的内存缓存是LruMemoryCache，前篇文章有分析到。

如果缓存中存在相应的Bitmap的话，进入到if里面

我们如果在DisplayImageOptions中设置了postProcessor就进入true逻辑，不过默认postProcessor是为null的，BitmapProcessor接口主要是对Bitmap进行处理，这个框架并没有给出相对应的实现，如果我们有自己的需求的时候可以自己实现BitmapProcessor接口（比如将图片设置成圆形的）.

然后到了27行

将Bitmap设置到ImageView上面，这里我们可以在DisplayImageOptions中配置显示需求displayer，默认使用的是SimpleBitmapDisplayer，直接将Bitmap设置到ImageView上面，我们可以配置其他的显示逻辑，他这里提供了FadeInBitmapDisplayer（透明度从0-1）RoundedBitmapDisplayer（4个角是圆弧）等，然后回调到ImageLoadingListener接口。

我们知道loadImage和displayImage的区别在于loadImage依靠返回的Bitmap进行设置显示，而displayImage则是直接显示。而loadImage最终也是调用了displayImage，原因就在于这个display和imageAware

public final class SimpleBitmapDisplayer implements BitmapDisplayer {

@Override

public void display(Bitmap bitmap, ImageAware imageAware, LoadedFrom loadedFrom) {

imageAware.setImageBitmap(bitmap);

}

loadImage的ImageAware是NonImageAware并没有处理setImageBitmap的方法，而displayImage的ImageViewAware则有处理显示。

好，继续前面，当从内存缓存获取到的Bitmap为空的情况下

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,

ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {

…//前两部分

//如果Bitmap为空

} else {

if (options.shouldShowImageOnLoading()) {

imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));

} else if (options.isResetViewBeforeLoading()) {

imageAware.setImageDrawable(null);

}

ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,

options, listener, progressListener, engine.getLockForUri(uri));

LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,

defineHandler(options));

if (options.isSyncLoading()) {

displayTask.run();

} else {

engine.submit(displayTask);

}

如果需要设置显示加载中的图片，则进行设置显示。

ImageLoadingInfo则是一个加载显示图片任务信息的一个类。

之后根据它创建了一个LoadAndDisplayImageTask类，它实现了Runnable。

如果配置了isSyncLoading为true, 直接执行LoadAndDisplayImageTask的run方法，表示同步，默认是false,将LoadAndDisplayImageTask提交给线程池对象

接下来我们就看LoadAndDisplayImageTask的run(), 这个类还是蛮复杂的，我们还是一段一段的分析。

@Override

public void run() {

if (waitIfPaused()) return;

if (delayIfNeed()) return;

…

}

如果waitIfPaused(), delayIfNeed()返回true的话，直接从run()方法中返回了，不执行下面的逻辑, 接下来我们先看看waitIfPaused（）

private boolean waitIfPaused() {

AtomicBoolean pause = engine.getPause();

if (pause.get()) {

synchronized (engine.getPauseLock()) {

if (pause.get()) {

L.d(LOG_WAITING_FOR_RESUME, memoryCacheKey);

try {

engine.getPauseLock().wait();

} catch (InterruptedException e) {

L.e(LOG_TASK_INTERRUPTED, memoryCacheKey);

return true;

}

L.d(LOG_RESUME_AFTER_PAUSE, memoryCacheKey);

}

return isTaskNotActual();

}

这个方法是干嘛用呢，主要是我们在使用ListView，GridView去加载图片的时候，有时候为了滑动更加的流畅，我们会选择手指在滑动或者猛地一滑动的时候不去加载图片，所以才提出了这么一个方法，那么要怎么用呢？这里用到了PauseOnScrollListener这个类，使用很简单ListView.setOnScrollListener(new PauseOnScrollListener(pauseOnScroll, pauseOnFling ))， pauseOnScroll控制我们缓慢滑动ListView，GridView是否停止加载图片，pauseOnFling 控制猛的滑动ListView，GridView是否停止加载图片。

我们可以看下这个PauseOnScrollListener的处理

@Override

public void onScrollStateChanged(AbsListView view, int scrollState) {

switch (scrollState) {

case OnScrollListener.SCROLL_STATE_IDLE:

imageLoader.resume();

break;

case OnScrollListener.SCROLL_STATE_TOUCH_SCROLL:

if (pauseOnScroll) {

imageLoader.pause();

}

break;

case OnScrollListener.SCROLL_STATE_FLING:

if (pauseOnFling) {

imageLoader.pause();

}

break;

}

if (externalListener != null) {

externalListener.onScrollStateChanged(view, scrollState);

}

滑动停止的话会调用到imageLoader.pause

public void pause() {

engine.pause();

}

…

void pause() {

paused.set(true);

}

这里的pause是

private final AtomicBoolean paused = new AtomicBoolean(false);

所以调用pause.get则会返回true。

除此之外，这个方法的返回值由isTaskNotActual()决定，我们接着看看isTaskNotActual()的源码

private boolean isTaskNotActual() {

return isViewCollected() || isViewReused();

}

isViewCollected()是判断我们ImageView是否被垃圾回收器回收了，如果回收了，LoadAndDisplayImageTask方法的run()就直接返回了，isViewReused()判断该ImageView是否被重用，被重用run()方法也直接返回，为什么要用isViewReused()方法呢？主要是ListView，GridView我们会复用item对象，假如我们先去加载ListView，GridView第一页的图片的时候，第一页图片还没有全部加载完我们就快速的滚动，isViewReused()方法就会避免这些不可见的item去加载图片，而直接加载当前界面的图片。

回头继续看run方法

@Override

public void run() {

…

ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;

L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);

if (loadFromUriLock.isLocked()) {

L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);

}

loadFromUriLock.lock();

Bitmap bmp;

try {

checkTaskNotActual();

bmp = configuration.memoryCache.get(memoryCacheKey);

if (bmp == null || bmp.isRecycled()) {

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);

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);

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);

runTask(displayBitmapTask, syncLoading, handler, engine);

}

第4行代码有一个loadFromUriLock，这个是一个锁，获取锁的方法在ImageLoaderEngine类的getLockForUri()方法中

ReentrantLock getLockForUri(String uri) {

ReentrantLock lock = uriLocks.get(uri);

if (lock == null) {

lock = new ReentrantLock();

uriLocks.put(uri, lock);

}

return lock;

}

从上面可以看出，这个锁对象与图片的url是相互对应的，为什么要这么做？也行你还有点不理解，不知道大家有没有考虑过一个场景，假如在一个ListView中，某个item正在获取图片的过程中，而此时我们将这个item滚出界面之后又将其滚进来，滚进来之后如果没有加锁，该item又会去加载一次图片，假设在很短的时间内滚动很频繁，那么就会出现多次去网络上面请求图片，所以这里根据图片的Url去对应一个ReentrantLock对象，让具有相同Url的请求就会在第10行等待，等到这次图片加载完成之后，ReentrantLock就被释放，刚刚那些相同Url的请求就会继续执行第10行下面的代码。

之后来到第13行，先调用checkTaskNotActual判断当前View是否被GC回收使用，是则抛出异常。

接着15行，它们会先从内存缓存中获取一遍，如果内存缓存中没有在去执行下面的逻辑，所以ReentrantLock的作用就是避免这种情况下重复的去从网络上面请求图片。

17行的方法tryLoadBitmap(),这个方法确实也有点长，我先告诉大家，这里面的逻辑是先从文件缓存中获取有没有Bitmap对象，如果没有在去从网络中获取，然后将bitmap保存在文件系统中，我们还是具体分析下

private Bitmap tryLoadBitmap() throws TaskCancelledException {

Bitmap bitmap = null;

try {

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()));

}

if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {

L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);

loadedFrom = LoadedFrom.NETWORK;

String imageUriForDecoding = uri;

if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {

imageFile = configuration.diskCache.get(uri);

if (imageFile != null) {

imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());

}

checkTaskNotActual();

bitmap = decodeImage(imageUriForDecoding);

if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {

fireFailEvent(FailType.DECODING_ERROR, null);

}

…

return bitmap;

}

首先在第4行会去磁盘缓存中去获取图片，如果图片已经保存在磁盘了，则直接获取对应的File路径，调用bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));进行解析。

如果在磁盘中没有的话，则到了12行，开始进行网络下载获取。

在17行会去调用isCacheOnDisk判断是否要保持在磁盘中，如果默认false，如果是则调用tryCacheImageOnDisk来下载图片并且保持在磁盘

private boolean tryCacheImageOnDisk() throws TaskCancelledException {

L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);

boolean loaded;

try {

loaded = downloadImage();

…

} …

return loaded;

}

调用了downloadImage进行下载图片

private boolean downloadImage() throws IOException {

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来下载，这里先不扩展，在后面会说到

下载之后则保存在磁盘中。

回来前面

String imageUriForDecoding = uri;

if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {

imageFile = configuration.diskCache.get(uri);

if (imageFile != null) {

imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());

}

checkTaskNotActual();

bitmap = decodeImage(imageUriForDecoding);

这里有个String变量imageUriForDecoding，初始值是uri，如果有设置磁盘缓存的话，则会调用tryCacheImageOnDisk来下载并且保持图片，此时的imageUriForDecoding则是文件File的路径。

如果没有设置磁盘缓存的话，则imageUriForDecoding还是uri。

关键则是在decodeImage，它能根据对应的uri来加载图片。

private Bitmap decodeImage(String imageUri) throws IOException {

ViewScaleType viewScaleType = imageAware.getScaleType();

ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey, imageUri, uri, targetSize, viewScaleType,

getDownloader(), options);

return decoder.decode(decodingInfo);

}

把传递进来的imageUri（可能是文件的uri，也可能是图片的uri）封装到ImageDecodingInfo进行解析。

这里的decoder是ImageDecode，它的默认实现类是BaseImageDecode

@Override

public Bitmap decode(ImageDecodingInfo decodingInfo) throws IOException {

Bitmap decodedBitmap;

ImageFileInfo imageInfo;

InputStream imageStream = getImageStream(decodingInfo);

…

}

通过getImageStream来获取输入流

protected InputStream getImageStream(ImageDecodingInfo decodingInfo) throws IOException {

return decodingInfo.getDownloader().getStream(decodingInfo.getImageUri(), decodingInfo.getExtraForDownloader());

}

这里的Downloader默认实现类是BaseImageDownloader

@Override

public InputStream getStream(String imageUri, Object extra) throws IOException {

switch (Scheme.ofUri(imageUri)) {

case HTTP:

case HTTPS:

return getStreamFromNetwork(imageUri, extra);

case FILE:

return getStreamFromFile(imageUri, extra);

case CONTENT:

return getStreamFromContent(imageUri, extra);

case ASSETS:

return getStreamFromAssets(imageUri, extra);

case DRAWABLE:

return getStreamFromDrawable(imageUri, extra);

case UNKNOWN:

default:

return getStreamFromOtherSource(imageUri, extra);

}

可以看到，在这里，已经做了多种情况的读取判断。第一篇文章就有介绍到UIL可以根据不同的uri来解析图片，其原理就是在这里。

而前面通过tryCacheImageOnDisk来下载图片也是根据这个。这里就不一一扩展开。

这里的网络下载图片内部则是使用HttpUrlConnection来下载的。

回到最前面LoadAndDisplayImageTask的run方法后面，当我们获取到Bitmap后，到了

DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);

runTask(displayBitmapTask, syncLoading, handler, engine);

这两个代码就是一个显示任务

直接看DisplayBitmapTask类的run（）方法

@Override

public void run() {

if (imageAware.isCollected()) {

L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);

listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());

} else if (isViewWasReused()) {

L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);

listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());

} else {

L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);

displayer.display(bitmap, imageAware, loadedFrom);

engine.cancelDisplayTaskFor(imageAware);

listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);

}

假如ImageView被回收了或者被重用了，回调给ImageLoadingListener接口，否则就调用BitmapDisplayer去显示Bitmap。到这里Bitmap已经显示加载完成，调用engine移除图片显示任务。

当然在最前面那里

public void displayImage(String uri, ImageAware imageAware, DisplayImageOptions options,

ImageSize targetSize, ImageLoadingListener listener, ImageLoadingProgressListener progressListener) {

…

ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,

options, listener, progressListener, engine.getLockForUri(uri));

LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,

defineHandler(options));

if (options.isSyncLoading()) {

displayTask.run();

} else {

engine.submit(displayTask);

}

如果此时的显示加载是异步的话，则交由engine的Executor线程池去处理，最终也是调用了LoadAndDisplayImageTask的run方法去加载显示。

到这里Universal-Image-Loader的分析也算完了，从基本使用到内存模型在加载显示，可以看到UIL这个开源框架十分的灵活，比如建造者模式，装饰模式，代理模式，策略模式等等，这样方便我们去扩展，实现我们想要的功能，当然，也带给我们更多的想象空间。

原文链接：https://www.jianshu.com/p/cff58eddb4ae

阿里P7移动互联网架构师进阶视频（每日更新中）免费学习请点击：https://space.bilibili.com/474380680

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

最后

我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。

其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。

不断奔跑，你就知道学习的意义所在！

以上进阶BATJ大厂学习资料可以免费分享给大家，需要完整版的朋友，【点这里可以看到全部内容】。

CacheKey,

options, listener, progressListener, engine.getLockForUri(uri));

LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,

defineHandler(options));

if (options.isSyncLoading()) {

displayTask.run();

} else {

engine.submit(displayTask);

}

如果此时的显示加载是异步的话，则交由engine的Executor线程池去处理，最终也是调用了LoadAndDisplayImageTask的run方法去加载显示。

原文链接：https://www.jianshu.com/p/cff58eddb4ae

阿里P7移动互联网架构师进阶视频（每日更新中）免费学习请点击：https://space.bilibili.com/474380680

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-pdgyRr0S-1710691752389)]
[外链图片转存中…(img-6E06lpcF-1710691752390)]
[外链图片转存中…(img-HMi4hYbz-1710691752390)]
[外链图片转存中…(img-0wtFsA5R-1710691752390)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-VdxPUrHS-1710691752391)]

最后

不断奔跑，你就知道学习的意义所在！

以上进阶BATJ大厂学习资料可以免费分享给大家，需要完整版的朋友，【点这里可以看到全部内容】。

功勋Web工程师

关注

15
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
图片加载框架之图片加载框架选型（一）上篇

我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了7、8年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
复制链接

扫一扫

专栏目录