Picasso源码解析

Picasso 是一个强大的图片加载缓存框架

一、使用

Picasso.with(this)
        .load("url")
        .placeholder(R.drawable.leak_canary_icon)//占位图
        .error(R.drawable.leak_canary_icon)//网络失败显示的图片
        .resize(480, 480)//指定图片的尺寸
        .centerCrop()//指定图片缩放类型
        .rotate(90)
        .priority(Picasso.Priority.HIGH)//指定优先级
        .tag("tag")
        .memoryPolicy(MemoryPolicy.NO_CACHE)
        .networkPolicy(NetworkPolicy.NO_CACHE)
        .into(imageView);

二、重要的类

1. Picasso: 图片加载、转换、缓存的管理类。单列模式 ，通过with方法获取实例，也是加载图片的入口。
2. RequestCreator: Request构建类，Builder 模式，采用链式设置该Request的属性(如占位图、缓存策略、裁剪规则、显示大小、优先级等等)。最后调用build()方法生成一个请求（Request）。
3. DeferredRequestCreator:当创建请求的时候还不能获取ImageView的宽和高的时候，则创建一个DeferredRequestCreator，DeferredRequestCreator里对 target 设置监听，直到可以获取到宽和高的时候重新执行请求创建。
4. Action: 请求包装类，存储了该请求和RequestCreator设置的这些属性，最终提交给线程执行下载。
5. Dispatcher:分发器，分发执行各种请求、分发结果等等。
6. PicassoExecutorService:Picasso使用的线程池，默认池大小为3。
7. LruCache:一个使用最近最少使用策略的内存缓存。
8. BitmapHunter:这是Picasso的一个核心的类，开启线程执行下载，获取结果后解码成Bitmap,然后做一些转换操作如图片旋转、裁剪等，如果请求设置了转换器Transformation,也会在BitmapHunter里执行这些转换操作。
9. NetworkRequestHandler:网络请求处理器，如果图片需要从网络下载，则用这个处理器处理。
10. FileRequestHandler:文件请求处理器，如果请求的是一张存在文件中的图片，则用这个处理器处理。
11. AssetRequestHandler: Asset 资源图片处理器，如果是加载asset目录下的图片，则用这个处理器处理。
12. ResourceRequestHandler:Resource资源图片处理器，如果是加载res下的图片，则用这个处理器处理。
13. ContentStreamRequestHandler: ContentProvider 处理器，如果是ContentProvider提供的图片，则用这个处理器处理
14. MediaStoreRequestHandler: MediaStore 请求处理器，如果图片是存在MediaStore上的则用这个处理器处理。
    15.``Response`: 返回的结果信息，Stream流或者Bitmap。
15. Request: 请求实体类，存储了应用在图片上的信息。
16. Target:图片加载的监听器接口，有3个回调方法，onPrepareLoad 在请求提交前回调，onBitmapLoaded 请求成功回调，并返回Bitmap,onBitmapFailed请求失败回调。
17. PicassoDrawable:继承BitmapDrawable，实现了过渡动画和图片来源的标识（就是图片来源的指示器，要调用 setIndicatorsEnabled(true)方法才生效），请求成功后都会包装成BitmapDrawable显示到ImageView 上。
18. OkHttpDownloader:用OkHttp实现的图片下载器，默认就是用的这个下载器。
19. UrlConnectionDownloader:使用HttpURLConnection 实现的下载器。
20. MemoryPolicy: 内存缓存策略，一个枚举类型。
21. NetworkPolicy: 磁盘缓存策略，一个枚举类型。
22. Stats: 这个类相当于日志记录，会记录如：内存缓存的命中次数，丢失次数，下载次数，转换次数等等，我们可以通过StatsSnapshot类将日志打印出来，看一下整个项目的图片加载情况。

三、源码分析

1、获取Picasso实例

Picasso采用单例模式

  public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }

// 真正new 的地方在build()方法里
 public Picasso build() {
      Context context = this.context;

      if (downloader == null) {
        //1. 配置默认的下载器，首先通过反射获取OkhttpClient,如果获取到了，就使用OkHttpDwownloader作为默认下载器
        //如果获取不到就使用UrlConnectionDownloader作为默认下载器
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {
       // 2. 配置内存缓存，大小为手机内存的15%
        cache = new LruCache(context);
      }
      if (service == null) {
       // 3.配置Picaso 线程池，核心池大小为3
        service = new PicassoExecutorService();
      }
      if (transformer == null) {
       // 4. 配置请求转换器，默认的请求转换器没有做任何事，直接返回原请求
        transformer = RequestTransformer.IDENTITY;
      }

      Stats stats = new Stats(cache);
      //5.创建分发器 
      Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
    }

1. 配置默认的下载器

  static Downloader createDefaultDownloader(Context context) {
    try {
      // 查找项目中是否使用了OkHttp
      Class.forName("com.squareup.okhttp.OkHttpClient");
      return OkHttpLoaderCreator.create(context);
    } catch (ClassNotFoundException ignored) {
    }
    // 没有使用OkHttp则用默认的HttpURLConnection
    return new UrlConnectionDownloader(context);
  }

2. 配置内存缓存：最多手机内存的15%

  public LruCache(Context context) {
    this(Utils.calculateMemoryCacheSize(context));
  }

  public LruCache(int maxSize) {
    if (maxSize <= 0) {
      throw new IllegalArgumentException("Max size must be positive.");
    }
    this.maxSize = maxSize;
    this.map = new LinkedHashMap(0, 0.75f, true);
  }

  static int calculateMemoryCacheSize(Context context) {
    ActivityManager am = getService(context, ACTIVITY_SERVICE);
    boolean largeHeap = (context.getApplicationInfo().flags & FLAG_LARGE_HEAP) != 0;
    int memoryClass = am.getMemoryClass();
    if (largeHeap && SDK_INT >= HONEYCOMB) {
      memoryClass = am.getLargeMemoryClass();
    }
    // Target ~15% of the available heap.
    return 1024 * 1024 * memoryClass / 7;
  }

3. 配置线程池

  PicassoExecutorService() {
    super(DEFAULT_THREAD_COUNT, DEFAULT_THREAD_COUNT, 0, TimeUnit.MILLISECONDS,
        new PriorityBlockingQueue(), new Utils.PicassoThreadFactory());
  }

4. 配置默认请求转换器

    // 空转换，请求原样返回
    RequestTransformer IDENTITY = new RequestTransformer() {
      @Override public Request transformRequest(Request request) {
        return request;
      }
    };

5. Dispatcher分发器

  Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
      Downloader downloader, Cache cache, Stats stats) {
    // DispatcherThread继承自HandlerThread，主要做一些耗时操作 
    this.dispatcherThread = new DispatcherThread();
    this.dispatcherThread.start();
    this.context = context;
    this.service = service;
    this.hunterMap = new LinkedHashMap();
    this.failedActions = new WeakHashMap();
    this.pausedActions = new WeakHashMap();
    this.pausedTags = new HashSet