Universal-Image-Loader源码分析（一）——ImageLoaderConfiguration分析

UIl与Volley同样是很是古老的框架，UIL实现了从网络获取图片，对图片进行缓存，以及根据个性化的设置来将图片加载到ImageView上。

这篇文章 主要分析UIl在初始化配置的源码

UIL初始化的源码分析

UIl提供在Application中进行UIl的初始化操做，常见的初始化操做代码以下：

ImageLoaderConfiguration.Builder config = new ImageLoaderConfiguration.Builder(context);
        config.threadPriority(Thread.NORM_PRIORITY - 2);
        config.denyCacheImageMultipleSizesInMemory();
        config.diskCacheFileNameGenerator(new Md5FileNameGenerator());
        config.diskCacheSize(50 * 1024 * 1024); // 50 MiB
        config.tasksProcessingOrder(QueueProcessingType.LIFO);
        config.writeDebugLogs(); // Remove for release app

        // Initialize ImageLoader with configuration.
        ImageLoader.getInstance().init(config.build());

以Builder模式来构建ImageLoaderConfiguration。
下面是ImageLoaderConfiguration类的成员变量，也是具体的配置选项。

//资源信息
    final Resources resources;
    //内存缓存 图片的最大宽度
    final int maxImageWidthForMemoryCache;
    //内存缓存 图片的最大高度
    final int maxImageHeightForMemoryCache;
    //本地文件系统缓存 图片的最大宽度
    final int maxImageWidthForDiskCache;
    //本地文件系统缓存 图片的最大高度
    final int maxImageHeightForDiskCache;
    //本地文件系统缓存 图片处理器
    final BitmapProcessor processorForDiskCache;
    //任务执行者
    final Executor taskExecutor;
    //图片缓存任务执行者
    final Executor taskExecutorForCachedImages;
    //是否自定义任务执行者
    final boolean customExecutor;
    //是否为图片缓存自定义任务执行者
    final boolean customExecutorForCachedImages;
    //线程池中线程数量
    final int threadPoolSize;
    //线程等级
    final int threadPriority;
    //队列中处理算法类型
    final QueueProcessingType tasksProcessingType;
    //内存缓存对象
    final MemoryCache memoryCache;
    //本地文件系统缓存对象
    final DiskCache diskCache;
    //图片默认下载加载器
    final ImageDownloader downloader;
    //图片解码器
    final ImageDecoder decoder;
    //图片显示配置参数
    final DisplayImageOptions defaultDisplayImageOptions;
    //网络拒绝时下载器
    final ImageDownloader networkDeniedDownloader;
    //慢网络时下载器
    final ImageDownloader slowNetworkDownloader;

Builder模式构建对象，上述的不少变量都是经过外部传入。咱们只看几个变量的初始值。

• 线程池中线程数量默认是3
• 线程的优先级是Thread.NORM_PRIORITY - 2
• 队列中处理算法是QueueProcessingType.FIFO

若是没有指定config的配置，则采用默认的配置，经过工厂模式建立一系列初始化值。
建立的初始值以下：

• taskExecutor
• taskExecutorForCachedImages
• diskCache
• memoryCache
• downloader
• decoder

下面咱们看看DefaultConfigurationFactory的源码

默认配置工厂类能够建立任务执行者 taskExecutor, taskExecutorForCachedImages

public static Executor createExecutor(int threadPoolSize, int threadPriority,
            QueueProcessingType tasksProcessingType) {
        //初始化队列算法类型 默认为LIFO
        boolean lifo = tasksProcessingType == QueueProcessingType.LIFO;
        //初始化队列 根据不一样的算法类型，建立不一样的队列
        BlockingQueue<Runnable> taskQueue =
                lifo ? new LIFOLinkedBlockingDeque<Runnable>() : new LinkedBlockingQueue<Runnable>();
        return new ThreadPoolExecutor(threadPoolSize, threadPoolSize, 0L, TimeUnit.MILLISECONDS, taskQueue,
                createThreadFactory(threadPriority, "uil-pool-"));
    }

其主要的事情 就是建立阻塞队列，根据QueueProcessingType的类型，建立各类类型的阻塞队列。
在执行该方法的时候，若是咱们没有指定的话 在ImageLoaderConfiguration中是FIFO，先入先出。
taskExecutor和taskExecutorForCachedImages有同样的初始化方法，和参数

下面 咱们看看各类缓存的初始化

针对DiskCache,代码以下：

public static DiskCache createDiskCache(Context context, FileNameGenerator diskCacheFileNameGenerator,
            long diskCacheSize, int diskCacheFileCount) {
        //建立备用缓存文件
        File reserveCacheDir = createReserveDiskCacheDir(context);
        if (diskCacheSize > 0 || diskCacheFileCount > 0) {
            File individualCacheDir = StorageUtils.getIndividualCacheDirectory(context);
            try {
                //建立本地文件系统缓存器
                return new LruDiskCache(individualCacheDir, reserveCacheDir, diskCacheFileNameGenerator, diskCacheSize,
                        diskCacheFileCount);
            } catch (IOException e) {
                L.e(e);
                // continue and create unlimited cache
            }
        }
        //建立无限制的文件缓存器
        File cacheDir = StorageUtils.getCacheDirectory(context);
        return new UnlimitedDiskCache(cacheDir, reserveCacheDir, diskCacheFileNameGenerator);
    }

这边能够看出 当LruDiskCache不能用时，会建立一个无限制文件缓存。

针对MemoryCache，代码以下：

public static MemoryCache createMemoryCache(Context context, int memoryCacheSize) {
        if (memoryCacheSize == 0) {
            ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
            int memoryClass = am.getMemoryClass();
            if (hasHoneycomb() && isLargeHeap(context)) {
                memoryClass = getLargeMemoryClass(am);
            }
            memoryCacheSize = 1024 * 1024 * memoryClass / 8;
        }
        return new LruMemoryCache(memoryCacheSize);
    }

memoryCacheSize是每一个App的限制内存大小，memoryCache的大小是App限制大小的1/8

默认配置工厂还建立了图片默认的下载器BaseIamgeDownloader以及图片默认的解码器BaseImageDecoder
这个咱们后面再分析。

到如今，已经完成了UIL初始化的时候的各类配置，下一篇咱们看一下在使用的时候，其内部的流程。