讲到图片请求，主要涉及到网络请求，内存缓存，硬盘缓存等原理和4大引用的问题，概括起来主要有以下几个内容：

原理示意图

    主体有三个，分别是UI，缓存模块和数据源（网络）。它们之间的关系如下：

① UI：请求数据，使用唯一的Key值索引Memory Cache中的Bitmap。

② 内存缓存：缓存搜索，如果能找到Key值对应的Bitmap，则返回数据。否则执行第三步。

③ 硬盘存储：使用唯一Key值对应的文件名，检索SDCard上的文件。

④ 如果有对应文件，使用BitmapFactory.decode*方法，解码Bitmap并返回数据，同时将数据写入缓存。如果没有对应文件，执行第五步。

⑤ 下载图片：启动异步线程，从数据源下载数据(Web)。

⑥ 若下载成功，将数据同时写入硬盘和缓存，并将Bitmap显示在UI中。

UIL中的内存缓存策略

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

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

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

 UsingFreqLimitedMemoryCache（如果缓存的图片总量超过限定值，先删除使用频率最小的bitmap）

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

 3.只使用弱引用缓存

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

我们直接选择UIL中的默认配置缓存策略进行分析。

ImageLoaderConfiguration.createDefault(…)这个方法最后是调用Builder.build()方法创建默认的配置参数的。默认的内存缓存实现是LruMemoryCache，磁盘缓存是UnlimitedDiscCache。

所以android在以后的版本中建议使用LruMemoryCache进行管理。

LruMemoryCache：一种使用强引用来保存有数量限制的Bitmap的cache（在空间有限的情况，保留最近使用过的Bitmap）。每次Bitmap被访问时，它就被移动到一个队列的头部。当Bitmap被添加到一个空间已满的cache时，在队列末尾的Bitmap会被挤出去并变成适合被GC回收的状态。
注意：这个cache只使用强引用来保存Bitmap。

LruMemoryCache实现MemoryCache，而MemoryCache继承自MemoryCacheAware。

下面给出继承关系图

通过跟踪
LruMemoryCache.get()的代码我们发现，LruMemoryCache声称保留在空间有限的情况下保留最近使用过的Bitmap，这是一个LinkedHashMap<String, Bitmap>，Icache的源码缓存的代码如下：

@Override
    public ICache<String, Bitmap> getBitmapCache() {
        if (bitmapCache == null) {
            bitmapCache = new ICache<String, Bitmap>() {
                @Override
                public void remove(String key) {
                    ImageLoader.getInstance().getMemoryCache().remove(key);
                }
                @Override
                public boolean put(String key, Bitmap value) {
                    if (key == null || value == null) return false;
                    return ImageLoader.getInstance().getMemoryCache().put(key, value);
                }
                @Override
                public Collection<String> keys() {
                    return null;
                }
                @Override
                public Bitmap get(String key) {
                    return ImageLoader.getInstance().getMemoryCache().get(key);
                }
                @Override
                public void clear() {
                    ImageLoader.getInstance().getMemoryCache().clear();
                }
            };
        }
        return bitmapCache;
    }

看到这里我们就清楚LruMemoryCache使用LinkedHashMap来缓存数据，在LinkedHashMap.get()方法执行后，LinkedHashMap中entry的顺序会得到调整。那么我们怎么保证最近使用的项不会被剔除呢？接下去，让我们看看LruMemoryCache.put(…)。

public final boolean put(String key, Bitmap value) { 
    if(key != null && value != null) { 
        synchronized(this) { 
            this.size += this.sizeOf(key, value); 
            Bitmap previous = (Bitmap)this.map.put(key, value); 
            if(previous != null) { 
                this.size -= this.sizeOf(key, previous); 
            } 
        } 
 
        this.trimToSize(this.maxSize); 
        return true; 
    } else { 
        throw new NullPointerException("key == null || value == null"); 
    } 
}

private void trimToSize(int maxSize) { 
    while(true) { 
        synchronized(this) { 
            if(this.size < 0 || this.map.isEmpty() && this.size != 0) { 
                throw new IllegalStateException(this.getClass().getName() + ".sizeOf() is reporting inconsistent results!"); 
            } 
 
            if(this.size > maxSize && !this.map.isEmpty()) { 
                Entry toEvict = (Entry)this.map.entrySet().iterator().next(); 
                if(toEvict != null) { 
                    String key = (String)toEvict.getKey(); 
                    Bitmap value = (Bitmap)toEvict.getValue(); 
                    this.map.remove(key); 
                    this.size -= this.sizeOf(key, value); 
                    continue; 
                } 
            } 
 
            return; 
        } 
    } 
}

最后看一些我们需要怎么使用

配置：

ImageLoaderConfiguration config = new ImageLoaderConfiguration.Builder(YmatouApplication.instance())         .threadPriority(Thread.NORM_PRIORITY - 1)         .memoryCache(new LruMemoryCache(getMemoryCacheSize()))         .diskCacheSize(50 * ByteConstants.MB)         .diskCacheFileNameGenerator(new Md5FileNameGenerator())         .diskCacheFileCount(200)         .memoryCacheExtraOptions(480, 800)         .threadPoolSize(3)         .memoryCache(new WeakMemoryCache())         .tasksProcessingOrder(QueueProcessingType.FIFO)         .defaultDisplayImageOptions(getSimpleOptions().build())         .build(); ImageLoader.getInstance().init(config);

在做网络请求的时候，我们也做些配置，如网络请求之前默认什么背景，请求完成后，请求失败后怎么显示我们都可以在

defaultDisplayImageOptions（DisplayImageOptions.Builder builed）进行配置

private static DisplayImageOptions.Builder getSimpleOptions() { 
    DisplayImageOptions.Builder options = new DisplayImageOptions.Builder() 
            .cacheInMemory(true) 
            .cacheOnDisk(true) 
            .considerExifParams(true) 
            .imageScaleType(ImageScaleType.EXACTLY) 
            .showImageOnLoading(R.drawable.image_loading) 
            .showImageForEmptyUri(R.drawable.image_default) 
            .showImageOnFail(R.drawable.image_failed) 
            .resetViewBeforeLoading(true) 
            .bitmapConfig(Bitmap.Config.ARGB_8888); 
    return options; 
}
 加载图片： 
public static void imageloader(String url, ImageView imageView) {     displayImage(url, imageView, null); }
 
 


原创文章，作者：奋斗，如若转载，请注明出处：https://blog.ytso.com/5842.html