最近聽聞現在用的較多的圖片載入框架是picasso，查了下picasso和okhttp是屬於同一個公司開發的，picasso在github現在的star量是13K+，看起來真的挺火的，因此決定對它的原始碼扒一扒。

研究原始碼之前首先的瞭解的它的使用方式，官網給的一個簡單例子如下：

Picasso.with(context).load("http://i.imgur.com/DvpvklR.png").into(imageView);

從Picass.with進入

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

發現picasso是一個懶載入單例模式；進入 Builder(context）方法

/** Start building a new {@link Picasso} instance. */
    public Builder(Context context) {
      if (context == null) {
        throw new IllegalArgumentException("Context must not be null.");
      }
      this.context = context.getApplicationContext();
    }
 

 /** Create the {@link Picasso} instance. */
    public Picasso build() {
      Context context = this.context;

      if (downloader == null) {
        downloader = Utils.createDefaultDownloader(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);
    }
  }
 

至此，picasso的初始化就完成了。整個picasso單例引用了一個全域性的ApplicationContext，當中初始化了以下幾個重要的元件：

1. downloader=UrlConnectionDownloader，負責網路請求。
   
2. cache=LruCache，記憶體快取（內部使用linkedHashMap），負責快取bitmap
   
3. service=PicassoExecutorService，一個執行緒池ExecutorService，負責以執行緒池的方式執行BitmapHunter
4. transformer = RequestTransformer.IDENTITY，為改善圖片載入速度使用，這兒要配置了cdn才有用
   
5.  dispatcher = new Dispatcher，負責排程圖片載入action進入service

ok，到這裡picasso的幾個重要元件就已經出場了。下面進入 Picass.load(String path)

 public RequestCreator load(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(Uri uri) {
    return new RequestCreator(this, uri, 0);
  }

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

通過一個uri構造一個RequestCreator，RequestCreator包含了一個對picasso和Request.Builder的引用。從Picasso和Request的初始化可以看到square公司對builder模式的喜愛。builder模式感覺可以叫設計模式中的建造者模式，builder模式的好處的是把物件的初始化交給builder類單獨處理，自己只負責和業務相關的邏輯，這樣避免了把很多的方法寫到一個類中，提高了程式碼的可讀性和已維護性。看過okhttp原始碼和retrofit原始碼的人應該知道，它們中的都大量的使用到了builder模式。

好了，此處稍微的跑偏了下，下面進入正題。RequestCreator建立好後，進入RequestCreator.into(ImageView target)

  public void into(ImageView target) {
    into(target, null);
  }

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

此處程式碼較多，不過業務邏輯不難。checkMain()檢測此處是否執行與主執行緒，然後檢查target是否為空，是空的話直接丟擲異常。一般情況下data.hasImage()等於true，deferred為false，因此這兩步跳過。接著根據RequestCreator中的data創建出一個request，再以request建立一個與之對應的requestKey，然後根據requestKey去cache中尋找是否有與之對應的bitmap，這裡是第一次載入，所以返回null。setPlaceholder預設是true，所以會首先會給target設定一個預設圖片，設定完預設圖片後，接著是把request以及一些相關的引數在做一層封裝得到一個ImageViewAction。  下面是這兩個類的成員圖，縮排的表示類屬性

ImageViewAction是對request的再次封裝。得到一個ImageViewAction，picasso.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);
  }

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

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

這段的作用其實就是讓picasso裡的dispatcher負責順序排程對ImageViewAction作再一次的封裝

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

  void performSubmit(Action action) {
    performSubmit(action, true);
  }

 void performSubmit(Action action, boolean dismissFailed) {
    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 = 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裡負責排程的是一個HandlerThread，也就是Dispatcher執行緒採用的是安卓特有的hanlder和looper輪詢機制，提高了Thread的使用效率。

pausedTags裡記錄的是對暫停的ImageViewAction的引用，這裡是第一次執行，pausedTags.contains(action.getTag())返回 false，hunterMap.get(action.getKey())也返回null，於是到了forRequest函式

  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的作用：由於圖片來源的方式有多種，可以是資源Id、contendProvider、資料流、asset中的檔案、本地檔案以及網路等，而不同的來源相應的載入方式也就不一樣，各種不同的RequestHandler就是解決從不同的地方載入圖片的。PIcasso初始化的時候就內建了一些常用的requestHandler儲存在requestHandlers集合中，如下

1. ResourceRequestHandler
   
2. ContactsPhotoRequestHandler
   
3. MediaStoreRequestHandler
   
4. ContentStreamRequestHandler
   
5. AssetRequestHandler
6. FileRequestHandler
7. NetworkRequestHandler  
   

從不同handler的名字我們基本就可以知道要何種handler，由於這裡請求的是網路地址，猜測應該是NetworkRequestHandler ，開啟NetworkRequestHandler 的canHandleRequest(Request data)方法

class NetworkRequestHandler extends RequestHandler {
  static final int RETRY_COUNT = 2;

  private static final String SCHEME_HTTP = "http";
  private static final String SCHEME_HTTPS = "https";

  @Override public boolean canHandleRequest(Request data) {
    String scheme = data.uri.getScheme();
    return (SCHEME_HTTP.equals(scheme) || SCHEME_HTTPS.equals(scheme));
  }

果真是NetworkRequestHandler ，在找到對應的RequestHandler之後，再對ImageViewAction做一層封裝，就得到了一個BitmapHunter，

返回到上一層，由於bitmapHunter繼承與runnable，因此可以交由service來執行，也就是圖片載入的任務是由執行緒池執行。

其實到這裡，圖片載入都還未真正開始，從RequestCreator-->Request--> ImageViewAction -->BitmapHunter,前面的都是對一個圖片載入任務的一層層封裝，為的是前期收集

足夠多的資訊以便後面解析bitmap然後設定到ImageView。

在bitmapHunter被提交到service（ExecuteService）後，就等待執行緒池排程執行它的run方法了

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

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

      result = hunt();

    

這一步沒什麼邏輯，直接看bitmapHunter的hunt方法

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

    data.networkPolicy = retryCount == 0 ? NetworkPolicy.OFFLINE.index : networkPolicy;
    RequestHandler.Result result = requestHandler.load(data, networkPolicy);
  

這裡再次檢查cache中是否存在與key對應的bitmap快取，這裡假設第一次載入，返回null。然後就是requestHandler.load(data, networkPolicy)，這裡的requestHandler是NetworkRequestHandler 

 @Override public Result load(Request request, int networkPolicy) throws IOException {
    Response response = downloader.load(request.uri, request.networkPolicy);
    if (response == null) {
      return null;
    }

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

    Bitmap bitmap = response.getBitmap();
    if (bitmap != null) {
      return new Result(bitmap, loadedFrom);
    }

    InputStream is = response.getInputStream();
    if (is == null) {
      return null;
    }
    // Sometimes response content length is zero when requests are being replayed. Haven't found
    // root cause to this but retrying the request seems safe to do so.
    if (loadedFrom == DISK && response.getContentLength() == 0) {
      Utils.closeQuietly(is);
      throw new ContentLengthException("Received response with 0 content-length header.");
    }
    if (loadedFrom == NETWORK && response.getContentLength() > 0) {
      stats.dispatchDownloadFinished(response.getContentLength());
    }
    return new Result(is, loadedFrom);
  }

NetworkRequestHandler 裡接著又呼叫download.load方法，download是UrlConnectionDownloader

@Override public Response load(Uri uri, int networkPolicy) throws IOException {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
      installCacheIfNeeded(context);
    }

    HttpURLConnection connection = openConnection(uri);
    connection.setUseCaches(true);

    if (networkPolicy != 0) {
      String headerValue;

      if (NetworkPolicy.isOfflineOnly(networkPolicy)) {
        headerValue = FORCE_CACHE;
      } else {
        StringBuilder builder = CACHE_HEADER_BUILDER.get();
        builder.setLength(0);

        if (!NetworkPolicy.shouldReadFromDiskCache(networkPolicy)) {
          builder.append("no-cache");
        }
        if (!NetworkPolicy.shouldWriteToDiskCache(networkPolicy)) {
          if (builder.length() > 0) {
            builder.append(',');
          }
          builder.append("no-store");
        }

        headerValue = builder.toString();
      }

      connection.setRequestProperty("Cache-Control", headerValue);
    }

    int responseCode = connection.getResponseCode();
    if (responseCode >= 300) {
      connection.disconnect();
      throw new ResponseException(responseCode + " " + connection.getResponseMessage(),
          networkPolicy, responseCode);
    }

    long contentLength = connection.getHeaderFieldInt("Content-Length", -1);
    boolean fromCache = parseResponseSourceHeader(connection.getHeaderField(RESPONSE_SOURCE));

    return new Response(connection.getInputStream(), fromCache, contentLength);
  }

UrlConnectionDownloader首先判斷系統版本，如果系統版本>=4.0就在記憶體中簡歷http快取。然後就是根據uri開啟一個HttpURLConnection，設定相應的請求頭，然後從connection獲取輸入流，內容長度，最後封裝成一個Response返回到上一層

Response返回到NetworkRequestHandler 的load方法。由於這裡返回的Response的bitmap為null，因此在NetworkRequestHandler裡又是把Response中的stream在封裝成Result返回到上一層。

Result返回到BitmapHunter的hunt方法，這裡再看hunt方法的下部分

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

由於返回的result在請求成功的情況下不為空，但是result裡的bitmap為null，因此會呼叫decodeStream(is, data)方法，該方法的作用是根據target的寬高來把is解析成bitmap，
後面bitmap還要request的要求做旋轉、縮放、居中等操作，然後bitmap返回到上一層BitmapHunter的run方法，看run方法下部分

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

假設這裡請求成功，result不為空，至此圖片請求成功並且解析成了bitmap，接下來的事就是把bitmap設定到ImageView中了。由於安卓中操作UI需要在UI執行緒中執行，因此這裡又用到了Dispatcher，由Dispatcher傳送通知告知此BitmapHunter已經解析結束，然後把此BitmapHunter加到barch集合中，然後再通過主執行緒handler告知主執行緒執行最後的ImageView設定bitmap工作，也就是最後呼叫ImageViewAction的complete方法

class ImageViewAction extends Action<ImageView> {

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

    ImageView target = this.target.get();
    if (target == null) {
      return;
    }

    Context context = picasso.context;
    boolean indicatorsEnabled = picasso.indicatorsEnabled;
    PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

    if (callback != null) {
      callback.onSuccess();
    }
  }

至此，bitmap就顯示到ImageView上了，也就是圖片載入成功了。

ok，最後我們來理一下picasso幾個重要的元件類關係圖

總結：

Picasso預設簡單的請求載入下是不會對大圖縮放的，即載入大圖的話消耗的記憶體很多，所以如果在載入很多大圖的情況下建議要主動resize已防止oom，如下

Picasso.with(this).load("uri").resize(50,50).centerCrop().config(Bitmap.Config.ARGB_8888).into(view)。

Picasso使用執行緒池執行網路請求，1個執行緒負責排程，主執行緒Handler負責排程每隔200毫秒一次顯示view。它的requestHandler採用有點類似介面卡的方式，使開發者可以實現自己的requestHandler，picasso各元件職責單一，使程式碼耦合度低，具有高可擴充套件性，很值得學習。