Universal-Image-Loader完全解析

标签：

相信大家平时做Android应用的时候，多少会接触到异步加载图片，或者加载大量图片的问题，而加载图片我们常常会遇到许多的问题，比如说图片的错乱，OOM等问题，对于新手来说，这些问题解决起来会比较吃力，所以就有很多的开源图片加载框架应运而生，比较著名的就是Universal-Image-Loader，相信很多朋友都听过或者使用过这个强大的图片加载框架，今天这篇文章就是对这个框架的基本介绍以及使用，主要是帮助那些没有使用过这个框架的朋友们。该项目存在于Github上面https://github.com/hgl888/Android-Universal-Image-Loader，我们可以先看看这个开源库存在哪些特征

1. 多线程下载图片，图片可以来源于网络，文件系统，项目文件夹assets中以及drawable中等
2. 支持随意的配置ImageLoader，例如线程池，图片下载器，内存缓存策略，硬盘缓存策略，图片显示选项以及其他的一些配置
3. 支持图片的内存缓存，文件系统缓存或者SD卡缓存
4. 支持图片下载过程的监听
5. 根据控件(ImageView)的大小对Bitmap进行裁剪，减少Bitmap占用过多的内存
6. 较好的控制图片的加载过程，例如暂停图片加载，重新开始加载图片，一般使用在ListView,GridView中，滑动过程中暂停加载图片，停止滑动的时候去加载图片
7. 提供在较慢的网络下对图片进行加载

当然上面列举的特性可能不全，要想了解一些其他的特性只能通过我们的使用慢慢去发现了，接下来我们就看看这个开源库的简单使用吧

新建一个Android项目，下载JAR包添加到工程libs目录下

新建一个MyApplication继承Application，并在onCreate()中创建ImageLoader的配置参数，并初始化到ImageLoader中代码如下

[java] view plain copy

 

1. package com.example.uil;  
2.   
3. import com.nostra13.universalimageloader.core.ImageLoader;  
4. import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;  
5.   
6. import android.app.Application;  
7.   
8. public class MyApplication extends Application {  
9.   
10.     @Override  
11.     public void onCreate() {  
12.         super.onCreate();  
13.   
14.         //创建默认的ImageLoader配置参数  
15.         ImageLoaderConfiguration configuration = ImageLoaderConfiguration.createDefault(this);  
16.           
17.         //Initialize ImageLoader with configuration.  
18.         ImageLoader.getInstance().init(configuration);  
19.     }  
20.   
21. }  

ImageLoaderConfiguration是图片加载器ImageLoader的配置参数，使用了建造者模式，这里是直接使用了createDefault()方法创建一个默认的ImageLoaderConfiguration，当然我们还可以自己设置ImageLoaderConfiguration，设置如下

[java] view plain copy

 

1. File cacheDir = StorageUtils.getCacheDirectory(context);  
2. ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(context)  
3.         .memoryCacheExtraOptions(480, 800) // default = device screen dimensions  
4.         .diskCacheExtraOptions(480, 800, CompressFormat.JPEG, 75, null)  
5.         .taskExecutor(...)  
6.         .taskExecutorForCachedImages(...)  
7.         .threadPoolSize(3) // default  
8.         .threadPriority(Thread.NORM_PRIORITY - 1) // default  
9.         .tasksProcessingOrder(QueueProcessingType.FIFO) // default  
10.         .denyCacheImageMultipleSizesInMemory()  
11.         .memoryCache(new LruMemoryCache(2 * 1024 * 1024))  
12.         .memoryCacheSize(2 * 1024 * 1024)  
13.         .memoryCacheSizePercentage(13) // default  
14.         .diskCache(new UnlimitedDiscCache(cacheDir)) // default  
15.         .diskCacheSize(50 * 1024 * 1024)  
16.         .diskCacheFileCount(100)  
17.         .diskCacheFileNameGenerator(new HashCodeFileNameGenerator()) // default  
18.         .imageDownloader(new BaseImageDownloader(context)) // default  
19.         .imageDecoder(new BaseImageDecoder()) // default  
20.         .defaultDisplayImageOptions(DisplayImageOptions.createSimple()) // default  
21.         .writeDebugLogs()  
22.         .build();  

上面的这些就是所有的选项配置，我们在项目中不需要每一个都自己设置，一般使用createDefault()创建的ImageLoaderConfiguration就能使用，然后调用ImageLoader的init（）方法将ImageLoaderConfiguration参数传递进去，ImageLoader使用单例模式。

配置Android Manifest文件

[html] view plain copy

 

1. <manifest>  
2.     <uses-permission android:name="android.permission.INTERNET" />  
3.     <!-- Include next permission if you want to allow UIL to cache images on SD card -->  
4.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />  
5.     ...  
6.     <application android:name="MyApplication">  
7.         ...  
8.     </application>  
9. </manifest>  

[html] view plain copy

 

1. <?xml version="1.0" encoding="utf-8"?>  
2. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
3.     android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent">  
5.   
6.     <ImageView  
7.         android:layout_gravity="center"  
8.         android:id="@+id/image"  
9.         android:src="@drawable/ic_empty"  
10.         android:layout_width="wrap_content"  
11.         android:layout_height="wrap_content" />  
12.   
13. </FrameLayout>  

里面只有一个ImageView，很简单，接下来我们就去加载图片，我们会发现ImageLader提供了几个图片加载的方法，主要是这几个displayImage(), loadImage(),loadImageSync()，loadImageSync()方法是同步的，android4.0有个特性，网络操作不能在主线程，所以loadImageSync()方法我们就不去使用

.

loadimage()加载图片

我们先使用ImageLoader的loadImage()方法来加载网络图片

[java] view plain copy

 

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";  
3.           
4.         ImageLoader.getInstance().loadImage(imageUrl, new ImageLoadingListener() {  
5.               
6.             @Override  
7.             public void onLoadingStarted(String imageUri, View view) {  
8.                   
9.             }  
10.               
11.             @Override  
12.             public void onLoadingFailed(String imageUri, View view,  
13.                     FailReason failReason) {  
14.                   
15.             }  
16.               
17.             @Override  
18.             public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {  
19.                 mImageView.setImageBitmap(loadedImage);  
20.             }  
21.               
22.             @Override  
23.             public void onLoadingCancelled(String imageUri, View view) {  
24.                   
25.             }  
26.         });  

[java] view plain copy

 

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";  
3.           
4.         ImageLoader.getInstance().loadImage(imageUrl, new SimpleImageLoadingListener(){  
5.   
6.             @Override  
7.             public void onLoadingComplete(String imageUri, View view,  
8.                     Bitmap loadedImage) {  
9.                 super.onLoadingComplete(imageUri, view, loadedImage);  
10.                 mImageView.setImageBitmap(loadedImage);  
11.             }  
12.               
13.         });  

[java] view plain copy

 

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";  
3.           
4.         ImageSize mImageSize = new ImageSize(100, 100);  
5.           
6.         ImageLoader.getInstance().loadImage(imageUrl, mImageSize, new SimpleImageLoadingListener(){  
7.   
8.             @Override  
9.             public void onLoadingComplete(String imageUri, View view,  
10.                     Bitmap loadedImage) {  
11.                 super.onLoadingComplete(imageUri, view, loadedImage);  
12.                 mImageView.setImageBitmap(loadedImage);  
13.             }  
14.               
15.         });  

上面只是很简单的使用ImageLoader来加载网络图片，在实际的开发中，我们并不会这么使用，那我们平常会怎么使用呢？我们会用到DisplayImageOptions，他可以配置一些图片显示的选项，比如图片在加载中ImageView显示的图片，是否需要使用内存缓存，是否需要使用文件缓存等等，可供我们选择的配置如下

[java] view plain copy

 

1. DisplayImageOptions options = new DisplayImageOptions.Builder()  
2.         .showImageOnLoading(R.drawable.ic_stub) // resource or drawable  
3.         .showImageForEmptyUri(R.drawable.ic_empty) // resource or drawable  
4.         .showImageOnFail(R.drawable.ic_error) // resource or drawable  
5.         .resetViewBeforeLoading(false)  // default  
6.         .delayBeforeLoading(1000)  
7.         .cacheInMemory(false) // default  
8.         .cacheOnDisk(false) // default  
9.         .preProcessor(...)  
10.         .postProcessor(...)  
11.         .extraForDownloader(...)  
12.         .considerExifParams(false) // default  
13.         .imageScaleType(ImageScaleType.IN_SAMPLE_POWER_OF_2) // default  
14.         .bitmapConfig(Bitmap.Config.ARGB_8888) // default  
15.         .decodingOptions(...)  
16.         .displayer(new SimpleBitmapDisplayer()) // default  
17.         .handler(new Handler()) // default  
18.         .build();  

[java] view plain copy

 

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";  
3.         ImageSize mImageSize = new ImageSize(100, 100);  
4.           
5.         //显示图片的配置  
6.         DisplayImageOptions options = new DisplayImageOptions.Builder()  
7. .showImageOnLoading(R.drawable.ic_stub)
8. .showImageForEmptyUri(R.drawable.ic_empty)
9. .showImageOnFail(R.drawable.ic_error)
10.                 .cacheInMemory(true)  
11.                 .cacheOnDisk(true)
12. .considerExifParams(true)
13.                 .bitmapConfig(Bitmap.Config.RGB_565)  
14.                 .build();  
15.           
16.         ImageLoader.getInstance().loadImage(imageUrl, mImageSize, options, new SimpleImageLoadingListener(){  
17.   
18.             @Override  
19.             public void onLoadingComplete(String imageUri, View view,  
20.                     Bitmap loadedImage) {  
21.                 super.onLoadingComplete(imageUri, view, loadedImage);  
22.                 mImageView.setImageBitmap(loadedImage);  
23.             }  
24.               
25.         });  

我们使用了DisplayImageOptions来配置显示图片的一些选项，这里我添加了将图片缓存到内存中已经缓存图片到文件系统中，这样我们就不用担心每次都从网络中去加载图片了，是不是很方便呢，但是DisplayImageOptions选项中有些选项对于loadImage()方法是无效的，比如showImageOnLoading, showImageForEmptyUri等，

displayImage()加载图片

接下来我们就来看看网络图片加载的另一个方法displayImage()，代码如下

[java] view plain copy

 

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";  
3.           
4.         //显示图片的配置  
5.         DisplayImageOptions options = new DisplayImageOptions.Builder()  
6.                 .showImageOnLoading(R.drawable.ic_stub)  
7.                 .showImageOnFail(R.drawable.ic_error)  
8.                 .cacheInMemory(true)  
9.                 .cacheOnDisk(true)  
10.                 .bitmapConfig(Bitmap.Config.RGB_565)  
11.                 .build();  
12.           
13.         ImageLoader.getInstance().displayImage(imageUrl, mImageView, options);  

从上面的代码中，我们可以看出，使用displayImage()比使用loadImage()方便很多，也不需要添加ImageLoadingListener接口，我们也不需要手动设置ImageView显示Bitmap对象，直接将ImageView作为参数传递到displayImage()中就行了，图片显示的配置选项中，我们添加了一个图片加载中ImageVIew上面显示的图片，以及图片加载出现错误显示的图片，效果如下，刚开始显示ic_stub图片，如果图片加载成功显示图片，加载产生错误显示ic_error

[java] view plain copy

 

1. public class MyApplication extends Application {  
2.   
3.     @Override  
4.     public void onCreate() {  
5.         super.onCreate();  
6.   
7.         //创建默认的ImageLoader配置参数  
8.         ImageLoaderConfiguration configuration = new ImageLoaderConfiguration.Builder(this)  
9.         .writeDebugLogs() //打印log信息  
10.         .build();  
11.           
12.           
13.         //Initialize ImageLoader with configuration.  
14.         ImageLoader.getInstance().init(configuration);  
15.     }  
16.   
17. }  

第一条信息中，告诉我们开始加载图片，打印出图片的url以及图片的最大宽度和高度，图片的宽高默认是设备的宽高，当然如果我们很清楚图片的大小，我们也可以去设置这个大小，在ImageLoaderConfiguration的选项中memoryCacheExtraOptions(int maxImageWidthForMemoryCache, int maxImageHeightForMemoryCache)

第二条信息显示我们加载的图片来源于网络

第三条信息显示图片的原始大小为1024 x 682 经过裁剪变成了512 x 341 

第四条显示图片加入到了内存缓存中，我这里没有加入到sd卡中，所以没有加入文件缓存的Log

我们在加载网络图片的时候，经常有需要显示图片下载进度的需求，Universal-Image-Loader当然也提供这样的功能，只需要在displayImage()方法中传入ImageLoadingProgressListener接口就行了，代码如下

[java] view plain copy

 

1. imageLoader.displayImage(imageUrl, mImageView, options, new SimpleImageLoadingListener(), new ImageLoadingProgressListener() {  
2.               
3.             @Override  
4.             public void onProgressUpdate(String imageUri, View view, int current,  
5.                     int total) {  
6.                   
7.             }  
8.         });  

加载其他来源的图片

使用Universal-Image-Loader框架不仅可以加载网络图片，还可以加载sd卡中的图片，Content provider等，使用也很简单，只是将图片的url稍加的改变下就行了，下面是加载文件系统的图片

[java] view plain copy

 

1. //显示图片的配置  
2.         DisplayImageOptions options = new DisplayImageOptions.Builder()  
3.                 .showImageOnLoading(R.drawable.ic_stub)  
4.                 .showImageOnFail(R.drawable.ic_error)  
5.                 .cacheInMemory(true)  
6.                 .cacheOnDisk(true)  
7.                 .bitmapConfig(Bitmap.Config.RGB_565)  
8.                 .build();  
9.           
10.         final ImageView mImageView = (ImageView) findViewById(R.id.image);  
11.         String imagePath = "/mnt/sdcard/image.png";  
12.         String imageUrl = Scheme.FILE.wrap(imagePath);  
13.           
14. //      String imageUrl = "http://img.my.csdn.net/uploads/201309/01/1378037235_7476.jpg";  
15.           
16.         imageLoader.displayImage(imageUrl, mImageView, options);  

[java] view plain copy

 

1. //图片来源于Content provider  
2.         String contentprividerUrl = "content://media/external/audio/albumart/13";  
3.           
4.         //图片来源于assets  
5.         String assetsUrl = Scheme.ASSETS.wrap("image.png");  
6.           
7.         //图片来源于  
8.         String drawableUrl = Scheme.DRAWABLE.wrap("R.drawable.image");  

相信大部分人都是使用GridView，ListView来显示大量的图片，而当我们快速滑动GridView，ListView，我们希望能停止图片的加载，而在GridView，ListView停止滑动的时候加载当前界面的图片，这个框架当然也提供这个功能，使用起来也很简单，它提供了PauseOnScrollListener这个类来控制ListView,GridView滑动过程中停止去加载图片，该类使用的是代理模式

[java] view plain copy

 

1. listView.setOnScrollListener(new PauseOnScrollListener(imageLoader, pauseOnScroll, pauseOnFling));  
2.         gridView.setOnScrollListener(new PauseOnScrollListener(imageLoader, pauseOnScroll, pauseOnFling));  

OutOfMemoryError

虽然这个框架有很好的缓存机制，有效的避免了OOM的产生，一般的情况下产生OOM的概率比较小，但是并不能保证OutOfMemoryError永远不发生，这个框架对于OutOfMemoryError做了简单的catch,保证我们的程序遇到OOM而不被crash掉，但是如果我们使用该框架经常发生OOM，我们应该怎么去改善呢？

• 减少线程池中线程的个数，在ImageLoaderConfiguration中的（.threadPoolSize）中配置，推荐配置1-5
• 在DisplayImageOptions选项中配置bitmapConfig为Bitmap.Config.RGB_565，因为默认是ARGB_8888， 使用RGB_565会比使用ARGB_8888少消耗2倍的内存
• 在ImageLoaderConfiguration中配置图片的内存缓存为memoryCache(new WeakMemoryCache()) 或者不使用内存缓存
• 在DisplayImageOptions选项中设置.imageScaleType(ImageScaleType.IN_SAMPLE_INT)或者imageScaleType(ImageScaleType.EXACTLY)

通过上面这些，相信大家对Universal-Image-Loader框架的使用已经非常的了解了，我们在使用该框架的时候尽量的使用displayImage()方法去加载图片，loadImage()是将图片对象回调到ImageLoadingListener接口的onLoadingComplete()方法中，需要我们手动去设置到ImageView上面，displayImage()方法中，对ImageView对象使用的是Weak references，方便垃圾回收器回收ImageView对象，如果我们要加载固定大小的图片的时候，使用loadImage()方法需要传递一个ImageSize对象，而displayImage()方法会根据ImageView对象的测量值，或者android:layout_width and android:layout_height设定的值，或者android:maxWidth and/or android:maxHeight设定的值来裁剪图片

继续为大家介绍Universal-Image-Loader这个开源的图片加载框架，介绍的是图片缓存策略方面的，我们一般去加载大量的图片的时候，都会做缓存策略，缓存又分为内存缓存和硬盘缓存，使用的内存缓存是LruCache这个类，LRU是Least Recently Used 近期最少使用算法，我们可以给LruCache设定一个缓存图片的最大值，它会自动帮我们管理好缓存的图片总大小是否超过我们设定的值， 超过就删除近期最少使用的图片，而作为一个强大的图片加载框架，Universal-Image-Loader自然也提供了多种图片的缓存策略，下面就来详细的介绍下

内存缓存

首先我们来了解下什么是强引用和什么是弱引用?

强引用是指创建一个对象并把这个对象赋给一个引用变量， 强引用有引用变量指向时永远不会被垃圾回收。即使内存不足的时候宁愿报OOM也不被垃圾回收器回收，我们new的对象都是强引用

弱引用通过weakReference类来实现，它具有很强的不确定性，如果垃圾回收器扫描到有着WeakReference的对象，就会将其回收释放内存

现在我们来看Universal-Image-Loader有哪些内存缓存策略

1. 只使用的是强引用缓存 

• LruMemoryCache（这个类就是这个开源框架默认的内存缓存类，缓存的是bitmap的强引用，下面我会从源码上面分析这个类）

2.使用强引用和弱引用相结合的缓存有

• UsingFreqLimitedMemoryCache（如果缓存的图片总量超过限定值，先删除使用频率最小的bitmap）
• LRULimitedMemoryCache（这个也是使用的lru算法，和LruMemoryCache不同的是，他缓存的是bitmap的弱引用）
• FIFOLimitedMemoryCache（先进先出的缓存策略，当超过设定值，先删除最先加入缓存的bitmap）
• LargestLimitedMemoryCache(当超过缓存限定值，先删除最大的bitmap对象)
• LimitedAgeMemoryCache（当 bitmap加入缓存中的时间超过我们设定的值，将其删除）

3.只使用弱引用缓存

• WeakMemoryCache（这个类缓存bitmap的总大小没有限制，唯一不足的地方就是不稳定，缓存的图片容易被回收掉）

上面介绍了Universal-Image-Loader所提供的所有的内存缓存的类，当然我们也可以使用我们自己写的内存缓存类，我们还要看看要怎么将这些内存缓存加入到我们的项目中，我们只需要配置ImageLoaderConfiguration.memoryCache(...)，如下

[java] view plain copy

 

1. ImageLoaderConfiguration configuration = new ImageLoaderConfiguration.Builder(this)  
2.         .memoryCache(new WeakMemoryCache())  
3.         .build();  

下面我们来分析LruMemoryCache这个类的源代码

[java] view plain copy

 

1. package com.nostra13.universalimageloader.cache.memory.impl;  
2.   
3. import android.graphics.Bitmap;  
4. import com.nostra13.universalimageloader.cache.memory.MemoryCacheAware;  
5.   
6. import java.util.Collection;  
7. import java.util.HashSet;  
8. import java.util.LinkedHashMap;  
9. import java.util.Map;  
10.   
11. /** 
12.  * A cache that holds strong references to a limited number of Bitmaps. Each time a Bitmap is accessed, it is moved to 
13.  * the head of a queue. When a Bitmap is added to a full cache, the Bitmap at the end of that queue is evicted and may 
14.  * become eligible for garbage collection.<br /> 
15.  * <br /> 
16.  * <b>NOTE:</b> This cache uses only strong references for stored Bitmaps. 
17.  * 
18.  * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) 
19.  * @since 1.8.1 
20.  */  
21. public class LruMemoryCache implements MemoryCacheAware<String, Bitmap> {  
22.   
23.     private final LinkedHashMap<String, Bitmap> map;  
24.   
25.     private final int maxSize;  
26.     /** Size of this cache in bytes */  
27.     private int size;  
28.   
29.     /** @param maxSize Maximum sum of the sizes of the Bitmaps in this cache */  
30.     public LruMemoryCache(int maxSize) {  
31.         if (maxSize <= 0) {  
32.             throw new IllegalArgumentException("maxSize <= 0");  
33.         }  
34.         this.maxSize = maxSize;  
35.         this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);  
36.     }  
37.   
38.     /** 
39.      * Returns the Bitmap for {@code key} if it exists in the cache. If a Bitmap was returned, it is moved to the head 
40.      * of the queue. This returns null if a Bitmap is not cached. 
41.      */  
42.     @Override  
43.     public final Bitmap get(String key) {  
44.         if (key == null) {  
45.             throw new NullPointerException("key == null");  
46.         }  
47.   
48.         synchronized (this) {  
49.             return map.get(key);  
50.         }  
51.     }  
52.   
53.     /** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */  
54.     @Override  
55.     public final boolean put(String key, Bitmap value) {  
56.         if (key == null || value == null) {  
57.             throw new NullPointerException("key == null || value == null");  
58.         }  
59.   
60.         synchronized (this) {  
61.             size += sizeOf(key, value);  
62.             Bitmap previous = map.put(key, value);  
63.             if (previous != null) {  
64.                 size -= sizeOf(key, previous);  
65.             }  
66.         }  
67.   
68.         trimToSize(maxSize);  
69.         return true;  
70.     }  
71.   
72.     /** 
73.      * Remove the eldest entries until the total of remaining entries is at or below the requested size. 
74.      * 
75.      * @param maxSize the maximum size of the cache before returning. May be -1 to evict even 0-sized elements. 
76.      */  
77.     private void trimToSize(int maxSize) {  
78.         while (true) {  
79.             String key;  
80.             Bitmap value;  
81.             synchronized (this) {  
82.                 if (size < 0 || (map.isEmpty() && size != 0)) {  
83.                     throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");  
84.                 }  
85.   
86.                 if (size <= maxSize || map.isEmpty()) {  
87.                     break;  
88.                 }  
89.   
90.                 Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();  
91.                 if (toEvict == null) {  
92.                     break;  
93.                 }  
94.                 key = toEvict.getKey();  
95.                 value = toEvict.getValue();  
96.                 map.remove(key);  
97.                 size -= sizeOf(key, value);  
98.             }  
99.         }  
100.     }  
101.   
102.     /** Removes the entry for {@code key} if it exists. */  
103.     @Override  
104.     public final void remove(String key) {  
105.         if (key == null) {  
106.             throw new NullPointerException("key == null");  
107.         }  
108.   
109.         synchronized (this) {  
110.             Bitmap previous = map.remove(key);  
111.             if (previous != null) {  
112.                 size -= sizeOf(key, previous);  
113.             }  
114.         }  
115.     }  
116.   
117.     @Override  
118.     public Collection<String> keys() {  
119.         synchronized (this) {  
120.             return new HashSet<String>(map.keySet());  
121.         }  
122.     }  
123.   
124.     @Override  
125.     public void clear() {  
126.         trimToSize(-1); // -1 will evict 0-sized elements  
127.     }  
128.   
129.     /** 
130.      * Returns the size {@code Bitmap} in bytes. 
131.      * <p/> 
132.      * An entry‘s size must not change while it is in the cache. 
133.      */  
134.     private int sizeOf(String key, Bitmap value) {  
135.         return value.getRowBytes() * value.getHeight();  
136.     }  
137.   
138.     @Override  
139.     public synchronized final String toString() {  
140.         return String.format("LruCache[maxSize=%d]", maxSize);  
141.     }  
142. }  

我们可以看到该缓存类比较简单，逻辑也比较清晰，如果大家想知道其他内存缓存的逻辑，可以去分析分析其源码，在这里我简单说下FIFOLimitedMemoryCache的实现逻辑，该类使用的HashMap来缓存bitmap的弱引用，然后使用LinkedList来保存成功加入到FIFOLimitedMemoryCache的bitmap的强引用，如果加入的FIFOLimitedMemoryCache的bitmap总数超过限定值，直接删除LinkedList的第一个元素，所以就实现了先进先出的缓存策略，其他的缓存都类似，有兴趣的可以去看看。

硬盘缓存

在新版本中，使用LruDiscCache代替LimitedAgeDiscCache，TotalSizeLimitedDiscCache，FileCountLimitedDiscCache

下面我们就来分析分析BaseDiscCache的源码实现

/*******************************************************************************
 * Copyright 2011-2014 Sergey Tarasevich
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************/
package com.nostra13.universalimageloader.cache.disc.impl;

import android.graphics.Bitmap;
import com.nostra13.universalimageloader.cache.disc.DiskCache;
import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;
import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;
import com.nostra13.universalimageloader.utils.IoUtils;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * Base disk cache.
 *
 * @author Sergey Tarasevich (nostra13[at]gmail[dot]com)
 * @see FileNameGenerator
 * @since 1.0.0
 */
public abstract class BaseDiskCache implements DiskCache {
   /** {@value */
   public static final int DEFAULT_BUFFER_SIZE = 32 * 1024; // 32 Kb
   /** {@value */
   public static final Bitmap.CompressFormat DEFAULT_COMPRESS_FORMAT = Bitmap.CompressFormat.PNG;
   /** {@value */
   public static final int DEFAULT_COMPRESS_QUALITY = 100;

   private static final String ERROR_ARG_NULL = " argument must be not null";
   private static final String TEMP_IMAGE_POSTFIX = ".tmp";

   protected final File cacheDir;
   protected final File reserveCacheDir;

   protected final FileNameGenerator fileNameGenerator;

   protected int bufferSize = DEFAULT_BUFFER_SIZE;

   protected Bitmap.CompressFormat compressFormat = DEFAULT_COMPRESS_FORMAT;
   protected int compressQuality = DEFAULT_COMPRESS_QUALITY;

   /** @param cacheDir Directory for file caching */
   public BaseDiskCache(File cacheDir) {
      this(cacheDir, null);
   }

   /**
    * @param cacheDir        Directory for file caching
    * @param reserveCacheDir null-ok; Reserve directory for file caching. It‘s used when the primary directory isn‘t available.
    */
   public BaseDiskCache(File cacheDir, File reserveCacheDir) {
      this(cacheDir, reserveCacheDir, DefaultConfigurationFactory.createFileNameGenerator());
   }

   /**
    * @param cacheDir          Directory for file caching
    * @param reserveCacheDir   null-ok; Reserve directory for file caching. It‘s used when the primary directory isn‘t available.
    * @param fileNameGenerator {@linkplain com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator
    *                          Name generator} for cached files
    */
   public BaseDiskCache(File cacheDir, File reserveCacheDir, FileNameGenerator fileNameGenerator) {
      if (cacheDir == null) {
         throw new IllegalArgumentException("cacheDir" + ERROR_ARG_NULL);
      }
      if (fileNameGenerator == null) {
         throw new IllegalArgumentException("fileNameGenerator" + ERROR_ARG_NULL);
      }

      this.cacheDir = cacheDir;
      this.reserveCacheDir = reserveCacheDir;
      this.fileNameGenerator = fileNameGenerator;
   }

   @Override
   public File getDirectory() {
      return cacheDir;
   }

   @Override
   public File get(String imageUri) {
      return getFile(imageUri);
   }

   @Override
   public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
      File imageFile = getFile(imageUri);
      File tmpFile = new File(imageFile.getAbsolutePath() + TEMP_IMAGE_POSTFIX);
      boolean loaded = false;
      try {
         OutputStream os = new BufferedOutputStream(new FileOutputStream(tmpFile), bufferSize);
         try {
            loaded = IoUtils.copyStream(imageStream, os, listener, bufferSize);
         } finally {
            IoUtils.closeSilently(os);
         }
      } finally {
         if (loaded && !tmpFile.renameTo(imageFile)) {
            loaded = false;
         }
         if (!loaded) {
            tmpFile.delete();
         }
      }
      return loaded;
   }

   @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 boolean remove(String imageUri) {
      return getFile(imageUri).delete();
   }

   @Override
   public void close() {
      // Nothing to do
   }

   @Override
   public void clear() {
      File[] files = cacheDir.listFiles();
      if (files != null) {
         for (File f : files) {
            f.delete();
         }
      }
   }

   /** Returns file object (not null) for incoming image URI. File object can reference to non-existing file. */
   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);
   }

   public void setBufferSize(int bufferSize) {
      this.bufferSize = bufferSize;
   }

   public void setCompressFormat(Bitmap.CompressFormat compressFormat) {
      this.compressFormat = compressFormat;
   }

   public void setCompressQuality(int compressQuality) {
      this.compressQuality = compressQuality;
   }
}

下面主要从源码的角度上面去解读这个强大的图片加载框架，

[java] view plain copy

 

1. ImageView mImageView = (ImageView) findViewById(R.id.image);    
2.         String imageUrl = "http://pic36.nipic.com/20131217/6704106_233034463381_2.jpg";    
3.             
4.         //显示图片的配置    
5.         DisplayImageOptions options = new DisplayImageOptions.Builder()    
6.                 .showImageOnLoading(R.drawable.ic_stub)    
7.                 .showImageOnFail(R.drawable.ic_error)    
8.                 .cacheInMemory(true)    
9.                 .cacheOnDisk(true)    
10.                 .bitmapConfig(Bitmap.Config.RGB_565)    
11.                 .build();    
12.             
13.         ImageLoader.getInstance().displayImage(imageUrl, mImageView, options);    

[java] view plain copy

 

1. public void displayImage(String uri, ImageView imageView, DisplayImageOptions options) {  
2.         displayImage(uri, new ImageViewAware(imageView), options, null, null);  
3.     }  

接下来看具体的displayImage方法啦，由于这个方法代码量蛮多的，所以这里我分开来读

[java] view plain copy

 

1. checkConfiguration();  
2.         if (imageAware == null) {  
3.             throw new IllegalArgumentException(ERROR_WRONG_ARGUMENTS);  
4.         }  
5.         if (listener == null) {  
6.             listener = emptyListener;  
7.         }  
8.         if (options == null) {  
9.             options = configuration.defaultDisplayImageOptions;  
10.         }  
11.   
12.         if (TextUtils.isEmpty(uri)) {  
13.             engine.cancelDisplayTaskFor(imageAware);  
14.             listener.onLoadingStarted(uri, imageAware.getWrappedView());  
15.             if (options.shouldShowImageForEmptyUri()) {  
16.                 imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));  
17.             } else {  
18.                 imageAware.setImageDrawable(null);  
19.             }  
20.             listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);  
21.             return;  
22.         }  

12-21行主要是针对url为空的时候做的处理，第13行代码中，ImageLoaderEngine中存在一个HashMap,用来记录正在加载的任务，加载图片的时候会将ImageView的id和图片的url加上尺寸加入到HashMap中，加载完成之后会将其移除，然后将DisplayImageOptions的imageResForEmptyUri的图片设置给ImageView,最后回调给ImageLoadingListener接口告诉它这次任务完成了。

[java] view plain copy

 

1. ImageSize targetSize = ImageSizeUtils.defineTargetSizeForView(imageAware, configuration.getMaxImageSize());  
2.     String memoryCacheKey = MemoryCacheUtils.generateKey(uri, targetSize);  
3.     engine.prepareDisplayTaskFor(imageAware, memoryCacheKey);  
4.   
5.     listener.onLoadingStarted(uri, imageAware.getWrappedView());  
6.   
7.     Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);  
8.     if (bmp != null && !bmp.isRecycled()) {  
9.         L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);  
10.   
11.         if (options.shouldPostProcess()) {  
12.             ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,  
13.                     options, listener, progressListener, engine.getLockForUri(uri));  
14.             ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,  
15.                     defineHandler(options));  
16.             if (options.isSyncLoading()) {  
17.                 displayTask.run();  
18.             } else {  
19.                 engine.submit(displayTask);  
20.             }  
21.         } else {  
22.             options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);  
23.             listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);  
24.         }  
25.     }  

第7行从内存缓存中获取Bitmap对象，我们可以再ImageLoaderConfiguration中配置内存缓存逻辑，默认使用的是LruMemoryCache,这个类我在前面的文章中讲过

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

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

[java] view plain copy

 

1. if (options.shouldShowImageOnLoading()) {  
2.                 imageAware.setImageDrawable(options.getImageOnLoading(configuration.resources));  
3.             } else if (options.isResetViewBeforeLoading()) {  
4.                 imageAware.setImageDrawable(null);  
5.             }  
6.   
7.             ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,  
8.                     options, listener, progressListener, engine.getLockForUri(uri));  
9.             LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,  
10.                     defineHandler(options));  
11.             if (options.isSyncLoading()) {  
12.                 displayTask.run();  
13.             } else {  
14.                 engine.submit(displayTask);  
15.             }  

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

[java] view plain copy

 

1. if (waitIfPaused()) return;  
2. if (delayIfNeed()) return;  

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

[java] view plain copy

 

1. private boolean waitIfPaused() {  
2.     AtomicBoolean pause = engine.getPause();  
3.     if (pause.get()) {  
4.         synchronized (engine.getPauseLock()) {  
5.             if (pause.get()) {  
6.                 L.d(LOG_WAITING_FOR_RESUME, memoryCacheKey);  
7.                 try {  
8.                     engine.getPauseLock().wait();  
9.                 } catch (InterruptedException e) {  
10.                     L.e(LOG_TASK_INTERRUPTED, memoryCacheKey);  
11.                     return true;  
12.                 }  
13.                 L.d(LOG_RESUME_AFTER_PAUSE, memoryCacheKey);  
14.             }  
15.         }  
16.     }  
17.     return isTaskNotActual();  
18. }  

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

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

[java] view plain copy

 

1. private boolean isTaskNotActual() {  
2.         return isViewCollected() || isViewReused();  
3.     }  

[java] view plain copy

 

1. ReentrantLock loadFromUriLock = imageLoadingInfo.loadFromUriLock;  
2.         L.d(LOG_START_DISPLAY_IMAGE_TASK, memoryCacheKey);  
3.         if (loadFromUriLock.isLocked()) {  
4.             L.d(LOG_WAITING_FOR_IMAGE_LOADED, memoryCacheKey);  
5.         }  
6.   
7.         loadFromUriLock.lock();  
8.         Bitmap bmp;  
9.         try {  
10.             checkTaskNotActual();  
11.   
12.             bmp = configuration.memoryCache.get(memoryCacheKey);  
13.             if (bmp == null || bmp.isRecycled()) {  
14.                 bmp = tryLoadBitmap();  
15.                 if (bmp == null) return; // listener callback already was fired  
16.   
17.                 checkTaskNotActual();  
18.                 checkTaskInterrupted();  
19.   
20.                 if (options.shouldPreProcess()) {  
21.                     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);  
22.                     bmp = options.getPreProcessor().process(bmp);  
23.                     if (bmp == null) {  
24.                         L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);  
25.                     }  
26.                 }  
27.   
28.                 if (bmp != null && options.isCacheInMemory()) {  
29.                     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);  
30.                     configuration.memoryCache.put(memoryCacheKey, bmp);  
31.                 }  
32.             } else {  
33.                 loadedFrom = LoadedFrom.MEMORY_CACHE;  
34.                 L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);  
35.             }  
36.   
37.             if (bmp != null && options.shouldPostProcess()) {  
38.                 L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);  
39.                 bmp = options.getPostProcessor().process(bmp);  
40.                 if (bmp == null) {  
41.                     L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);  
42.                 }  
43.             }  
44.             checkTaskNotActual();  
45.             checkTaskInterrupted();  
46.         } catch (TaskCancelledException e) {  
47.             fireCancelEvent();  
48.             return;  
49.         } finally {  
50.             loadFromUriLock.unlock();  
51.         }  

[java] view plain copy

 

1. ReentrantLock getLockForUri(String uri) {  
2.         ReentrantLock lock = uriLocks.get(uri);  
3.         if (lock == null) {  
4.             lock = new ReentrantLock();  
5.             uriLocks.put(uri, lock);  
6.         }  
7.         return lock;  
8.     }  

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

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

[java] view plain copy

 

1. File imageFile = configuration.diskCache.get(uri);  
2.             if (imageFile != null && imageFile.exists()) {  
3.                 L.d(LOG_LOAD_IMAGE_FROM_DISK_CACHE, memoryCacheKey);  
4.                 loadedFrom = LoadedFrom.DISC_CACHE;  
5.   
6.                 checkTaskNotActual();  
7.                 bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));  
8.             }  

[java] view plain copy

 

1. if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {  
2.             L.d(LOG_LOAD_IMAGE_FROM_NETWORK, memoryCacheKey);  
3.             loadedFrom = LoadedFrom.NETWORK;  
4.   
5.             String imageUriForDecoding = uri;  
6.             if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {  
7.                 imageFile = configuration.diskCache.get(uri);  
8.                 if (imageFile != null) {  
9.                     imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());  
10.                 }  
11.             }  
12.   
13.             checkTaskNotActual();  
14.             bitmap = decodeImage(imageUriForDecoding);  
15.   
16.             if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {  
17.                 fireFailEvent(FailType.DECODING_ERROR, null);  
18.             }  
19.         }  

[java] view plain copy

 

1. private Bitmap decodeImage(String imageUri) throws IOException {  
2.     ViewScaleType viewScaleType = imageAware.getScaleType();  
3.     ImageDecodingInfo decodingInfo = new ImageDecodingInfo(memoryCacheKey, imageUri, uri, targetSize, viewScaleType,  
4.             getDownloader(), options);  
5.     return decoder.decode(decodingInfo);  
6. }  
7.   
8. /** @return <b>true</b> - if image was downloaded successfully; <b>false</b> - otherwise */  
9. private boolean tryCacheImageOnDisk() throws TaskCancelledException {  
10.     L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);  
11.   
12.     boolean loaded;  
13.     try {  
14.         loaded = downloadImage();  
15.         if (loaded) {  
16.             int width = configuration.maxImageWidthForDiskCache;  
17.             int height = configuration.maxImageHeightForDiskCache;  
18.               
19.             if (width > 0 || height > 0) {  
20.                 L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);  
21.                 resizeAndSaveImage(width, height); // TODO : process boolean result  
22.             }  
23.         }  
24.     } catch (IOException e) {  
25.         L.e(e);  
26.         loaded = false;  
27.     }  
28.     return loaded;  
29. }  
30.   
31. private boolean downloadImage() throws IOException {  
32.     InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader());  
33.     return configuration.diskCache.save(uri, is, this);  
34. }  

第16-17行，获取ImageLoaderConfiguration是否设置保存在文件系统中的图片大小，如果设置了maxImageWidthForDiskCache和maxImageHeightForDiskCache，会调用resizeAndSaveImage()方法对图片进行裁剪然后在替换之前的原图，保存裁剪后的图片到文件系统的，之前有同学问过我说这个框架保存在文件系统的图片都是原图，怎么才能保存缩略图，只要在Application中实例化ImageLoaderConfiguration的时候设置maxImageWidthForDiskCache和maxImageHeightForDiskCache就行了

[java] view plain copy

 

1. if (bmp == null) return; // listener callback already was fired  
2.   
3.                 checkTaskNotActual();  
4.                 checkTaskInterrupted();  
5.   
6.                 if (options.shouldPreProcess()) {  
7.                     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);  
8.                     bmp = options.getPreProcessor().process(bmp);  
9.                     if (bmp == null) {  
10.                         L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);  
11.                     }  
12.                 }  
13.   
14.                 if (bmp != null && options.isCacheInMemory()) {  
15.                     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);  
16.                     configuration.memoryCache.put(memoryCacheKey, bmp);  
17.                 }  

[java] view plain copy

 

1. DisplayBitmapTask displayBitmapTask = new DisplayBitmapTask(bmp, imageLoadingInfo, engine, loadedFrom);  
2.         runTask(displayBitmapTask, syncLoading, handler, engine);  

[java] view plain copy

 

1. @Override  
2.     public void run() {  
3.         if (imageAware.isCollected()) {  
4.             L.d(LOG_TASK_CANCELLED_IMAGEAWARE_COLLECTED, memoryCacheKey);  
5.             listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());  
6.         } else if (isViewWasReused()) {  
7.             L.d(LOG_TASK_CANCELLED_IMAGEAWARE_REUSED, memoryCacheKey);  
8.             listener.onLoadingCancelled(imageUri, imageAware.getWrappedView());  
9.         } else {  
10.             L.d(LOG_DISPLAY_IMAGE_IN_IMAGEAWARE, loadedFrom, memoryCacheKey);  
11.             displayer.display(bitmap, imageAware, loadedFrom);  
12.             engine.cancelDisplayTaskFor(imageAware);  
13.             listener.onLoadingComplete(imageUri, imageAware.getWrappedView(), bitmap);  
14.         }  
15.     }  

假如ImageView被回收了或者被重用了，回调给ImageLoadingListener接口，否则就调用BitmapDisplayer去显示Bitmap

文章写到这里就已经写完了，不知道大家对这个开源框架有没有进一步的理解，这个开源框架设计也很灵活，用了很多的设计模式，比如建造者模式，装饰模式，代理模式，策略模式等等，这样方便我们去扩展，实现我们想要的功能，今天的讲解就到这了，有对这个框架不明白的地方可以在下面留言，我会尽量为大家解答的。

Universal-Image-Loader完全解析

标签：

原文地址：http://blog.csdn.net/hgl868/article/details/51199497