Picasso源码分析记录

Picasso,看的版本是v.2.5.2

  • 使用方法,大概这么几种加载资源的形式
Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

Picasso.with(context).load(R.drawable.landing_screen).into(imageView1);

Picasso.with(context).load("file:///android_asset/DvpvklR.png").into(imageView2);

Picasso.with(context).load(newFile(...)).into(imageView3);

还可以对图片进行一些操作:设置大小、裁剪、加载中&加载错误时显示的图片等,参考Picasso官网。

Picasso.with(context)
    .load(url)
    .resize(50, 50)
    .centerCrop()
    .into(imageView)
Picasso.with(context)
    .load(url)
    .placeholder(R.drawable.user_placeholder)
    .error(R.drawable.user_placeholder_error)
    .into(imageView);
  • 类关系图


    Picasso-classes-relation
  • 开始捋源码
    从外部调用看,first,初始化方法:Picasso.java #with(context):单例模式 double-check + 内部静态类Builder,在Picasso.java#Builder().build(){}方法中使用默认或自定义配置初始化Picasso,返回给外部调用。Builder 中初始化了以下配置:
public Picasso build() {
      Context context = this.context;

      if (downloader == null) {  //1
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {  //2
        cache = new LruCache(context);
      }
      if (service == null) {  //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);  //6

      return new Picasso(context, dispatcher, cache, listener, transformer, requestHandlers, stats,
          defaultBitmapConfig, indicatorsEnabled, loggingEnabled);
    }
  }```
  *  downloader
createDefaultDownloader()里,API 9以上使用 OkHttp (最低支持API 9)、以下使用HttpURLConnection 的 Http 的本地缓存。

  *  cache
  Picasso自定义了一个 LruCache,与 Google 的实现类似,但是是针对 value 为 Bitmap 的精简实现。应该单独写一篇来回顾下[LRU缓存策略]()。
  *  service 
创建线程池,默认是3个执行线程,会根据网络状况再切换线程数。

  * transformer
默认配置是返回原始的 Request,Picasso 文档对于 RequestTransformer 这个接口的解释是
> A transformer that is called immediately before every request is submitted. This can be used to modify any information about a request.
For example, if you use a CDN you can change the hostname for the image based on the current location of the user in order to get faster download speeds.

    如果使用CDN,则可以根据用户的当前位置更改映像的主机名,以获得更快的下载速度。

  * stats 
用于统计下载和缓存的状况,比如总/平均下载数、缓存命中率/未命中率、下载图片的总/平均大小等等

 * dispatcher
用以上的1&2&3&5&new Handler(Looper.getMainLooper()),构造了dispatcher,用于调度任务,handler与主线程进行交互。

  最后用 //6 dispatcher 和一些其他的参数,构造 Picasso返回给外部调用。构造函数如下:
          Picasso(Context context, //1
              Dispatcher dispatcher, //2
              Cache cache, //3
              Listener listener, //4
              RequestTransformer requestTransformer, //5
              List extraRequestHandlers, //6
              Stats stats, //7
              Bitmap.Config defaultBitmapConfig, //8
              boolean indicatorsEnabled, //9
              boolean loggingEnabled //10) {
              ...
              ...
              int builtInHandlers = 7; // Adjust this as internal handlers are added or removed.
              int extraCount = (extraRequestHandlers != null ? extraRequestHandlers.size() : 0);
              List allRequestHandlers =
              new ArrayList(builtInHandlers + extraCount);
              allRequestHandlers.add(new ResourceRequestHandler(context));
              if (extraRequestHandlers != null) {
                  allRequestHandlers.addAll(extraRequestHandlers);
              }
              allRequestHandlers.add(new ContactsPhotoRequestHandler(context));
              allRequestHandlers.add(new MediaStoreRequestHandler(context));
              allRequestHandlers.add(new ContentStreamRequestHandler(context));
              allRequestHandlers.add(new AssetRequestHandler(context));
              allRequestHandlers.add(new FileRequestHandler(context));
              allRequestHandlers.add(new NetworkRequestHandler(dispatcher.downloader, stats));
              requestHandlers = Collections.unmodifiableList(allRequestHandlers);
              ...
              ...
           }
  
    第6个参数比较重要,一个默认添加了7个RequestHandler的List,也可以自定义RequestHandler加进去,均继承自RequestHandler,再返回一个只读的List。类名都很见名知意,对应于开篇时的使用方法,不同的RequestHandler去处理不同资源类型的Request。除了以上10个从Builder里传入的参数外,Picasso的构造函数里还有以下几个:
       Picasso(1,2,3,4,5,6,7,8,9,10){
        ...
        this.targetToAction = new WeakHashMap();  //11
        this.targetToDeferredRequestCreator = new WeakHashMap();  //12
        this.referenceQueue = new ReferenceQueue();  //13
        this.cleanupThread = new CleanupThread(referenceQueue, HANDLER);  //14
        this.cleanupThread.start();
      }

  Picasso构造好之后,调用** load(File | int | String | Uri) **传入要加载的资源,不管传入的什么类型,都是去构造一个RequestCreator,然后返回。好的,那就接着去看看RequestCreator。RequestCreator的构造函数很简单,其中实例化了这样一个变量:
      private final Request.Builder data;
      RequestCreator(Picasso picasso, Uri uri, int resourceId) {
         ...//省略
        this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
      }
进而调用** load() **方法返回 Request.Builder 后可以调用一些像在前面使用方法里的那些方法,对图像做二次处理,这些方法都是Request.java 里的方法,rotate、resize什么的,其中有一个方法灵活性很高,可以满足自定义的一些需求,就是 ** transform(Transformation transformation) **。比如让图片模糊显示(让我想起了微信某个版本的临时性玩法),等等。详细用法可见 [Picasso — Image Rotation and Transformation](https://futurestud.io/tutorials/picasso-image-rotation-and-transformation)

  接下来,最常用到的方法就是**into(ImageView)**方法了,一系列check以及初次调用没有缓存时,重要的是以下几个方法:

public void into(ImageView target, Callback callback) {
...//省略
Request request = createRequest(System.nanoTime());
String requestKey = createKey(request);
Action action = new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,errorDrawable, requestKey, tag, callback, noFade);
picasso.enqueueAndSubmit(action);
}

生成一个唯一标识的 requestKey 来构造 ImageViewAction,它继承自Action,封装了一些回调方法:**complete(),error(),cancel()**等。然后作为参数,调用**enqueueAndSubmit(Action)**

void enqueueAndSubmit(Action action) {
Object target = action.getTarget();
if (target != null && targetToAction.get(target) != action) {
// This will also check we are on the main thread.
cancelExistingRequest(target);
targetToAction.put(target, action);
}
submit(action);
}

判定不为空&&取消当前target已有请求后,把当前的target和action放入targetToAction中,就是上面构造Picasso时的第11个变量,**cancelExistingRequest(target)**其实就是从这个WeakHashMap里移除。重点的方法来了**submit(action)**:

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

这个dispatcher就是前面builder里的第6个变量,再来回顾一下它的构造:

Dispatcher dispatcher = new Dispatcher(context, service, HANDLER, downloader, cache, stats);

看了dispatcher手里的牌,接下来要干什么是不是有点不言而喻了?

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

@Override public void handleMessage(final Message msg) {
switch (msg.what) {
case REQUEST_SUBMIT: {
Action action = (Action) msg.obj;
dispatcher.performSubmit(action);
break;
}
...
}

简化一下performSubmit:

void performSubmit(Action action, boolean dismissFailed) {
BitmapHunter hunter = hunterMap.get(action.getKey());
//1
if (hunter != null) {
hunter.attach(action);
return;
}
...
//2
hunter = forRequest(action.getPicasso(), this, cache, stats, action);
hunter.future = service.submit(hunter);
hunterMap.put(action.getKey(), hunter);
...
}

截了两段我觉得比较重要的片段。
* 第1段,没明白attach之后是要干什么,因为直接就return了,按照 **hunter.attach(action)**里的逻辑看是把相同key的action添加到了BitmapHunter内部维护的一个List中,但是目前没有找到对于List的主动操作,只是cancel、detach用到了。
* 第2段,先是构造了BitmapHunter

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

  // Index-based loop to avoid allocating an iterator.
  //noinspection ForLoopReplaceableByForEach
  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);
}
通过责任链模式,匹配之前添加的那些RequestHandler谁能处理当前发送过来的Request(匹配request的资源的Uri的scheme等判断逻辑),**requestHandler.canHandleRequest(request)**为true就用这个匹配的requestHandler作为参数构造一个BitmapHunter返回。BitmapHunter是实现了Runnable接口的,再贴一下上面的代码:

hunter.future = service.submit(hunter);

值得注意的是这里hunter内部持有了一个future对象,是Future类型,它代表一个异步任务的计算结果。把**service.submit(Runnable)**的结果赋值给了future,这是为了拿到这个返回结果可以做后续的**cancel()**操作。如果不需要这个结果,一般调用的是**service.execute(Runnable)**。stackoverflow上有一段关于这两个方法的选择问答,说的还蛮清楚的。[Choose between ExecutorService's submit and ExecutorService's execute](http://stackoverflow.com/questions/3929342/choose-between-executorservices-submit-and-executorservices-execute)
然后去看看实现了Runnable接口的BitmapHunter内部的**run()**方法(简化后的):

@Override
public void run() {
...
result = hunt();
if (result == null) {
dispatcher.dispatchFailed(this);
} else {
dispatcher.dispatchComplete(this);
}
...
}

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

if (shouldReadFromMemoryCache(memoryPolicy)) {
  bitmap = cache.get(key);
  if (bitmap != null) {
    stats.dispatchCacheHit();
    loadedFrom = MEMORY;
    }
    return bitmap;
  }
}

data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
RequestHandler.Result result = requestHandler.load(data, networkPolicy);
if (result != null) {
  loadedFrom = result.getLoadedFrom();
  exifOrientation = result.getExifOrientation();
  bitmap = result.getBitmap();

  // If there was no Bitmap then we need to decode it from the stream.
  if (bitmap == null) {
    InputStream is = result.getStream();
      bitmap = decodeStream(is, data);
  }
}

if (bitmap != null) {
  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);  
      }
    }
    if (bitmap != null) {
      stats.dispatchBitmapTransformed(bitmap);
    }
  }
}
return bitmap;

}

先根据缓存策略判断是否允许从缓存中读取,允许的话就从cache中get,get到的话在stats中记录命中了缓存并返回命中的bitmap,不允许或未get到就去从之前匹配到的**RequestHandler.load()**,得到**load()**的结果再判断是否有对结果的二次处理什么的,就不再赘述。主要分析下load()跟进去的方法,比如此次请求的是个url资源,匹配的是**NetworkRequestHandler**,去看下它的**load()**方法(简化后的):

@Override @Nullable public Result load(Request request, int networkPolicy) throws IOException {
Response response = downloader.load(request.uri, request.networkPolicy);
Picasso.LoadedFrom loadedFrom = response.cached ? DISK : NETWORK;
InputStream is = response.getInputStream();
return new Result(is, loadedFrom);
}

先调用downloader的load方法,去获得请求的Response,我开始看的是grep code上的源码2.5.2版,http请求时的downloader还像前文分析的那样分为OkHttpDownloader(API 9以上)和UrlConnectionDownloader(API 9以下),写这篇时再看github上的源码由于OkHttp更新到OkHttp3,只有OkHttp3Downloader这一个用于url请求时的Downloader了。无论哪种其内部逻辑都是请求网络返回Response,然后根据Picasso的缓存策略利用的http的本地缓存。
一大圈的调用,顺利地在BitmapHunter的**run()**方法中拿到result且不为空的话,就调用了**dispatcher.dispatchComplete(this)**,这个方法又调用了:

void dispatchComplete(BitmapHunter hunter) {
handler.sendMessage(handler.obtainMessage(HUNTER_COMPLETE, hunter));
}

case HUNTER_COMPLETE: {
BitmapHunter hunter = (BitmapHunter) msg.obj;
dispatcher.performComplete(hunter);
break;
}

void performComplete(BitmapHunter hunter) {
if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
cache.set(hunter.getKey(), hunter.getResult());
}
hunterMap.remove(hunter.getKey());
batch(hunter);
}
}

在这里,根据缓存策略,将结果里的Bitmap加入内存Cache中,也就是前面实例化的LruCache。然后发送一个HUNTER_DELAY_NEXT_BATCH,
handleMessage(Message)中处理:

case HUNTER_DELAY_NEXT_BATCH: {
dispatcher.performBatchComplete();
break;
}

void performBatchComplete() {
List copy = new ArrayList<>(batch);
batch.clear();
mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage( HUNTER_BATCH_COMPLETE, copy));
logBatch(copy);
}

这个mainThreadHandler也就是最开始Picasso的构造函数里Builder里放入去实例化Dispatcher传入的那个HANDLER,再次回到Picasso.java里去看当时HANDLER的初始化:

static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
@Override public void handleMessage(Message msg) {
switch (msg.what) {
case HUNTER_BATCH_COMPLETE: {
@SuppressWarnings("unchecked") List batch = (List) msg.obj;
//noinspection ForLoopReplaceableByForEach
for (int i = 0, n = batch.size(); i < n; i++) {
BitmapHunter hunter = batch.get(i);
hunter.picasso.complete(hunter);
}
break;
}
...
}
};

一切又都回到了当初入口类里的**complete(BitmapHunter)** ,按照源码逻辑,顺利的话接下来是 **deliverAction(Bitmap result, LoadedFrom from, Action action, Exception e)**,再action.complete(result, from);从上面的分析可知,最终调用的是继承了Action的ImageViewAction的complete方法,let's go(依然是简化版):

@Override
public void complete(Bitmap result, Picasso.LoadedFrom from) {
ImageView target = this.target.get();
Context context = picasso.context;
boolean indicatorsEnabled = picasso.indicatorsEnabled;
PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);
if (callback != null) {
callback.onSuccess();
}
}

这样就完成对控件的图片设置。

  源码分析下来,发现Picasso其实非常适合作为一个骨架去自定义重要模块的实现,比如LruCache,比如本地缓存的Downloader,优秀的框架是易于扩展的框架。
* 小结:Picasso的源码不多,也就30几个类,通读一遍也就俩小时,但是记录成文字倒是花费了很长时间。这也是我第一次写这么多东西。深知了那些写文章分享技术的人的不易。同时也希望自己可以养成记录的习惯,这对于彻底理解一件事物还是非常有帮助的。

你可能感兴趣的:(Picasso源码分析记录)