Picasso源码走读

Picasso，Square公司开源的一款图片加载库，实现了图片的下载，缓存及显示功能，本身的Api调用非常的简单，一行代码实现异步加载:

Picasso.with(context).load("url").into(imageView);

Picasso的一些优点：

在Adapter里自带ImageView的显示加载与取消
支持图片转换，降低内存的占用
默认支持二级缓存（内存、硬盘缓存）

下面我们来看Picasso的实现，首先是Picasso.with(context)的初始化代码片段，静态内部类Builder。

  public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
           //建造者模式，构建单一Picasso实例
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }

下面我们看一下，在Builder里做的一些初始化操作

public Picasso build() {
      Context context = this.context;

      if (downloader == null) {
        //创建下载的DownLoader OkhttpClient或者HttpUrlConnection
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {
        //实现缓存的类
        cache = new LruCache(context);
      }
      if (service == null) {
        //线程池，默认3条线程
        service = new PicassoExecutorService();
      }
      if (transformer == null) {
        //请求转换器
        transformer = RequestTransformer.IDENTITY;
      }
        //各种下载状态，缓存状态等处理的类
      Stats stats = new Stats(cache);
        //各种调度处理
      Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

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

同时还有一些其他的可自己选择的构建参数，是否显示Log管理，自定义下载Downloader，加载失败的监听Listener，自定义线程池管理，request请求转换器，自定义请求下载处理RequestHandler等。

/**
     * Specify the default {@link Bitmap.Config} used when decoding images. This can be overridden
     * on a per-request basis using {@link RequestCreator#config(Bitmap.Config) config(..)}.
     */
    public Builder defaultBitmapConfig(Bitmap.Config bitmapConfig) {
      if (bitmapConfig == null) {
        throw new IllegalArgumentException("Bitmap config must not be null.");
      }
      this.defaultBitmapConfig = bitmapConfig;
      return this;
    }

    /** Specify the {@link Downloader} that will be used for downloading images. */
    public Builder downloader(Downloader downloader) {
      if (downloader == null) {
        throw new IllegalArgumentException("Downloader must not be null.");
      }
      if (this.downloader != null) {
        throw new IllegalStateException("Downloader already set.");
      }
      this.downloader = downloader;
      return this;
    }

    /**
     * Specify the executor service for loading images in the background.
     * 

     * Note: Calling {@link Picasso#shutdown() shutdown()} will not shutdown supplied executors.
     */
    public Builder executor(ExecutorService executorService) {
      if (executorService == null) {
        throw new IllegalArgumentException("Executor service must not be null.");
      }
      if (this.service != null) {
        throw new IllegalStateException("Executor service already set.");
      }
      this.service = executorService;
      return this;
    }

    /** Specify the memory cache used for the most recent images. */
    public Builder memoryCache(Cache memoryCache) {
      if (memoryCache == null) {
        throw new IllegalArgumentException("Memory cache must not be null.");
      }
      if (this.cache != null) {
        throw new IllegalStateException("Memory cache already set.");
      }
      this.cache = memoryCache;
      return this;
    }

    /** Specify a listener for interesting events. */
    public Builder listener(Listener listener) {
      if (listener == null) {
        throw new IllegalArgumentException("Listener must not be null.");
      }
      if (this.listener != null) {
        throw new IllegalStateException("Listener already set.");
      }
      this.listener = listener;
      return this;
    }

    /**
     * Specify a transformer for all incoming requests.
     * 

     * NOTE: This is a beta feature. The API is subject to change in a backwards incompatible
     * way at any time.
     */
    public Builder requestTransformer(RequestTransformer transformer) {
      if (transformer == null) {
        throw new IllegalArgumentException("Transformer must not be null.");
      }
      if (this.transformer != null) {
        throw new IllegalStateException("Transformer already set.");
      }
      this.transformer = transformer;
      return this;
    }

    /** Register a {@link RequestHandler}. */
    public Builder addRequestHandler(RequestHandler requestHandler) {
      if (requestHandler == null) {
        throw new IllegalArgumentException("RequestHandler must not be null.");
      }
      if (requestHandlers == null) {
        requestHandlers = new ArrayList();
      }
      if (requestHandlers.contains(requestHandler)) {
        throw new IllegalStateException("RequestHandler already registered.");
      }
      requestHandlers.add(requestHandler);
      return this;
    }

    /**
     * @deprecated Use {@link #indicatorsEnabled(boolean)} instead.
     * Whether debugging is enabled or not.
     */
    @Deprecated public Builder debugging(boolean debugging) {
      return indicatorsEnabled(debugging);
    }

    /** Toggle whether to display debug indicators on images. */
    public Builder indicatorsEnabled(boolean enabled) {
      this.indicatorsEnabled = enabled;
      return this;
    }

    /**
     * Toggle whether debug logging is enabled.
     * 

     * WARNING: Enabling this will result in excessive object allocation. This should be only
     * be used for debugging purposes. Do NOT pass {@code BuildConfig.DEBUG}.
     */
    public Builder loggingEnabled(boolean enabled) {
      this.loggingEnabled = enabled;
      return this;
    }

前面说到，在Builder里面构建了Picasso实例，

Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
          RequestTransformer requestTransformer, List extraRequestHandlers, Stats stats,
          Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
    ...
        
    ...添加了各种资源的request请求，

    //弱引用封装请求Action，
    this.targetToAction = new WeakHashMap();
    //ImageView裁剪
    this.targetToDeferredRequestCreator = new WeakHashMap();
    ... 

    //和RequestWeakReference弱引用关联使用，如果弱引用所引用的对象被垃圾回收，
    //Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。
    this.referenceQueue = new ReferenceQueue