Picasso源码解析

【前言】

关于Picasso的使用教程，网上资料有很多。本文主要是对Picasso源码进行解析，关于Picasso的详细使用方法，可访问http://square.github.io/picasso/。

Picasso实现了一行代码加载图片的功能（可加载本地图片、网络图片），使用它可以自动处理Android中加载图片涉及到的以下几个问题：

① Adapter中对ImageView的回收和下载任务的自动取消

② 以最小的内存，完成复杂的图片格式转换

③ 自动处理内存缓存和硬盘缓存

 

【Picasso.with(Context) 介绍】

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

通过调用with来获取Picasso的实例，由于使用了构建者模式，在build中构建了许多下载和缓存相关的对象

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

    if (downloader == null) {
      /**
       * 构建默认的下载器（默认使用OkHttp请求网络图片）
       */
      downloader = Utils.createDefaultDownloader(context);
    }
    if (cache == null) {
      /**
       * 默认缓存机制（Lru内存缓存）
       */
      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);
  }
}

如果用户不想使用默认的构建对象，可通过new Picasso.Builder来创建Picasso实例。

【Picasso.load(...) 介绍】

load是一个重载的函数，有四种类型的形参

① File 通过转换，调用了load(Uri)

② Uri

③ String 通过转换，调用了load(Uri)

④ int 加载drawable资源图片

public RequestCreator load(@Nullable Uri uri) {
  return new RequestCreator(this, uri, 0);
}

public RequestCreator load(@DrawableRes int resourceId) {
  if (resourceId == 0) {
    throw new IllegalArgumentException("Resource ID must not be zero.");
  }
  return new RequestCreator(this, null, resourceId);
}

 

 

 

【RequestCreator 介绍】

封装了图片加载请求，一次请求对应一个RequestCreator实例。该类包含了几个常见的函数：

① placeholder 设置加载过程中显示的图片

② error 设置加载异常后显示的图片

③ resize 重置图片尺寸

④ centerCrop 对图片进行裁剪

⑤ transform 对图片做置换操作（如变形、圆角处理等）

⑥ into 实现异步请求图片到指定的 View组件

【RequestCreator.into(...) 介绍】

into是个重载的函数。支持把图片“绑定”到指定的View控制，其中View控件可以是普通的ImageView，也可以是跨进程的RemoteViews。

public void into(ImageView target, Callback callback) {
  long started = System.nanoTime();

  /**
   * 注意，into方法必须在主线程中调用
   */
  checkMain();
...

  /**
   * 如果之前通过uri或resourceId加载过改图片，则取消请求

   */

  if (!data.hasImage()) {
    picasso.cancelRequest(target);
          ...
    return;
  }
...
  Request request = createRequest(started);
  String requestKey = createKey(request);
    /**
     * 读取内存中对应的图片，如果有则取消请求

     */
  if (shouldReadFromMemoryCache(memoryPolicy)) {
    Bitmap bitmap = picasso.quickMemoryCacheCheck(requestKey);
    if (bitmap != null) {
      picasso.cancelRequest(target);
      setBitmap(target, picasso.context, bitmap, MEMORY, noFade, picasso.indicatorsEnabled);
      if (picasso.loggingEnabled) {
        log(OWNER_MAIN, VERB_COMPLETED, request.plainId(), "from " + MEMORY);
      }
      if (callback != null) {
        callback.onSuccess();
      }
      return;
    }
  }
  ...

  /**
   * 把请求封装成Action

   */
  Action action =
      new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
          errorDrawable, requestKey, tag, callback, noFade);
  /**
   * Action进入请求队列

   */

  picasso.enqueueAndSubmit(action);
}

【Picasso.enqueueAndSubmit 介绍】

    void enqueueAndSubmit(Action action) {
  Object target = action.getTarget();
  if (target != null && targetToAction.get(target) != action) {
    /**
     * 取消View对应的历史Action请求（保证同一时刻，View只对应一个Action请求）
     * 注：该方法要求在主线程调用
     */
    cancelExistingRequest(target);
    targetToAction.put(target, action);
  }
  submit(action);
}

【Picasso.submint 介绍】

    Picasso的submint很简单，逻辑的处理交给了事件分发器Dispatcher，接下来看看Dispatcher的dispatchSubmit

    void submit(Action action) {
  dispatcher.dispatchSubmit(action);
}

【Dispatcher.dispatchSubmit 介绍】

    void dispatchSubmit(Action action) {
  handler.sendMessage(handler.obtainMessage(REQUEST_SUBMIT, action));
}

dispatchSubmit里面的逻辑也很明了，交给了handler处理。其实这个handler使用的looper是HandlerThread传进来的，而这个HandlerThread又是在Picasso的build中初始化的，也就是说handler属于主线程。

 

Dispatcher(Context context, ExecutorService service, Handler mainThreadHandler,
    Downloader downloader, Cache cache, Stats stats) {
  this.dispatcherThread = new DispatcherThread();
  ...

  this.handler = new DispatcherHandler(dispatcherThread.getLooper(), this);
  ...
}

  public Picasso build() {
   ...
    /**
     * 事件分发器
     */
    Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);
   ...
  }
}

根据REQUEST_SUBMIT可知，调用了 dispatcher.performSubmit(action);

【Dispatcher.performSubmit(Action, boolean) 介绍】

    performSubmit中通过forRequest创建了BitmapHunter实例，它其实是Runnable的子类，之后交给线程池去执行。可知图片的加载请求是在BitmapHunter的run方法中执行的。

    void performSubmit(Action action, boolean dismissFailed) {
  /**
   * 如果action被贴上暂停的标签，则加入pausedActions集合，且不对请求做处理
   */
  if (pausedTags.contains(action.getTag())) {
    pausedActions.put(action.getTarget(), action);
    if (action.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_PAUSED, action.request.logId(),
          "because tag '" + action.getTag() + "' is paused");
    }
    return;
  }

  /**
   * BitmapHunter其实是一个Runnable
   */
  BitmapHunter hunter = hunterMap.get(action.getKey());
  if (hunter != null) {
    hunter.attach(action);
    return;
  }

  /**
   * 判断线程池是否关闭
   */
  if (service.isShutdown()) {
    if (action.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), "because shut down");
    }
    return;
  }

  /**
   * 构建请求Runnable
   */
  hunter = forRequest(action.getPicasso(), this, cache, stats, action);
  hunter.future = service.submit(hunter);
  hunterMap.put(action.getKey(), hunter);
  if (dismissFailed) {
    failedActions.remove(action.getTarget());
  }

  if (action.getPicasso().loggingEnabled) {
    log(OWNER_DISPATCHER, VERB_ENQUEUED, action.request.logId());
  }
}

【Dispatcher.forRequest 介绍】

    在创建BitmapHunter实例前，会遍历请求处理器集合，该集合的初始化是在Picasso的构造函数中。至少有7个处理器——对不同来源的图片请求进行处理。当然，用户也可以自定义处理器。如果都没有匹配到，将使用默认的ERRORING_HANDLER 并抛出异常。

static BitmapHunter forRequest(Picasso picasso, Dispatcher dispatcher, Cache cache, Stats stats,
    Action action) {
  Request request = action.getRequest();
  List<RequestHandler> requestHandlers = picasso.getRequestHandlers();

  // Index-based loop to avoid allocating an iterator.
  //noinspection ForLoopReplaceableByForEach
  /**
   * 遍历集合，找到适合处理该请求的处理器
   * 至少有7个处理器对不同来源的请求进行匹配：

   * ResourceRequestHandler、ContactsPhotoRequestHandler、

   * MediaStoreRequestHandler、ContentStreamRequestHandler、

   * AssetRequestHandler、FileRequestHandler、NetworkRequestHandler
   * 如果都不匹配，也没有自定义的处理器，则使用 ERRORING_HANDLER 抛出异常
   */
  for (int i = 0, count = requestHandlers.size(); i < count; i++) {
    RequestHandler requestHandler = requestHandlers.get(i);
    if (requestHandler.canHandleRequest(request)) {
      return new BitmapHunter(picasso, dispatcher, cache, stats, action, requestHandler);
    }
  }

  return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
}

【BitmapHunter.run 介绍】

BitmapHunter.run是请求图片的主要入口，里面又调用了hunt行数，由它完成图片的请求和返回请求结果。

@Override public void run() {
  try {
    updateThreadName(data);

    if (picasso.loggingEnabled) {
      log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
    }

    /**
     * 开始请求图片，并切返回请求结果
     */
    result = hunt();
    ...
}

【BitmapHunter.hunt介绍】

    该方法首先会读取内存中是否有缓存图片，如果没有才会调用requestHandler.load真正加载图片，这个requestHandler就是前面说到的7个请求处理器中的一个，这里以NetworkRequestHandler 为例讲解获取网络图片的过程。

Bitmap hunt() throws IOException {
  Bitmap bitmap = null;

  /**
   * 先从内存中读取是否有缓存的图片
   */
  if (shouldReadFromMemoryCache(memoryPolicy)) {
    bitmap = cache.get(key);
    if (bitmap != null) {
      stats.dispatchCacheHit();
      loadedFrom = MEMORY;
      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_DECODED, data.logId(), "from cache");
      }
      return bitmap;
    }
  }

  /**
   * 除了网络请求处理器返回默认的重试次数为2，其他请求处理器都返回0
   */
  data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
  /**
   * 处理器开始加载图片（这里以 NetworkRequestHandler 为例讲解）
   */
  RequestHandler.Result result = requestHandler.load(data, networkPolicy);
      ...
  if (bitmap != null) {
    if (picasso.loggingEnabled) {
      log(OWNER_HUNTER, VERB_DECODED, data.logId());
    }
    stats.dispatchBitmapDecoded(bitmap);
    if (data.needsTransformation() || exifOrientation != 0) {
      synchronized (DECODE_LOCK) {
        /**
         * 如果设置了图片转换器(变形，旋转等处理)，则进行置换处理
         */
        if (data.needsMatrixTransform() || exifOrientation != 0) {
          bitmap = transformResult(data, bitmap, exifOrientation);
            ...
        }
        if (data.hasCustomTransformations()) {
          bitmap = applyCustomTransformations(data.transformations, bitmap);
            ...
        }
      }
       ...
    }
  }

  return bitmap;
}

【NetworkRequestHandler.load 介绍】

load里面使用了默认下载器来加载网络数据。该下载器的实例化在Picasso的build里（Utils.createDefaultDownloader），默认实现是OkHttp3Downloader。所以需要跳转到OkHttp3Downloader的load里去看个究竟。

    @Override @Nullable public Result load(Request request, int networkPolicy) throws IOException {
  /**
   * 使用默认下载器加载网络数据（下载器初始化在Picasso.build里，默认是OkHttp3Downloader）
   * 可见Picasso 网络请求部分，使用了第三方开源工具 OkHttp
   */
  Response response = downloader.load(request.uri, request.networkPolicy);
  if (response == null) {
    return null;
  }

  Picasso.LoadedFrom loadedFrom = response.cached ? DISK : NETWORK;

  Bitmap bitmap = response.getBitmap();
     ...
  return new Result(is, loadedFrom);
}

【OkHttp3Downloader.load 介绍】

    最终通过调用OkHttp的网络请求接口获取图片数据，把返回的数据封装到Response后返回。

@Override public Response load(@NonNull Uri uri, int networkPolicy) throws IOException {
     Request.Builder builder = new okhttp3.Request.Builder().url(uri.toString());

...
  /**
   * 直接调用了 OkHttp 框架的网络请求接口，然后把返回的输入流封装到Response返回
   */
  okhttp3.Response response = client.newCall(builder.build()).execute();
  int responseCode = response.code();
  if (responseCode >= 300) {
    response.body().close();
    throw new ResponseException(responseCode + " " + response.message(), networkPolicy,
        responseCode);
  }

  boolean fromCache = response.cacheResponse() != null;
  ResponseBody responseBody = response.body();
  return new Response(responseBody.byteStream(), fromCache, responseBody.contentLength());
}

【总结】

    至此Picasso的源码分析就暂告一段落，让我们回头总结下。Picasso作为一款出色的图片获取、处理框架，离不开服务框架OkHttp、缓存框架LruCache的功劳。还加入了线程池管理器，支持请求优先级设置，支持图片压缩和置换处理，有效避免了OOM异常。