码迷,mamicode.com
首页 > 移动开发 > 详细

教你写Android ImageLoader框架之初始配置与请求调度

时间:2015-02-01 12:06:57      阅读:216      评论:0      收藏:0      [点我收藏+]

标签:android   框架   图片加载   imageloader   


## 前言

   在教你写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, threadCount);
        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跳动而热血沸腾起来了!

Github仓库链接 

SimpleImageLoader仓库地址    


如果你觉得我写得还行,那就帮我顶个帖吧!Thanks~


教你写Android ImageLoader框架之初始配置与请求调度

标签:android   框架   图片加载   imageloader   

原文地址:http://blog.csdn.net/bboyfeiyu/article/details/43195705

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!