Universal-Image-Loader从使用到源码分析

为什么我要写一个已经过时框架的解析框架呢？

那在我自己的项目里面其实也不用这个框架了，一般用的是Glide框架，那为什么我要写这篇文章呢，是因为由于我目前水平有限，对于Glide的源码难以参透，那与其在一个高大上的框架上钻牛角尖，不如把已有的框架进行一个全面的解析，因为图片解析框架无非就是如何高效的加载图片，若参透了之前的框架，那么对新的框架新的技术，也就可以了解其本质，从而更游刃有余的去学习新的技术。

UIL的简单使用

首先导入jar包，在Application的onCreate方法中对UIL进行一些参数配置，如果不想配置，也可以直接使用默认的参数配置。
那么最常用的加载图片方法：

private void showImage() {        ImageLoader loader = ImageLoader.getInstance();        //最常用的方法//        loader.displayImage(url,iv);        //同样我们配置些参数        DisplayImageOptions options = new DisplayImageOptions.Builder()                //缓存到内存中                .cacheInMemory(true)                //缓存到磁盘中                .cacheOnDisk(true)                .build();        loader.displayImage(url,iv,options);    }

那么以上就是UIL的基本使用了。

内存缓存

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

那么首先来分析一下LruCache干了些什么事

package com.nostra13.universalimageloader.cache.memory.impl;import android.graphics.Bitmap;import com.nostra13.universalimageloader.cache.memory.MemoryCacheAware;import java.util.Collection;import java.util.HashSet;import java.util.LinkedHashMap;import java.util.Map;/** * A cache that holds strong references to a limited number of Bitmaps. Each time a Bitmap is accessed, it is moved to * 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 * become eligible for garbage collection.<br /> * <br /> * <b>NOTE:</b> This cache uses only strong references for stored Bitmaps. * * @author Sergey Tarasevich (nostra13[at]gmail[dot]com) * @since 1.8.1 */public class LruMemoryCache implements MemoryCacheAware<String, Bitmap> {    private final LinkedHashMap<String, Bitmap> map;    private final int maxSize;    /** Size of this cache in bytes */    private int size;    /** @param maxSize Maximum sum of the sizes of the Bitmaps in this cache */    public LruMemoryCache(int maxSize) {        if (maxSize <= 0) {            throw new IllegalArgumentException("maxSize <= 0");        }        this.maxSize = maxSize;        this.map = new LinkedHashMap<String, Bitmap>(0, 0.75f, true);    }    /**     * Returns the Bitmap for {@code key} if it exists in the cache. If a Bitmap was returned, it is moved to the head     * of the queue. This returns null if a Bitmap is not cached.     */    @Override    public final Bitmap get(String key) {        if (key == null) {            throw new NullPointerException("key == null");        }        synchronized (this) {            return map.get(key);        }    }    /** Caches {@code Bitmap} for {@code key}. The Bitmap is moved to the head of the queue. */    @Override    public final boolean put(String key, Bitmap value) {        if (key == null || value == null) {            throw new NullPointerException("key == null || value == null");        }        synchronized (this) {            size += sizeOf(key, value);            Bitmap previous = map.put(key, value);            if (previous != null) {                size -= sizeOf(key, previous);            }        }        trimToSize(maxSize);        return true;    }    /**     * Remove the eldest entries until the total of remaining entries is at or below the requested size.     *     * @param maxSize the maximum size of the cache before returning. May be -1 to evict even 0-sized elements.     */    private void trimToSize(int maxSize) {        while (true) {            String key;            Bitmap value;            synchronized (this) {                if (size < 0 || (map.isEmpty() && size != 0)) {                    throw new IllegalStateException(getClass().getName() + ".sizeOf() is reporting inconsistent results!");                }                if (size <= maxSize || map.isEmpty()) {                    break;                }                Map.Entry<String, Bitmap> toEvict = map.entrySet().iterator().next();                if (toEvict == null) {                    break;                }                key = toEvict.getKey();                value = toEvict.getValue();                map.remove(key);                size -= sizeOf(key, value);            }        }    }    /** Removes the entry for {@code key} if it exists. */    @Override    public final void remove(String key) {        if (key == null) {            throw new NullPointerException("key == null");        }        synchronized (this) {            Bitmap previous = map.remove(key);            if (previous != null) {                size -= sizeOf(key, previous);            }        }    }    @Override    public Collection<String> keys() {        synchronized (this) {            return new HashSet<String>(map.keySet());        }    }    @Override    public void clear() {        trimToSize(-1); // -1 will evict 0-sized elements    }    /**     * Returns the size {@code Bitmap} in bytes.     * <p/>     * An entry's size must not change while it is in the cache.     */    private int sizeOf(String key, Bitmap value) {        return value.getRowBytes() * value.getHeight();    }    @Override    public synchronized final String toString() {        return String.format("LruCache[maxSize=%d]", maxSize);    }}

我们可以看到在LruMemoryCache的初始化方法中初始化了一个LinkedHashMap和一个MaxSize，LinkedHashMap传入了true，是访问优先的模式，MaxSize代表了我们想要在内存中缓存所有图片的最大比特。还定义了一个size表示当前的所有图片大小。那么在put方法中，首先调用了一个sizeof（）方法，sizeof（）方法是用来计算put进去的图片大小，那么size会加上这个sizeof（）的值，并且将bitmap放入map中，如果map已经缓存过了，就要减去之前计算得出的size。之后就会调用一个trimtosize（maxsize）方法，这个方法是用来调整map中图片的个数，如果size<=maxsize，那么什么都不做，如果反之，就删除map中的第一个元素，并循环这个过程，直到size<=maxsize。这就是整个LruMemoryCache的原理，并不复杂。
那么我们可以看到最为核心的类是LinkedHashMap，那LinkedHashMap是如何实现Lru算法的呢？

LinkedHashMap解析
LinkedHashMap是HashMap的一个子类，它保留插入的顺序，如果需要输出的顺序和输入时的相同，那么就选用LinkedHashMap。
LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。
LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。
注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。
根据链表中元素的顺序可以分为：按插入顺序的链表，和按访问顺序(调用get方法)的链表。
默认是按插入顺序排序，如果指定按访问顺序排序，那么调用get方法后，会将这次访问的元素移至链表尾部，不断访问可以形成按访问顺序排序的链表。可以重写removeEldestEntry方法返回true值指定插入元素时移除最老的元素。 让我们来看一下源码

/**  * 双向链表的表头元素。  */  private transient Entry<K,V> header;  /**  * LinkedHashMap的Entry元素。  * 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。  */  private static class Entry<K,V> extends HashMap.Entry<K,V> {      Entry<K,V> before, after;      ……  }  // 通过源代码可以看出，在LinkedHashMap的构造方法中，实际调用了父类HashMap的相关构造方法来构造一个底层存放的table数组，并默认是插入顺序public LinkedHashMap(int initialCapacity, float loadFactor) {      super(initialCapacity, loadFactor);      accessOrder = false;  }  //LinkedHashMap重写了init()方法，来完成对header的初始化void init() {      header = new Entry<K,V>(-1, null, null, null);      header.before = header.after = header;  }  /* LinkedHashMap并未重写父类HashMap的put方法，而是重写了父类HashMap的put方法调用的子方法void recordAccess(HashMap m)   ，void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的双向链接列表的实现。*/public V put(K key, V value) {          if (key == null)              return putForNullKey(value);          int hash = hash(key.hashCode());          int i = indexFor(hash, table.length);          for (Entry<K,V> e = table[i]; e != null; e = e.next) {              Object k;              if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {                  V oldValue = e.value;                  e.value = value;                  e.recordAccess(this);                  return oldValue;              }          }          modCount++;          addEntry(hash, key, value, i);          return null;  }//如果为访问优先，那么删除当前节点，添加到链表尾部void recordAccess(HashMap<K,V> m) {              LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;              if (lm.accessOrder) {                  lm.modCount++;                  remove();                  addBefore(lm.header);              }          }  void addEntry(int hash, K key, V value, int bucketIndex) {      // 调用create方法，将新元素以双向链表的的形式加入到映射中。      createEntry(hash, key, value, bucketIndex);      // 删除最近最少使用元素的策略定义      Entry<K,V> eldest = header.after;      //如果需要删除节点，那么就删除，如果不需要，则判断一下是否要扩容    if (removeEldestEntry(eldest)) {          removeEntryForKey(eldest.key);      } else {          if (size >= threshold)              resize(2 * table.length);      }  }  void createEntry(int hash, K key, V value, int bucketIndex) {      HashMap.Entry<K,V> old = table[bucketIndex];      Entry<K,V> e = new Entry<K,V>(hash, key, value, old);      table[bucketIndex] = e;      // 调用元素的addBrefore方法，将元素加入到哈希、双向链接列表。      e.addBefore(header);      size++;  }  private void addBefore(Entry<K,V> existingEntry) {      after  = existingEntry;      before = existingEntry.before;      before.after = this;      after.before = this;  }  

那么总结一下put方法，如果map中已经有元素存在，并且是访问优先，就删除当前链表上的节点，并将当前节点添加到链表的尾部。
如果不存在，就直接添加到链表的尾部，并判断是否要移除最老的元素，如果需要移除，那么就直接移除，如果不需要移除也判断是否需要扩容。
LinkedHashMap重写了父类HashMap的get方法，实际在调用父类getEntry()方法取得查找的元素后，再判断当排序模式accessOrder为true时，记录访问顺序，将最新访问的元素添加到双向链表的表头，并从原来的位置删除。由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。
OK，对LinkedHashMap是如何实现LruCache算法也有些了解。
那么现在了解了些基本原理，我们来梳理一下UIL的工作流程。

• UI：请求数据，使用唯一的Key值索引Memory Cache中的Bitmap。
• 内存缓存：缓存搜索，如果能找到Key值对应的Bitmap，则返回数据。否则执行第三步
• 硬盘存储：使用唯一Key值对应的文件名，检索SDCard上的文件
• 如果有对应文件，使用BitmapFactory.decode*方法，解码Bitmap并返回数据，同时将数据写入缓存。如果没有对应文件，执行第五步
• 下载图片：启动异步线程，从数据源下载数据(Web)
• 若下载成功，将数据同时写入硬盘和缓存，并将Bitmap显示在UI中