Picassio源码分析

步骤

get()：

双锁创建Picasso单例，通过Builder模式创建

Picasso singleton；

  public static Picasso get() {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          if (PicassoProvider.context == null) {
            throw new IllegalStateException("context == null");
          }
          singleton = new Builder(PicassoProvider.context).build();
        }
      }
    }
    return singleton;
  }

private  Context;
 public Builder(@NonNull Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
    // 这里得到的是ApplicationContext的上下文
      this.context = context.getApplicationContext();
    }

可以看到传入的只是Builder到这里只有一个上下文context

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

      if (downloader == null) {
        downloader = new OkHttp3Downloader(context);
      }
      if (cache == null) {
        cache = new LruCache(context);
      }
      if (service == null) {
        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);
    }

调用build的时候，我们会创建多个东西：

• downloader : OKHTTP的下载器
• LruCache : 缓存器
• PicassoExecutorService : 线程池服务
• transformer ： 变压器

  Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
      RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats,
      Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {
    this.context = context;
    this.dispatcher = dispatcher;
    this.cache = cache;
    this.listener = listener;
    this.requestTransformer = requestTransformer;
    this.defaultBitmapConfig = defaultBitmapConfig;

    int builtInHandlers = 7; // Adjust this as internal handlers are added or removed.
    int extraCount = (extraRequestHandlers != null ? extraRequestHandlers.size() : 0);
    List<RequestHandler> allRequestHandlers = new ArrayList<>(builtInHandlers + extraCount);

    // ResourceRequestHandler needs to be the first in the list to avoid
    // forcing other RequestHandlers to perform null checks on request.uri
    // to cover the (request.resourceId != 0) case.
    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);

    this.stats = stats;
    this.targetToAction = new WeakHashMap<>();
    this.targetToDeferredRequestCreator = new WeakHashMap<>();
    this.indicatorsEnabled = indicatorsEnabled;
    this.loggingEnabled = loggingEnabled;
    this.referenceQueue = new ReferenceQueue<>();
    this.cleanupThread = new CleanupThread(referenceQueue, HANDLER);
    this.cleanupThread.start();
  }

这里我们才真正真正初始化了单例Picasso ，最后传入对应的配置。接下开看看比较重要的：
allRequestHandlers：是一个容器内部包裹了多个RequestHandler，用来解决不同的请求，举个例子，家里装了新家
我们需要做的事情就是请工人安装，但是工人分为好几种，电工.管道.工装空调的等等他们各司其职 ，用来解决不同的场景，而这里我们就可以把他看成一个一个的“工人”。

--

load（）

 public RequestCreator load(@Nullable String path) {
    if (path == null) {
      return new RequestCreator(this, null, 0);
    }
    if (path.trim().length() == 0) {
      throw new IllegalArgumentException("Path must not be empty.");
    }
    return load(Uri.parse(path));
  }
  
 public RequestCreator load(@Nullable Uri uri) {
    return new RequestCreator(this, uri, 0);
  }

这里可以看见调用load的时候我们进行判断过滤，输入的满足条件就可以开始创建RequestCreator类

  RequestCreator(Picasso picasso, Uri uri, int resourceId) {
    if (picasso.shutdown) {
      throw new IllegalStateException(
          "Picasso instance already shut down. Cannot submit new requests.");
    }
    this.picasso = picasso;
    this.data = new Request.Builder(uri, resourceId, picasso.defaultBitmapConfig);
  }

做了两点，传入picasso引用，创建Request.Builder ，这里load就结束了其实，我们发现返回的其实是包装好了的RequestCreator，而且RequestCreator内部包含引用data=Request.Builder，但是到目前为止我们什么都还没做，只是初始化了相关配置，创建了RequestCreator而已。

into

好戏现在才开始

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

    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }

    if (!data.hasImage()) {
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }

    if (deferred) {
      if (data.hasSize()) {
        throw new IllegalStateException("Fit cannot be used with resize.");
      }
      int width = target.getWidth();
      int height = target.getHeight();
      if (width == 0 || height == 0) {
        if (setPlaceholder) {
          setPlaceholder(target, getPlaceholderDrawable());
        }
        picasso.defer(target, new DeferredRequestCreator(this, target, callback));
        return;
      }
      data.resize(width, height);
    }

    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;
      }
    }

    if (setPlaceholder) {
      setPlaceholder(target, getPlaceholderDrawable());
    }

    Action action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    picasso.enqueueAndSubmit(action);
  }
  
  
   private Request createRequest(long started) {
    int id = nextId.getAndIncrement();

    Request request = data.build();
    request.id = id;
    request.started = started;

    boolean loggingEnabled = picasso.loggingEnabled;
    if (loggingEnabled) {
      log(OWNER_MAIN, VERB_CREATED, request.plainId(), request.toString());
    }

    Request transformed = picasso.transformRequest(request);
    if (transformed != request) {
      // If the request was changed, copy over the id and timestamp from the original.
      transformed.id = id;
      transformed.started = started;

      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_CHANGED, transformed.logId(), "into " + transformed);
      }
    }

    return transformed;
  }
  

    boolean hasImage() {
      return uri != null || resourceId != 0;
    }

1. 我们检查是不是在主线程
2. 判断uri或者resourceId ，即来源是不是为空，为空就直接取消请求，设置占位图
3. 是不是调用fit()，但是不能和resize一起用
4. 创建Request实体,即Request.Builder.build()，这里有过滤然后设置该Request为普通
5. 设置resourceId还有开始的时间
6. createRequest(started)设置了transformed转换器的一个接口，实现该接口应该可以手动改变request，如果转换后的request变更我们就改变他
7. 是不是需要在缓存中找，如果找到取消请求，设置图片，回调成功接口。
8. 没有找到就设置占位图，创建一个Action，调用picasso.enqueueAndSubmit(action);

Action 和 Requst的对比。

如果查看区别的话，其实属性都可以查看出来：
我们看看Request属性：

 int id;
  long started;
  int networkPolicy;
  public final Uri uri;
  public final int resourceId;
  public final String stableKey;
  public final List<Transformation> transformations;
  public final int targetWidth;
  public final int targetHeight;
  public final boolean centerCrop;
  public final boolean centerInside;
  public final boolean onlyScaleDown;
  public final float rotationDegrees;
  public final float rotationPivotX;
  public final float rotationPivotY;
  public final boolean hasRotationPivot;
  public final Bitmap.Config config;
  public final Priority priority;

再来看看Action属性

final Picasso picasso;
  final Request request;
  final WeakReference<T> target;
  final boolean noFade;
  final int memoryPolicy;
  final int networkPolicy;
  final int errorResId;
  final Drawable errorDrawable;
  final String key;
  final Object tag;
  boolean willReplay;
  boolean cancelled;

我们可以看见Request跟注重的是他请求的本身 如：id，请求的来源等等 ，而Action更倾向于一个加载的任务而且它持有Request引用，还有任务的状态，各种策略等，所以是包含关系。

回到代码中：

  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);
  }

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

因为Target 是所谓的虚引用，然后拿出Target判断是不是和数组里的Target一样不一样就更新。最后交给了
dispatcher.dispatchSubmit(action)。

Dispatcher

中文译为分发者即 ： 任务分发者

• 他是在Picassio初始化的时候被创建的是
• 每一个Dispatcher都关联了 线程池 下载器 缓存 监控器 以及主线程的Handler
• 他是发动机，也是我们的控制或者说中心
• Dispatcher内部有一个东西即 DispatcherHandler这是Dispatcher自己的Handler，他绑定的是Dispatcher子线程的Looper

Dispatcher. dispatchSubmit():

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

而这个handler就是我们之前聊到的DispatcherHandler，相当于把发送的任务交给了子线程，我看看接下来到底是怎样的吧：
这里插一句 ： 子线程handleMessage调用performSubmit方法不多讲中间过程不多讲

oid performSubmit(Action action, boolean dismissFailed) {
//注意哦，这里已经不在主线程了，而是在dispatcher线程(HandlerThread)
    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 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;
    }

    //创建hunter
    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());
    }
  }

1. 判断任务是不是被暂停了，如果暂停了就放入暂停的容器里
2. 在通过 key在huntermap中寻找有没有对应的hunter
3. 判断是不是线程被关闭，不然就return
4. 创建对应的Hunter ，等一会儿详细讨论它
5. 调用直接把Hunter扔进去线程池中，为什么能直接扔，看下面
6. 然后把Hunter和key为键值对放到hunterMap容器中

BitmapHunter

中文翻译 图像猎人 脑洞真大
先看实现接口吧：

class BitmapHunter implements Runnable

实现了Runable的接口，这说明了上文的为什么可以直接扔进线程池的原因，所以等等我们思路就跟更加明了直接在run方法看线程池执行的过程
不过在这之前我们得看看Hunter是如何创建的：

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
    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吗？现在我们正调用canHandleRequest方法，一个一个对比他们的能力是不是和这个任务匹配，如果找到就创建BitmapHunter对象并且传入对应requestHandler引用。

接下来，emm.....看Hunter的run方法

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

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

      result = hunt();

      if (result == null) {
        dispatcher.dispatchFailed(this);
      } else {
        dispatcher.dispatchComplete(this);
      }
    } catch (Downloader.ResponseException e) {
      if (!e.localCacheOnly || e.responseCode != 504) {
        exception = e;
      }
      dispatcher.dispatchFailed(this);
    } catch (NetworkRequestHandler.ContentLengthException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (IOException e) {
      exception = e;
      dispatcher.dispatchRetry(this);
    } catch (OutOfMemoryError e) {
      StringWriter writer = new StringWriter();
      stats.createSnapshot().dump(new PrintWriter(writer));
      exception = new RuntimeException(writer.toString(), e);
      dispatcher.dispatchFailed(this);
    } catch (Exception e) {
      exception = e;
      dispatcher.dispatchFailed(this);
    } finally {
      Thread.currentThread().setName(Utils.THREAD_IDLE_NAME);
    }
  }

我们只用关心两点：

• 调用hunt “打猎” ，然后传回打猎的结果
• 如果有结果 调用 dispatcher.dispatchComplete(this)否则调用dispatcher.dispatchFailed(this);

然后看看怎么“打的猎吧”

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;
     }
   }

   //缓存没有命中的话，再调用requestHandler.load
   data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
   RequestHandler.Result result = requestHandler.load(data, networkPolicy);
   //拿到结果
   if (result != null) {
     loadedFrom = result.getLoadedFrom();
     exifRotation = result.getExifOrientation();
      //从结果中拿bitmap
     bitmap = result.getBitmap();

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

   if (bitmap != null) {
     if (picasso.loggingEnabled) {
       log(OWNER_HUNTER, VERB_DECODED, data.logId());
     }
     stats.dispatchBitmapDecoded(bitmap);
     //图片变换
     if (data.needsTransformation() || exifRotation != 0) {
       synchronized (DECODE_LOCK) {
         if (data.needsMatrixTransform() || exifRotation != 0) {
           bitmap = transformResult(data, bitmap, exifRotation);
           if (picasso.loggingEnabled) {
             log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId());
           }
         }
         if (data.hasCustomTransformations()) {
           bitmap = applyCustomTransformations(data.transformations, bitmap);
           if (picasso.loggingEnabled) {
             log(OWNER_HUNTER, VERB_TRANSFORMED, data.logId(), "from custom transformations");
           }
         }
       }
       if (bitmap != null) {
         stats.dispatchBitmapTransformed(bitmap);
       }
     }
   }

   return bitmap;
 }

• 缓存里面找
• 没找到调用Handler的load方法了
• load拿到结果取出 bitmap
• 查看我们是不是要变化即data.needsTransformation，如果要变化就变化
• 最后返回bitmap给Hunter ，调用dispatcher.dispatchComplete(this)

void performComplete(BitmapHunter hunter) {
    if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }
    hunterMap.remove(hunter.getKey());
    batch(hunter);
    if (hunter.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion");
    }
  }

• 首先根据缓存策略看是不是缓存
• 执行完后应该删除hunter在容器中
• 批量处理hunter

然后看看怎么批量处理的吧：

batch = new ArrayList();
  private void batch(BitmapHunter hunter) {
    if (hunter.isCancelled()) {
      return;
    }
    if (hunter.result != null) {
      hunter.result.prepareToDraw();
    }
    batch.add(hunter);
    if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
      handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
    }
  }

看到这里BATCH_DELAY是200ms 意思说在这期间全部返回的结果都交给了batch这个容器，最后延迟200ms发送信息

事情又回到了dispatcher的子线程中，而子线程会调用dispatcher.performComplete(hunter);

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

• 子线程提出批量的BitmapHunter然后清空batch
• 最后交给主线程批量更新UI

下面就看看主线程吧:

case HUNTER_BATCH_COMPLETE: {
          @SuppressWarnings("unchecked") List<BitmapHunter> batch = (List<BitmapHunter>) msg.obj;
          //noinspection ForLoopReplaceableByForEach
          for (int i = 0, n = batch.size(); i < n; i++) {
            BitmapHunter hunter = batch.get(i);
            hunter.picasso.complete(hunter);
          }

不用说逐个调用hunter.picasso.complete(hunter);

 @Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
    Action single = hunter.getAction();
    List<Action> joined = hunter.getActions();

    boolean hasMultiple = joined != null && !joined.isEmpty();
    boolean shouldDeliver = single != null || hasMultiple;

    if (!shouldDeliver) {
      return;
    }

    Uri uri = hunter.getData().uri;
    Exception exception = hunter.getException();
    Bitmap result = hunter.getResult();
    LoadedFrom from = hunter.getLoadedFrom();

    if (single != null) {
      deliverAction(result, from, single, exception);
    }

    if (hasMultiple) {
      //noinspection ForLoopReplaceableByForEach
      for (int i = 0, n = joined.size(); i < n; i++) {
        Action join = joined.get(i);
        deliverAction(result, from, join, exception);
      }
    }

    if (listener != null && exception != null) {
      listener.onImageLoadFailed(this, uri, exception);
    }
  }

那我们再开看看分发deliverAction方法吧

 private void deliverAction(Bitmap result, LoadedFrom from, Action action, Exception e) {
    if (action.isCancelled()) {
      return;
    }
    if (!action.willReplay()) {
      targetToAction.remove(action.getTarget());
    }
    if (result != null) {
      if (from == null) {
        throw new AssertionError("LoadedFrom cannot be null.");
      }
      action.complete(result, from);
      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_COMPLETED, action.request.logId(), "from " + from);
      }
    } else {
      action.error(e);
      if (loggingEnabled) {
        log(OWNER_MAIN, VERB_ERRORED, action.request.logId(), e.getMessage());
      }
    }
  }

这里没什么要讲得只是解决前面的判断问题吗，继续轮到ImageViewAction. complete

@Override public void complete(Bitmap result, Picasso.LoadedFrom from) {
  if (result == null) {
    throw new AssertionError(
        String.format("Attempted to complete action with no result!\n%s", this));
  }

  //得到target也就是ImageView
  ImageView target = this.target.get();
  if (target == null) {
    return;
  }

  Context context = picasso.context;
  boolean indicatorsEnabled = picasso.indicatorsEnabled;
  //通过PicassoDrawable来将bitmap设置到ImageView上
  PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

  //回调callback接口
  if (callback != null) {
    callback.onSuccess();
  }
}

• 判断target很简单，因为他是弱引用，有个能target到达这里已经被回收了
• PicassoDrawable.setBitmap方法吧bitmap设置给ImageView
• 调用成功的回调
  特别说一下PicassoDrawable负责入场动画，但是这里不深入
  到这里所以的流程都结束了

我们需要简化总接一下流程即：

创建->入队->执行->解码->变换->批处理->完成->分发->显示(可选)

• 创建：get()初始化配置，创建picassio，调用load（）创建RequestCreater
• 入队：在into中，RequestCreater创建request，通过request创建一个 Action即 一个完整的任务，交给picasso最后传给dispatcher的子线程，子线程找到对应的ReqestHandler，并打包Action 传给Hunter，最后把Hunter放入线程池入队
• 解码： 在线程池中，调用ReqestHandler的load方法尝试解码Action
• 变换： 拿到解码后的结果后判断是不是需要变换，如果需要就进行变化
• 批处理 ：将变换后的结果放入容器batch中，每隔0.2秒线程池就发送给dispatcher的子线程信息，子线程接收到信息后取出batch容器内容，并把它发送给主线程，主线程接受到对象逐个处理容器中每个hunter返回的结果
• 完成： 上面就会调用picasso.complete(hunter)方法:代表任务执行完成
• 分发： complete判断是不是需要分发如果需要就调用deliverAction(result, from, join);方法
• 显示 ： 上面任务就会调用action.complete(result, from); 根据action的不同调用对饮的显示方法

设计模式

建造者模式

建造者模式是指:将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式应该是我们都比较熟悉的一种模式,在创建AlertDialog的时候通过配置不同的参数就可以展示不同的AlertDialog,这也正是建造者模式的用途,通过不同的参数配置或者不同的执行顺序来构建不同的对象,在Picasso里当构建RequestCreator的时候正是使用了这种设计模式,我们通过可选的配置比如centerInside(),placeholder()等等来分别达到不同的使用方式,在这种使用场景下使用建造者模式是非常合适的.

责任链模式

责任链模式是指:一个请求沿着一条“链”传递，直到该“链”上的某个处理者处理它为止。当我们有一个请求可以被多个处理者处理或处理者未明确指定时。可以选择使用责任链模式,在Picasso里当我们通过BitmapHunter的forRequest()方法构建一个BitmapHunter对象时,需要为Request指定一个对应的RequestHandler来进行处理Request.这里就使用了责任链模式,依次调用requestHandler.canHandleRequest(request)方法来判断是否该RequestHandler能处理该Request如果可以就构建一个RequestHandler对象返回.这里就是典型的责任链思想的体现。

引用：Picasso源代码分析