本文转自Mr.Simple的博客,如侵删
前言
在教你写Android ImageLoader框架之基本架构中我们对SimpleImageLoader框架进行了基本的介绍，今天我们就从源码的角度来剖析ImageLoader的设计与实现。 在我们使用ImageLoader前都会通过一个配置类来设置一些基本的东西，比如加载中的图片、加载失败的图片、缓存策略等等，SimpleImageLoader的设计也是如此。配置类这个比较简单，我们直接看源码吧。
ImageLoaderConfig配置
/**
* ImageLoader配置类,
*
* @author mrsimple
*/
public class ImageLoaderConfig {
/**
* 图片缓存配置对象
*/
public BitmapCache bitmapCache = new MemoryCache();
/**
* 加载图片时的loading和加载失败的图片配置对象
*/
public DisplayConfig displayConfig = new DisplayConfig();
/**
* 加载策略
*/
public LoadPolicy loadPolicy = new SerialPolicy();
/**
*
*/
public int threadCount = Runtime.getRuntime().availableProcessors() + 1;
/**
* @param count
* @return
*/
public ImageLoaderConfig setThreadCount(int count) {
threadCount = Math.max(1, count);
return this;
}
public ImageLoaderConfig setCache(BitmapCache cache) {
bitmapCache = cache;
return this;
}
public ImageLoaderConfig setLoadingPlaceholder(int resId) {
displayConfig.loadingResId = resId;
return this;
}
public ImageLoaderConfig setNotFoundPlaceholder(int resId) {
displayConfig.failedResId = resId;
return this;
}
public ImageLoaderConfig setLoadPolicy(LoadPolicy policy) {
if (policy != null) {
loadPolicy = policy;
}
return this;
}
}
都是很简单的setter函数，但是不太一样的是这些setter都是返回一个ImageLoaderConfig对象的，在这里也就是返回了自身。这个设计是类似Builder模式的，便于用户的链式调用，例如:
private void initImageLoader() {
ImageLoaderConfig config = new ImageLoaderConfig()
.setLoadingPlaceholder(R.drawable.loading)
.setNotFoundPlaceholder(R.drawable.not_found)
.setCache(new DoubleCache(this))
.setThreadCount(4)
.setLoadPolicy(new ReversePolicy());
// 初始化
SimpleImageLoader.getInstance().init(config);
}
对于Builder模式不太了解的同学可以参考 Android源码分析之Builder模式。构建好配置对象之后我们就可以通过这个配置对象来初始化SimpleImageLoader了。SimpleImageLoader会根据配置对象来初始化一些内部策略，例如缓存策略、线程数量等。调用init方法后整个ImageLoader就正式启动了。
SimpleImageLoader的实现
SimpleImageLoader这个类的职责只是作为用户入口，它的工作其实并没有那么多，只是一个门童罢了。我们看看它的源码吧。
/**
* 图片加载类,支持url和本地图片的uri形式加载.根据图片路径格式来判断是网络图片还是本地图片,如果是网络图片则交给SimpleNet框架来加载，
* 如果是本地图片那么则交给mExecutorService从sd卡中加载
* .加载之后直接更新UI，无需用户干预.如果用户设置了缓存策略,那么会将加载到的图片缓存起来.用户也可以设置加载策略，例如顺序加载{@see
* SerialPolicy}和逆向加载{@see ReversePolicy}.
*
* @author mrsimple
*/
public final class SimpleImageLoader {
/** SimpleImageLoader实例 */
private static SimpleImageLoader sInstance;
/** 网络请求队列 */
private RequestQueue mImageQueue;
/** 缓存 */
private volatile BitmapCache mCache = new MemoryCache();
/** 图片加载配置对象 */
private ImageLoaderConfig mConfig;
private SimpleImageLoader() {
}
/**
* 获取ImageLoader单例
*
* @return
*/
public static SimpleImageLoader getInstance() {
if (sInstance == null) {
synchronized (SimpleImageLoader.class) {
if (sInstance == null) {
sInstance = new SimpleImageLoader();
}
}
}
return sInstance;
}
/**
* 初始化ImageLoader，启动请求队列
* @param config 配置对象
*/
public void init(ImageLoaderConfig config) {
mConfig = config;
mCache = mConfig.bitmapCache;
checkConfig();
mImageQueue = new RequestQueue(mConfig.threadCount);
mImageQueue.start();
}
private void checkConfig() {
if (mConfig == null) {
throw new RuntimeException(
"The config of SimpleImageLoader is Null, please call the init(ImageLoaderConfig config) method to initialize");
}
if (mConfig.loadPolicy == null) {
mConfig.loadPolicy = new SerialPolicy();
}
if (mCache == null) {
mCache = new NoCache();
}
}
public void displayImage(ImageView imageView, String uri) {
displayImage(imageView, uri, null, null);
}
public void displayImage(final ImageView imageView, final String uri,
final DisplayConfig config, final ImageListener listener) {
BitmapRequest request = new BitmapRequest(imageView, uri, config, listener);
// 加载的配置对象,如果没有设置则使用ImageLoader的配置
request.displayConfig = request.displayConfig != null ? request.displayConfig
: mConfig.displayConfig;
// 添加对队列中
mImageQueue.addRequest(request);
}
// 代码省略...
/**
* 图片加载Listener
*
* @author mrsimple
*/
public static interface ImageListener {
public void onComplete(ImageView imageView, Bitmap bitmap, String uri);
}
}
从上述代码中我们可以看到SimpleImageLoader的工作比较少，也比较简单。它就是根据用户传递进来的配置来初始化ImageLoader,并且作为图片加载入口，用户调用displayImage之后它会将这个调用封装成一个BitmapRequest请求,然后将该请求添加到请求队列中。
BitmapRequest图片加载请求
BitmapRequest只是一个存储了ImageView、图片uri、DisplayConfig以及ImageListener的一个对象，封装这个对象的目的在加载图片时减少参数的个数，在BitmapRequest的构造函数中我们会将图片uri设置为ImageView的tag，这样做的目的是防止图片错位显示。BitmapRequest类实现了Compare接口，请求队列会根据它的序列号进行排序，排序策略用户也可以通过配置类来设置，具体细节在加载策略的章节我们再聊吧。
public BitmapRequest(ImageView imageView, String uri, DisplayConfig config,
ImageListener listener) {
mImageViewRef = new WeakReference<ImageView>(imageView);
displayConfig = config;
imageListener = listener;
imageUri = uri;
// 设置ImageView的tag为图片的uri
imageView.setTag(uri);
imageUriMd5 = Md5Helper.toMD5(imageUri);
}
RequestQueue图片请求队列
请求队列我们采用了SImpleNet中一样的模式，通过封装一个优先级队列来维持图片加载队列，mSerialNumGenerator会给每一个请求分配一个序列号，PriorityBlockingQueue会根据BitmapRequest的compare策略来决定BitmapRequest的顺序。RequestQueue内部会启动用户指定数量的线程来从请求队列中读取请求，分发线程不断地从队列中读取请求，然后进行图片加载处理，这样ImageLoader就happy起来了。
/**
* 请求队列, 使用优先队列,使得请求可以按照优先级进行处理. [ Thread Safe ]
*
* @author mrsimple
*/
public final class RequestQueue {
/**
* 请求队列 [ Thread-safe ]
*/
private BlockingQueue<BitmapRequest> mRequestQueue = new PriorityBlockingQueue<BitmapRequest>();
/**
* 请求的序列化生成器
*/
private AtomicInteger mSerialNumGenerator = new AtomicInteger(0);
/**
* 默认的核心数
*/
public static int DEFAULT_CORE_NUMS = Runtime.getRuntime().availableProcessors() + 1;
/**
* CPU核心数 + 1个分发线程数
*/
private int mDispatcherNums = DEFAULT_CORE_NUMS;
/**
* NetworkExecutor,执行网络请求的线程
*/
private RequestDispatcher[] mDispatchers = null;
/**
*
*/
protected RequestQueue() {
this(DEFAULT_CORE_NUMS);
}
/**
* @param coreNums 线程核心数
* @param httpStack http执行器
*/
protected RequestQueue(int coreNums) {
mDispatcherNums = coreNums;
}
/**
* 启动RequestDispatcher
*/
private final void startDispatchers() {
mDispatchers = new RequestDispatcher[mDispatcherNums];
for (int i = 0; i < mDispatcherNums; i++) {
mDispatchers[i] = new RequestDispatcher(mRequestQueue);
mDispatchers[i].start();
}
}
public void start() {
stop();
startDispatchers();
}
/**
* 停止RequestDispatcher
*/
public void stop() {
if (mDispatchers != null && mDispatchers.length > 0) {
for (int i = 0; i < mDispatchers.length; i++) {
mDispatchers[i].interrupt();
}
}
}
/**
* 不能重复添加请求
* @param request
*/
public void addRequest(BitmapRequest request) {
if (!mRequestQueue.contains(request)) {
request.serialNum = this.generateSerialNumber();
mRequestQueue.add(request);
} else {
Log.d("", "### 请求队列中已经含有");
}
}
private int generateSerialNumber() {
return mSerialNumGenerator.incrementAndGet();
}
}
RequestDispatcher请求分发
请求Dispatcher,继承自Thread,从网络请求队列中循环读取请求并且执行，也比较简单，直接上源码吧。
final class RequestDispatcher extends Thread {
/**
* 网络请求队列
*/
private BlockingQueue<BitmapRequest> mRequestQueue;
/**
* @param queue 图片加载请求队列
*/
public RequestDispatcher(BlockingQueue<BitmapRequest> queue) {
mRequestQueue = queue;
}
@Override
public void run() {
try {
while (!this.isInterrupted()) {
final BitmapRequest request = mRequestQueue.take();
if (request.isCancel) {
continue;
}
// 解析图片schema
final String schema = parseSchema(request.imageUri);
// 根据schema获取对应的Loader
Loader imageLoader = LoaderManager.getInstance().getLoader(schema);
// 加载图片
imageLoader.loadImage(request);
}
} catch (InterruptedException e) {
Log.i("", "### 请求分发器退出");
}
}
/**
* 这里是解析图片uri的格式,uri格式为: schema:// + 图片路径。
*/
private String parseSchema(String uri) {
if (uri.contains("://")) {
return uri.split("://")[0];
} else {
Log.e(getName(), "### wrong scheme, image uri is : " + uri);
}
return "";
}
}
第一个重点就是run函数了，不断地从队列中获取请求，然后解析到图片uri的schema，从schema的格式就可以知道它是存储在哪里的图片。例如网络图片对象的schema是http或者https，sd卡存储的图片对应的schema为file。根据schema我们从LoaderManager中获取对应的Loader来加载图片，这个设计保证了SimpleImageLoader可加载图片类型的可扩展性，这就是为什么会增加loader这个包的原因。用户只需要根据uri的格式来构造图片uri，并且实现自己的Loader类，然后将Loader对象注入到LoaderManager即可，后续我们会再详细说明。
这里的另一个重点是parseSchema函数，它的职责是解析图片uri的格式,uri格式为: schema:// + 图片路径,例如网络图片的格式为 http://xxx.image.jpg, 而本地图片的uri为file:///sdcard/xxx/image.jpg。如果你要实现自己的Loader来加载特定的格式，那么它的uri格式必须以schema://开头，否则解析会错误，例如可以为drawable://image,然后你注册一个schema为"drawable"的Loader到LoaderManager中，SimpleImageLoader在加载图片时就会使用你注册的Loader来加载图片，这样就可以应对用户的多种多样的需求。如果不能拥抱变化那就不能称之为框架了，应该叫功能模块。
本章总结
最后我们来整理一下这个过程吧，SimpleImageLoader根据用户的配置来配置、启动请求队列，请求队列又会根据用户配置的线程数量来启动几个分发线程。这几个线程不断地从请求队列（线程安全）中读取图片加载请求，并且执行图片加载请求。这些请求是用户通过调用SimpleImageLoader的displayImage函数而产生的，内部会把这个调用封装成一个BitmapRequest对象，并且将该对象添加到请求队列中。这样就有了生产者（用户）和消费者（分发线程），整个SimpleImageLoader就随着CPU跳动而热血沸腾起来了！
