Android 開源架構Universal-Image-Loader完全解析

轉載請注明本文出自xiaanming的部落格（http://blog.csdn.net/xiaanming/article/details/26810303），請尊重他人的辛勤勞動成果，謝謝！

大家好！差不多兩個來月沒有寫文章了，前段時間也是在忙換工作的事，準備筆試面試什麼的事情，現在新工作找好了，新工作自己也比較滿意，唯一遺憾的就是自己要去一個新的城市，新的環境新的開始，希望自己能盡快的适應新環境，現在在準備交接的事情，自己也有一些時間了，是以就繼續給大家分享Android方面的東西。

相信大家平時做Android應用的時候，多少會接觸到異步加載圖檔，或者加載大量圖檔的問題，而加載圖檔我們常常會遇到許多的問題，比如說圖檔的錯亂，OOM等問題，對于新手來說，這些問題解決起來會比較吃力，是以就有很多的開源圖檔加載架構應運而生，比較著名的就是Universal-Image-Loader，相信很多朋友都聽過或者使用過這個強大的圖檔加載架構，今天這篇文章就是對這個架構的基本介紹以及使用，主要是幫助那些沒有使用過這個架構的朋友們。該項目存在于Github上面https://github.com/nostra13/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. import com.nostra13.universalimageloader.core.ImageLoader;  
3. import com.nostra13.universalimageloader.core.ImageLoaderConfiguration;  
4. import android.app.Application;  
5. public class MyApplication extends Application {  
6.     @Override  
7.     public void onCreate() {  
8.         super.onCreate();  
9.         //建立預設的ImageLoader配置參數  
10.         ImageLoaderConfiguration configuration = ImageLoaderConfiguration  
11.                 .createDefault(this);  
12.         //Initialize ImageLoader with configuration.  
13.         ImageLoader.getInstance().init(configuration);  
14.     }  
15. }  

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>  

接下來我們就可以來加載圖檔了，首先我們定義好Activity的布局檔案

[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.     <ImageView  
6.         android:layout_gravity="center"  
7.         android:id="@+id/image"  
8.         android:src="@drawable/ic_empty"  
9.         android:layout_width="wrap_content"  
10.         android:layout_height="wrap_content" />  
11. </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 = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";  
3.         ImageLoader.getInstance().loadImage(imageUrl, new ImageLoadingListener() {  
4.             @Override  
5.             public void onLoadingStarted(String imageUri, View view) {  
6.             }  
7.             @Override  
8.             public void onLoadingFailed(String imageUri, View view,  
9.                     FailReason failReason) {  
10.             }  
11.             @Override  
12.             public void onLoadingComplete(String imageUri, View view, Bitmap loadedImage) {  
13.                 mImageView.setImageBitmap(loadedImage);  
14.             }  
15.             @Override  
16.             public void onLoadingCancelled(String imageUri, View view) {  
17.             }  
18.         });  

傳入圖檔的url和ImageLoaderListener, 在回調方法onLoadingComplete()中将loadedImage設定到ImageView上面就行了，如果你覺得傳入ImageLoaderListener太複雜了，我們可以使用SimpleImageLoadingListener類，該類提供了ImageLoaderListener接口方法的空實作，使用的是預設擴充卡模式

[java]  view plain copy

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";  
3.         ImageLoader.getInstance().loadImage(imageUrl, new SimpleImageLoadingListener(){  
4.             @Override  
5.             public void onLoadingComplete(String imageUri, View view,  
6.                     Bitmap loadedImage) {  
7.                 super.onLoadingComplete(imageUri, view, loadedImage);  
8.                 mImageView.setImageBitmap(loadedImage);  
9.             }  
10.         });  

如果我們要指定圖檔的大小該怎麼辦呢，這也好辦，初始化一個ImageSize對象，指定圖檔的寬和高，代碼如下

[java]  view plain copy

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";  
3.         ImageSize mImageSize = new ImageSize(100, 100);  
4.         ImageLoader.getInstance().loadImage(imageUrl, mImageSize, new SimpleImageLoadingListener(){  
5.             @Override  
6.             public void onLoadingComplete(String imageUri, View view,  
7.                     Bitmap loadedImage) {  
8.                 super.onLoadingComplete(imageUri, view, loadedImage);  
9.                 mImageView.setImageBitmap(loadedImage);  
10.             }  
11.         });  

上面隻是很簡單的使用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 = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";  
3.         ImageSize mImageSize = new ImageSize(100, 100);  
4.         //顯示圖檔的配置  
5.         DisplayImageOptions options = new DisplayImageOptions.Builder()  
6.                 .cacheInMemory(true)  
7.                 .cacheOnDisk(true)  
8.                 .bitmapConfig(Bitmap.Config.RGB_565)  
9.                 .build();  
10.         ImageLoader.getInstance().loadImage(imageUrl, mImageSize, options, new SimpleImageLoadingListener(){  
11.             @Override  
12.             public void onLoadingComplete(String imageUri, View view,  
13.                     Bitmap loadedImage) {  
14.                 super.onLoadingComplete(imageUri, view, loadedImage);  
15.                 mImageView.setImageBitmap(loadedImage);  
16.             }  
17.         });  

我們使用了DisplayImageOptions來配置顯示圖檔的一些選項，這裡我添加了将圖檔緩存到記憶體中已經緩存圖檔到檔案系統中，這樣我們就不用擔心每次都從網絡中去加載圖檔了，是不是很友善呢，但是DisplayImageOptions選項中有些選項對于loadImage()方法是無效的，比如showImageOnLoading, showImageForEmptyUri等，

displayImage()加載圖檔

接下來我們就來看看網絡圖檔加載的另一個方法displayImage()，代碼如下

[java]  view plain copy

1. final ImageView mImageView = (ImageView) findViewById(R.id.image);  
2.         String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";  
3.         //顯示圖檔的配置  
4.         DisplayImageOptions options = new DisplayImageOptions.Builder()  
5.                 .showImageOnLoading(R.drawable.ic_stub)  
6.                 .showImageOnFail(R.drawable.ic_error)  
7.                 .cacheInMemory(true)  
8.                 .cacheOnDisk(true)  
9.                 .bitmapConfig(Bitmap.Config.RGB_565)  
10.                 .build();  
11.         ImageLoader.getInstance().displayImage(imageUrl, mImageView, options);  

從上面的代碼中，我們可以看出，使用displayImage()比使用loadImage()友善很多，也不需要添加ImageLoadingListener接口，我們也不需要手動設定ImageView顯示Bitmap對象，直接将ImageView作為參數傳遞到displayImage()中就行了，圖檔顯示的配置選項中，我們添加了一個圖檔加載中ImageVIew上面顯示的圖檔，以及圖檔加載出現錯誤顯示的圖檔，效果如下，剛開始顯示ic_stub圖檔，如果圖檔加載成功顯示圖檔，加載産生錯誤顯示ic_error

這個方法使用起來比較友善，而且使用displayImage()方法 他會根據控件的大小和imageScaleType來自動裁剪圖檔，我們修改下MyApplication，開啟Log列印

[java]  view plain copy

1. public class MyApplication extends Application {  
2.     @Override  
3.     public void onCreate() {  
4.         super.onCreate();  
5.         //建立預設的ImageLoader配置參數  
6.         ImageLoaderConfiguration configuration = new ImageLoaderConfiguration.Builder(this)  
7.         .writeDebugLogs() //列印log資訊  
8.         .build();  
9.         //Initialize ImageLoader with configuration.  
10.         ImageLoader.getInstance().init(configuration);  
11.     }  
12. }  

我們來看下圖檔加載的Log資訊

第一條資訊中，告訴我們開始加載圖檔，列印出圖檔的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.             @Override  
3.             public void onProgressUpdate(String imageUri, View view, int current,  
4.                     int total) {  
5.             }  
6.         });  

由于displayImage()方法中帶ImageLoadingProgressListener參數的方法都有帶ImageLoadingListener參數，是以我這裡直接new 一個SimpleImageLoadingListener，然後我們就可以在回調方法onProgressUpdate()得到圖檔的加載進度。

加載其他來源的圖檔

使用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.         final ImageView mImageView = (ImageView) findViewById(R.id.image);  
10.         String imagePath = "/mnt/sdcard/image.png";  
11.         String imageUrl = Scheme.FILE.wrap(imagePath);  
12. //      String imageUrl = "https://img-my.csdn.net/uploads/201309/01/1378037235_7476.jpg";  
13.         imageLoader.displayImage(imageUrl, mImageView, options);  

當然還有來源于Content provider,drawable,assets中，使用的時候也很簡單，我們隻需要給每個圖檔來源的地方加上Scheme包裹起來(Content provider除外)，然後當做圖檔的url傳遞到imageLoader中，Universal-Image-Loader架構會根據不同的Scheme擷取到輸入流

[java]  view plain copy

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

GirdView,ListView加載圖檔

相信大部分人都是使用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));  

第一個參數就是我們的圖檔加載對象ImageLoader, 第二個是控制是否在滑動過程中暫停加載圖檔，如果需要暫停傳true就行了，第三個參數控制猛的滑動界面的時候圖檔是否加載

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這個開源的圖檔加載架構，介紹的是圖檔緩存政策方面的，如果大家對這個開源架構的使用還不了解，大家可以看看我之前寫的一篇文章Android 開源架構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. import android.graphics.Bitmap;  
3. import com.nostra13.universalimageloader.cache.memory.MemoryCacheAware;  
4. import java.util.Collection;  
5. import java.util.HashSet;  
6. import java.util.LinkedHashMap;  
7. import java.util.Map;  
8. public class LruMemoryCache implements MemoryCacheAware<String, Bitmap> {  
9.     private final LinkedHashMap<String, Bitmap> map;  
10.     private final int maxSize;  
11.     private int size;  
12.     public LruMemoryCache(int maxSize) {  
13.         if (maxSize <= 0) {  
14.             throw new IllegalArgumentException("maxSize <= 0");  
15.         }  
16.         this.maxSize = maxSize;  
17.         this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);  
18.     }  
19.     @Override  
20.     public final Bitmap get(String key) {  
21.         if (key == null) {  
22.             throw new NullPointerException("key == null");  
23.         }  
24.         synchronized (this) {  
25.             return map.get(key);  
26.         }  
27.     }  
28.     @Override  
29.     public final boolean put(String key, Bitmap value) {  
30.         if (key == null || value == null) {  
31.             throw new NullPointerException("key == null || value == null");  
32.         }  
33.         synchronized (this) {  
34.             size += sizeOf(key, value);  
35.             Bitmap previous = map.put(key, value);  
36.             if (previous != null) {  
37.                 size -= sizeOf(key, previous);  
38.             }  
39.         }  
40.         trimToSize(maxSize);  
41.         return true;  
42.     }  
43.     private void trimToSize(int maxSize) {  
44.         while (true) {  
45.             String key;  
46.             Bitmap value;  
47.             synchronized (this) {  
48.                 if (size < 0 || (map.isEmpty() && size != 0)) {  
49.                     throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");  
50.                 }  
51.                 if (size <= maxSize || map.isEmpty()) {  
52.                     break;  
53.                 }  
54.                 Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();  
55.                 if (toEvict == null) {  
56.                     break;  
57.                 }  
58.                 key = toEvict.getKey();  
59.                 value = toEvict.getValue();  
60.                 map.remove(key);  
61.                 size -= sizeOf(key, value);  
62.             }  
63.         }  
64.     }  
65.     @Override  
66.     public final void remove(String key) {  
67.         if (key == null) {  
68.             throw new NullPointerException("key == null");  
69.         }  
70.         synchronized (this) {  
71.             Bitmap previous = map.remove(key);  
72.             if (previous != null) {  
73.                 size -= sizeOf(key, previous);  
74.             }  
75.         }  
76.     }  
77.     @Override  
78.     public Collection<String> keys() {  
79.         synchronized (this) {  
80.             return new HashSet<String>(map.keySet());  
81.         }  
82.     }  
83.     @Override  
84.     public void clear() {  
85.         trimToSize(-1); // -1 will evict 0-sized elements  
86.     }  
87.     private int sizeOf(String key, Bitmap value) {  
88.         return value.getRowBytes() * value.getHeight();  
89.     }  
90.     @Override  
91.     public synchronized final String toString() {  
92.         return String.format("LruCache[maxSize=%d]", maxSize);  
93.     }  
94. }  

我們可以看到這個類中維護的是一個LinkedHashMap，在LruMemoryCache構造函數中我們可以看到，我們為其設定了一個緩存圖檔的最大值maxSize，并執行個體化LinkedHashMap， 而從LinkedHashMap構造函數的第三個參數為ture，表示它是按照通路順序進行排序的，

我們來看将bitmap加入到LruMemoryCache的方法put(String key, Bitmap value),  第61行，sizeOf()是計算每張圖檔所占的byte數，size是記錄目前緩存bitmap的總大小，如果該key之前就緩存了bitmap,我們需要将之前的bitmap減掉去，接下來看trimToSize()方法，我們直接看86行，如果目前緩存的bitmap總數小于設定值maxSize，不做任何處理，如果目前緩存的bitmap總數大于maxSize,删除LinkedHashMap中的第一個元素，size中減去該bitmap對應的byte數

我們可以看到該緩存類比較簡單，邏輯也比較清晰，如果大家想知道其他記憶體緩存的邏輯，可以去分析分析其源碼，在這裡我簡單說下FIFOLimitedMemoryCache的實作邏輯，該類使用的HashMap來緩存bitmap的弱引用，然後使用LinkedList來儲存成功加入到FIFOLimitedMemoryCache的bitmap的強引用，如果加入的FIFOLimitedMemoryCache的bitmap總數超過限定值，直接删除LinkedList的第一個元素，是以就實作了先進先出的緩存政策，其他的緩存都類似，有興趣的可以去看看。

硬碟緩存

接下來就給大家分析分析硬碟緩存的政策，這個架構也提供了幾種常見的緩存政策，當然如果你覺得都不符合你的要求，你也可以自己去擴充

• FileCountLimitedDiscCache（可以設定緩存圖檔的個數，當超過設定值，删除掉最先加入到硬碟的檔案）
• LimitedAgeDiscCache（設定檔案存活的最長時間，當超過這個值，就删除該檔案）
• TotalSizeLimitedDiscCache（設定緩存bitmap的最大值，當超過這個值，删除最先加入到硬碟的檔案）
• UnlimitedDiscCache（這個緩存類沒有任何的限制）

下面我們就來分析分析TotalSizeLimitedDiscCache的源碼實作

[java]  view plain copy

1. package com.nostra13.universalimageloader.cache.disc.impl;  
2. import com.nostra13.universalimageloader.cache.disc.LimitedDiscCache;  
3. import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;  
4. import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;  
5. import com.nostra13.universalimageloader.utils.L;  
6. import java.io.File;  
7. public class TotalSizeLimitedDiscCache extends LimitedDiscCache {  
8.     private static final int MIN_NORMAL_CACHE_SIZE_IN_MB = 2;  
9.     private static final int MIN_NORMAL_CACHE_SIZE = MIN_NORMAL_CACHE_SIZE_IN_MB * 1024 * 1024;  
10.     public TotalSizeLimitedDiscCache(File cacheDir, int maxCacheSize) {  
11.         this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), maxCacheSize);  
12.     }  
13.     public TotalSizeLimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int maxCacheSize) {  
14.         super(cacheDir, fileNameGenerator, maxCacheSize);  
15.         if (maxCacheSize < MIN_NORMAL_CACHE_SIZE) {  
16.             L.w("You set too small disc cache size (less than %1$d Mb)", MIN_NORMAL_CACHE_SIZE_IN_MB);  
17.         }  
18.     }  
19.     @Override  
20.     protected int getSize(File file) {  
21.         return (int) file.length();  
22.     }  
23. }  

這個類是繼承LimitedDiscCache，除了兩個構造函數之外，還重寫了getSize()方法，傳回檔案的大小，接下來我們就來看看LimitedDiscCache [java]  view plain copy

1. package com.nostra13.universalimageloader.cache.disc;  
2. import com.nostra13.universalimageloader.cache.disc.naming.FileNameGenerator;  
3. import com.nostra13.universalimageloader.core.DefaultConfigurationFactory;  
4. import java.io.File;  
5. import java.util.Collections;  
6. import java.util.HashMap;  
7. import java.util.Map;  
8. import java.util.Map.Entry;  
9. import java.util.Set;  
10. import java.util.concurrent.atomic.AtomicInteger;  
11. public abstract class LimitedDiscCache extends BaseDiscCache {  
12.     private static final int INVALID_SIZE = -1;  
13.     //記錄緩存檔案的大小  
14.     private final AtomicInteger cacheSize;  
15.     //緩存檔案的最大值  
16.     private final int sizeLimit;  
17.     private final Map<File, Long> lastUsageDates = Collections.synchronizedMap(new HashMap<File, Long>());  
18.     public LimitedDiscCache(File cacheDir, int sizeLimit) {  
19.         this(cacheDir, DefaultConfigurationFactory.createFileNameGenerator(), sizeLimit);  
20.     }  
21.     public LimitedDiscCache(File cacheDir, FileNameGenerator fileNameGenerator, int sizeLimit) {  
22.         super(cacheDir, fileNameGenerator);  
23.         this.sizeLimit = sizeLimit;  
24.         cacheSize = new AtomicInteger();  
25.         calculateCacheSizeAndFillUsageMap();  
26.     }  
27.     private void calculateCacheSizeAndFillUsageMap() {  
28.         new Thread(new Runnable() {  
29.             @Override  
30.             public void run() {  
31.                 int size = 0;  
32.                 File[] cachedFiles = cacheDir.listFiles();  
33.                 if (cachedFiles != null) { // rarely but it can happen, don't know why  
34.                     for (File cachedFile : cachedFiles) {  
35.                         //getSize()是一個抽象方法，子類自行實作getSize()的邏輯  
36.                         size += getSize(cachedFile);  
37.                         //将檔案的最後修改時間加入到map中  
38.                         lastUsageDates.put(cachedFile, cachedFile.lastModified());  
39.                     }  
40.                     cacheSize.set(size);  
41.                 }  
42.             }  
43.         }).start();  
44.     }  
45.     @Override  
46.     public void put(String key, File file) {  
47.         //要加入檔案的大小  
48.         int valueSize = getSize(file);  
49.         //擷取目前緩存檔案大小總數  
50.         int curCacheSize = cacheSize.get();  
51.         //判斷是否超過設定的最大緩存值  
52.         while (curCacheSize + valueSize > sizeLimit) {  
53.             int freedSize = removeNext();  
54.             if (freedSize == INVALID_SIZE) break; // cache is empty (have nothing to delete)  
55.             curCacheSize = cacheSize.addAndGet(-freedSize);  
56.         }  
57.         cacheSize.addAndGet(valueSize);  
58.         Long currentTime = System.currentTimeMillis();  
59.         file.setLastModified(currentTime);  
60.         lastUsageDates.put(file, currentTime);  
61.     }  
62.     @Override  
63.     public File get(String key) {  
64.         File file = super.get(key);  
65.         Long currentTime = System.currentTimeMillis();  
66.         file.setLastModified(currentTime);  
67.         lastUsageDates.put(file, currentTime);  
68.         return file;  
69.     }  
70.     @Override  
71.     public void clear() {  
72.         lastUsageDates.clear();  
73.         cacheSize.set(0);  
74.         super.clear();  
75.     }  
76.     private int removeNext() {  
77.         if (lastUsageDates.isEmpty()) {  
78.             return INVALID_SIZE;  
79.         }  
80.         Long oldestUsage = null;  
81.         File mostLongUsedFile = null;  
82.         Set<Entry<File, Long>> entries = lastUsageDates.entrySet();  
83.         synchronized (lastUsageDates) {  
84.             for (Entry<File, Long> entry : entries) {  
85.                 if (mostLongUsedFile == null) {  
86.                     mostLongUsedFile = entry.getKey();  
87.                     oldestUsage = entry.getValue();  
88.                 } else {  
89.                     Long lastValueUsage = entry.getValue();  
90.                     if (lastValueUsage < oldestUsage) {  
91.                         oldestUsage = lastValueUsage;  
92.                         mostLongUsedFile = entry.getKey();  
93.                     }  
94.                 }  
95.             }  
96.         }  
97.         int fileSize = 0;  
98.         if (mostLongUsedFile != null) {  
99.             if (mostLongUsedFile.exists()) {  
100.                 fileSize = getSize(mostLongUsedFile);  
101.                 if (mostLongUsedFile.delete()) {  
102.                     lastUsageDates.remove(mostLongUsedFile);  
103.                 }  
104.             } else {  
105.                 lastUsageDates.remove(mostLongUsedFile);  
106.             }  
107.         }  
108.         return fileSize;  
109.     }  
110.     protected abstract int getSize(File file);  
111. }  

在構造方法中，第69行有一個方法calculateCacheSizeAndFillUsageMap(),該方法是計算cacheDir的檔案大小，并将檔案和檔案的最後修改時間加入到Map中

然後是将檔案加入硬碟緩存的方法put()，在106行判斷目前檔案的緩存總數加上即将要加入緩存的檔案大小是否超過緩存設定值，如果超過了執行removeNext()方法，接下來就來看看這個方法的具體實作，150-167中找出最先加入硬碟的檔案，169-180中将其從檔案硬碟中删除，并傳回該檔案的大小，删除成功之後成員變量cacheSize需要減掉改檔案大小。

FileCountLimitedDiscCache這個類實作邏輯跟TotalSizeLimitedDiscCache是一樣的，差別在于getSize()方法，前者傳回1，表示為檔案數是1，後者傳回檔案的大小。

等我寫完了這篇文章，我才發現FileCountLimitedDiscCache和TotalSizeLimitedDiscCache在最新的源碼中已經删除了，加入了LruDiscCache，由于我的是之前的源碼，是以我也不改了，大家如果想要了解LruDiscCache可以去看最新的源碼，我這裡就不介紹了，還好記憶體緩存的沒變化，下面分析的是最新的源碼中的部分，我們在使用中可以不自行配置硬碟緩存政策，直接用DefaultConfigurationFactory中的就行了

我們看DefaultConfigurationFactory這個類的createDiskCache()方法

[java]  view plain copy

1. public static DiskCache createDiskCache(Context context, FileNameGenerator diskCacheFileNameGenerator,  
2.         long diskCacheSize, int diskCacheFileCount) {  
3.     File reserveCacheDir = createReserveDiskCacheDir(context);  
4.     if (diskCacheSize > 0 || diskCacheFileCount > 0) {  
5.         File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);  
6.         LruDiscCache diskCache = new LruDiscCache(individualCacheDir, diskCacheFileNameGenerator, diskCacheSize,  
7.                 diskCacheFileCount);  
8.         diskCache.setReserveCacheDir(reserveCacheDir);  
9.         return diskCache;  
10.     } else {  
11.         File cacheDir = StorageUtils.getCacheDirectory(context);  
12.         return new UnlimitedDiscCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator);  
13.     }  
14. }  

如果我們在ImageLoaderConfiguration中配置了diskCacheSize和diskCacheFileCount，他就使用的是LruDiscCache，否則使用的是UnlimitedDiscCache，在最新的源碼中還有一個硬碟緩存類可以配置，那就是LimitedAgeDiscCache，可以在ImageLoaderConfiguration.diskCache(...)配置

//-----------------------------------------------------------------

本篇文章主要是帶大家從源碼的角度上面去解讀這個強大的圖檔加載架構，自己很久沒有寫文章了，感覺生疏了許多，距離上一篇文章三個月多了，确實是自己平常忙，換了工作很多東西都要去看去了解，然後加上自己也懶了，沒有以前那麼有激情了，我感覺這節奏不對，我要繼續保持以前的激情，正所謂好記性不如爛筆頭，有時候自己也會去翻看下之前寫的東西，我覺得知識寫下來比在腦海中留存的更久，今天就給大家來讀一讀這個架構的源碼，我感覺這個圖檔加載架構确實寫的很不錯，讀完代碼自己也學到了很多。我希望大家可以先去看下Android 開源架構Universal-Image-Loader完全解析（一）--- 基本介紹及使用， Android 開源架構Universal-Image-Loader完全解析（二）--- 圖檔緩存政策詳解 ，我希望大家可以堅持看完，看完了對你絕對是有收獲的。

[java]  view plain copy

1. ImageView mImageView = (ImageView) findViewById(R.id.image);    
2.         String imageUrl = "https://lh6.googleusercontent.com/-55osAWw3x0Q/URquUtcFr5I/AAAAAAAAAbs/rWlj1RUKrYI/s1024/A%252520Photographer.jpg";    
3.         //顯示圖檔的配置    
4.         DisplayImageOptions options = new DisplayImageOptions.Builder()    
5.                 .showImageOnLoading(R.drawable.ic_stub)    
6.                 .showImageOnFail(R.drawable.ic_error)    
7.                 .cacheInMemory(true)    
8.                 .cacheOnDisk(true)    
9.                 .bitmapConfig(Bitmap.Config.RGB_565)    
10.                 .build();    
11.         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.     }  

從上面的代碼中，我們可以看出，它會将ImageView轉換成ImageViewAware， ImageViewAware主要是做什麼的呢？該類主要是将ImageView進行一個包裝，将ImageView的強引用變成弱引用，當記憶體不足的時候，可以更好的回收ImageView對象，還有就是擷取ImageView的寬度和高度。這使得我們可以根據ImageView的寬高去對圖檔進行一個裁剪，減少記憶體的使用。

接下來看具體的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.         if (TextUtils.isEmpty(uri)) {  
12.             engine.cancelDisplayTaskFor(imageAware);  
13.             listener.onLoadingStarted(uri, imageAware.getWrappedView());  
14.             if (options.shouldShowImageForEmptyUri()) {  
15.                 imageAware.setImageDrawable(options.getImageForEmptyUri(configuration.resources));  
16.             } else {  
17.                 imageAware.setImageDrawable(null);  
18.             }  
19.             listener.onLoadingComplete(uri, imageAware.getWrappedView(), null);  
20.             return;  
21.         }  

第1行代碼是檢查ImageLoaderConfiguration是否初始化，這個初始化是在Application中進行的

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.     listener.onLoadingStarted(uri, imageAware.getWrappedView());  
5.     Bitmap bmp = configuration.memoryCache.get(memoryCacheKey);  
6.     if (bmp != null && !bmp.isRecycled()) {  
7.         L.d(LOG_LOAD_IMAGE_FROM_MEMORY_CACHE, memoryCacheKey);  
8.         if (options.shouldPostProcess()) {  
9.             ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,  
10.                     options, listener, progressListener, engine.getLockForUri(uri));  
11.             ProcessAndDisplayImageTask displayTask = new ProcessAndDisplayImageTask(engine, bmp, imageLoadingInfo,  
12.                     defineHandler(options));  
13.             if (options.isSyncLoading()) {  
14.                 displayTask.run();  
15.             } else {  
16.                 engine.submit(displayTask);  
17.             }  
18.         } else {  
19.             options.getDisplayer().display(bmp, imageAware, LoadedFrom.MEMORY_CACHE);  
20.             listener.onLoadingComplete(uri, imageAware.getWrappedView(), bmp);  
21.         }  
22.     }  

第1行主要是将ImageView的寬高封裝成ImageSize對象，如果擷取ImageView的寬高為0，就會使用手機螢幕的寬高作為ImageView的寬高，我們在使用ListView，GridView去加載圖檔的時候，第一頁擷取寬度是0，是以第一頁使用的手機的螢幕寬高，後面的擷取的都是控件本身的大小了

第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.             ImageLoadingInfo imageLoadingInfo = new ImageLoadingInfo(uri, imageAware, targetSize, memoryCacheKey,  
7.                     options, listener, progressListener, engine.getLockForUri(uri));  
8.             LoadAndDisplayImageTask displayTask = new LoadAndDisplayImageTask(engine, imageLoadingInfo,  
9.                     defineHandler(options));  
10.             if (options.isSyncLoading()) {  
11.                 displayTask.run();  
12.             } else {  
13.                 engine.submit(displayTask);  
14.             }  

這段代碼主要是Bitmap不在記憶體緩存，從檔案中或者網絡裡面擷取bitmap對象，執行個體化一個LoadAndDisplayImageTask對象，LoadAndDisplayImageTask實作了Runnable,如果配置了isSyncLoading為true, 直接執行LoadAndDisplayImageTask的run方法，表示同步，預設是false,将LoadAndDisplayImageTask送出給線程池對象

接下來我們就看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.     }  

isViewCollected()是判斷我們ImageView是否被垃圾回收器回收了，如果回收了，LoadAndDisplayImageTask方法的run()就直接傳回了，isViewReused()判斷該ImageView是否被重用，被重用run()方法也直接傳回，為什麼要用isViewReused()方法呢？主要是ListView，GridView我們會複用item對象，假如我們先去加載ListView，GridView第一頁的圖檔的時候，第一頁圖檔還沒有全部加載完我們就快速的滾動，isViewReused()方法就會避免這些不可見的item去加載圖檔，而直接加載目前界面的圖檔 [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.         loadFromUriLock.lock();  
7.         Bitmap bmp;  
8.         try {  
9.             checkTaskNotActual();  
10.             bmp = configuration.memoryCache.get(memoryCacheKey);  
11.             if (bmp == null || bmp.isRecycled()) {  
12.                 bmp = tryLoadBitmap();  
13.                 if (bmp == null) return; // listener callback already was fired  
14.                 checkTaskNotActual();  
15.                 checkTaskInterrupted();  
16.                 if (options.shouldPreProcess()) {  
17.                     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);  
18.                     bmp = options.getPreProcessor().process(bmp);  
19.                     if (bmp == null) {  
20.                         L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);  
21.                     }  
22.                 }  
23.                 if (bmp != null && options.isCacheInMemory()) {  
24.                     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);  
25.                     configuration.memoryCache.put(memoryCacheKey, bmp);  
26.                 }  
27.             } else {  
28.                 loadedFrom = LoadedFrom.MEMORY_CACHE;  
29.                 L.d(LOG_GET_IMAGE_FROM_MEMORY_CACHE_AFTER_WAITING, memoryCacheKey);  
30.             }  
31.             if (bmp != null && options.shouldPostProcess()) {  
32.                 L.d(LOG_POSTPROCESS_IMAGE, memoryCacheKey);  
33.                 bmp = options.getPostProcessor().process(bmp);  
34.                 if (bmp == null) {  
35.                     L.e(ERROR_POST_PROCESSOR_NULL, memoryCacheKey);  
36.                 }  
37.             }  
38.             checkTaskNotActual();  
39.             checkTaskInterrupted();  
40.         } catch (TaskCancelledException e) {  
41.             fireCancelEvent();  
42.             return;  
43.         } finally {  
44.             loadFromUriLock.unlock();  
45.         }  

第1行代碼有一個loadFromUriLock，這個是一個鎖，擷取鎖的方法在ImageLoaderEngine類的getLockForUri()方法中 [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.     }  

從上面可以看出，這個鎖對象與圖檔的url是互相對應的，為什麼要這麼做？也行你還有點不了解，不知道大家有沒有考慮過一個場景，假如在一個ListView中，某個item正在擷取圖檔的過程中，而此時我們将這個item滾出界面之後又将其滾進來，滾進來之後如果沒有加鎖，該item又會去加載一次圖檔，假設在很短的時間内滾動很頻繁，那麼就會出現多次去網絡上面請求圖檔，是以這裡根據圖檔的Url去對應一個ReentrantLock對象，讓具有相同Url的請求就會在第7行等待，等到這次圖檔加載完成之後，ReentrantLock就被釋放，剛剛那些相同Url的請求就會繼續執行第7行下面的代碼

來到第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.                 checkTaskNotActual();  
6.                 bitmap = decodeImage(Scheme.FILE.wrap(imageFile.getAbsolutePath()));  
7.             }  

先判斷檔案緩存中有沒有該檔案，如果有的話，直接去調用decodeImage（）方法去解碼圖檔，該方法裡面調用BaseImageDecoder類的decode()方法，根據ImageView的寬高，ScaleType去裁剪圖檔，具體的代碼我就不介紹了，大家自己去看看，我們接下往下看tryLoadBitmap()方法

[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.             String imageUriForDecoding = uri;  
5.             if (options.isCacheOnDisk() && tryCacheImageOnDisk()) {  
6.                 imageFile = configuration.diskCache.get(uri);  
7.                 if (imageFile != null) {  
8.                     imageUriForDecoding = Scheme.FILE.wrap(imageFile.getAbsolutePath());  
9.                 }  
10.             }  
11.             checkTaskNotActual();  
12.             bitmap = decodeImage(imageUriForDecoding);  
13.             if (bitmap == null || bitmap.getWidth() <= 0 || bitmap.getHeight() <= 0) {  
14.                 fireFailEvent(FailType.DECODING_ERROR, null);  
15.             }  
16.         }  

第1行表示從檔案緩存中擷取的Bitmap為null，或者寬高為0,就去網絡上面擷取Bitmap，來到第6行代碼是否配置了DisplayImageOptions的isCacheOnDisk，表示是否需要将Bitmap對象儲存在檔案系統中，一般我們需要配置為true, 預設是false這個要注意下，然後就是執行tryCacheImageOnDisk()方法，去伺服器上面拉取圖檔并儲存在本地檔案中

[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. private boolean tryCacheImageOnDisk() throws TaskCancelledException {  
8.     L.d(LOG_CACHE_IMAGE_ON_DISK, memoryCacheKey);  
9.     boolean loaded;  
10.     try {  
11.         loaded = downloadImage();  
12.         if (loaded) {  
13.             int width = configuration.maxImageWidthForDiskCache;  
14.             int height = configuration.maxImageHeightForDiskCache;  
15.             if (width > 0 || height > 0) {  
16.                 L.d(LOG_RESIZE_CACHED_IMAGE_FILE, memoryCacheKey);  
17.                 resizeAndSaveImage(width, height); // TODO : process boolean result  
18.             }  
19.         }  
20.     } catch (IOException e) {  
21.         L.e(e);  
22.         loaded = false;  
23.     }  
24.     return loaded;  
25. }  
26. private boolean downloadImage() throws IOException {  
27.     InputStream is = getDownloader().getStream(uri, options.getExtraForDownloader());  
28.     return configuration.diskCache.save(uri, is, this);  
29. }  

第6行的downloadImage()方法是負責下載下傳圖檔，并将其保持到檔案緩存中，将下載下傳儲存Bitmap的進度回調到IoUtils.CopyListener接口的onBytesCopied(int current, int total)方法中，是以我們可以設定ImageLoadingProgressListener接口來擷取圖檔下載下傳儲存的進度，這裡儲存在檔案系統中的圖檔是原圖

第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.                 checkTaskNotActual();  
3.                 checkTaskInterrupted();  
4.                 if (options.shouldPreProcess()) {  
5.                     L.d(LOG_PREPROCESS_IMAGE, memoryCacheKey);  
6.                     bmp = options.getPreProcessor().process(bmp);  
7.                     if (bmp == null) {  
8.                         L.e(ERROR_PRE_PROCESSOR_NULL, memoryCacheKey);  
9.                     }  
10.                 }  
11.                 if (bmp != null && options.isCacheInMemory()) {  
12.                     L.d(LOG_CACHE_IMAGE_IN_MEMORY, memoryCacheKey);  
13.                     configuration.memoryCache.put(memoryCacheKey, bmp);  
14.                 }  

接下來這裡就簡單了，6-12行是否要對Bitmap進行處理，這個需要自行實作，14-17就是将圖檔儲存到記憶體緩存中去

[java]  view plain copy

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

最後這兩行代碼就是一個顯示任務，直接看DisplayBitmapTask類的run（）方法

[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

文章寫到這裡就已經寫完了，不知道大家對這個開源架構有沒有進一步的了解，這個開源架構設計也很靈活，用了很多的設計模式，比如建造者模式，裝飾模式，代理模式，政策模式等等，這樣友善我們去擴充，實作我們想要的功能