寫在之前

原本打算是每周更新一篇博文，同時記錄一周的生活狀態，但是稍微工作忙一點就顧不上寫博客了。悲催
還是說下最近的狀況，最近兩周一直在接公司申請的計費點， 沃商店，銀貝殼，微信等等，然後就是不停的被人催促催促，真是一個頭兩個大。在這期間項目組還搞了個App會員登錄系統，接受第三方登錄，然後應用到現有的App當中，然後又是一陣狂Coding。
說道第三方登錄，那必然會包含第三方用戶信息，比如頭像，昵稱等，原本項目中就使用了Picasso框架，之前也沒有太深入的研究它，藉此機會就認真的研究了一下它的源碼實現，由此產生了這篇博文。

正文

說到Picasso，相信Android開發人員絕不陌生，它是Square公司開發的一款圖片載入神器。使用過它的coder絕對是愛不釋手：對它本身而言，輕量安全，有效載入圖片並防止OOM；對我們開發者來說，簡單方便，一行代碼搞定圖片載入。因此它備受Android開發人員的鐘愛。

關於它的更多好處優點，相信不用我介紹你也非常的清楚，在這裡我們廢話不多說，直接的進入主題來講解它的使用和從源碼的角度解析它的載入原理。

Picasso基本使用

一 工程引入

在我們的項目build.gradle中添加對Picasso框架的依賴：

compile 'com.squareup.picasso:picasso:2.5.2'

在這裡我使用的是2.5.2的最新版本。

二 添加許可權

因為載入圖片需要訪問網路，由此我們在Manifest中添加訪問網路的許可權：

<uses-permission android:name="android.permission.INTERNET"/>

三 創建載入圖片佈局文件

在我們的MainActivity的佈局文件中添加一個Button和一個ImageView：

四 MainActivity中點擊載入圖片

在這裡我們點擊Button讓它載入一張百度Logo的圖片並顯示在ImageView控制項中。

五 載入圖片

點擊Button載入圖片，來看結果：

ok，已載入出來了，但是我們到底做了什麼呢？

基本載入

其實我們所做的事情非常的簡單，那就是在Button的點擊事件中添加一行代碼：

Picasso.with(MainActivity.this).load(url).into(headerImage);

沒錯就是一行代碼搞定圖片載入。至於它是怎麼實現的，我們會在後面的源碼分析中詳細的解析它，現在來看看它的其他使用。

占點陣圖

不光載入圖片是非常簡單的事情，而且還可以在載入過程中使用占點陣圖，可以很友好的告訴用戶它正在載入，而不是載入中顯示空白的界面。

Picasso.with(MainActivity.this)
.load(url)
.placeholder(R.mipmap.ic_launcher)
.into(headerImage);

使用placeholder為尚未載入到圖片的ImageView設置占點陣圖，這是一種友好的顯示方式。

異常圖

不光可以設置占點陣圖，而且還可以在圖片載入不出來，或是找不到要載入的圖片後，可以為ImageView設置異常圖：

Picasso.with(MainActivity.this)
       .load(url)
       .placeholder(R.mipmap.ic_launcher)
       .error(R.drawable.error)
       .into(headerImage);

使用error可以為載入異常的ImageView設置異常圖，修改我們的圖片URL，使它無法獲取到正確的圖片地址，然後來看結果：

轉換器

不僅如此，我們還可以對載入到的圖片進行重新調整，比如改變圖片的大小，顯示形狀等，可以使用transform方法，例如：

首先我們先自定義一個Transformation：

 private class customTransformer implements Transformation{

        @Override
        public Bitmap transform(Bitmap source) {
            //在這裡可以對Bitmap進行操作，比如改變大小，形狀等

            return source;
        }
        @Override
        public String key() {
            return null;
        }
    }

然後在transform方法中進行處理：

 Picasso.with(MainActivity.this)
        .load(url)
        .placeholder(R.mipmap.ic_launcher)
        .transform(new customTransformer())
        .error(R.drawable.error)
        .into(headerImage);

這樣的話就可以對圖片進行一定意義上的控制和選擇，使它更加符合我們的需求。

當然Picasso中還有很多其他的應用，比如可以設置載入大小，使用resizeDimen方法，填充方式使用centerCrop，fit等等，大家如果有需要的話可以自己嘗試使用。這裡就不要一一的介紹了。

Picasso 源碼解析

ok，上面介紹了Picasso的部分基礎使用，非常的簡單，一行代碼搞定你的所需，那麼下麵我們從源碼的角度來解析下它到底是怎麼實現我們的圖片載入和使用的。

以下麵最簡潔的載入為示例：

Picasso.with(MainActivity.this).load(url).into(headerImage);

with

首先Picasso會調用靜態with方法，那麼我們來看看with方法是怎麼實現的：

由上面的源碼我們可以看到，在with方法中主要做了一件事，那就是返回一個Picasso實例，當然這個實例也不是那麼簡單的創建的，為了防止Picasso的多次創建，這裡使用了雙重加鎖的單例模式來創建的，主要目的是為了保證線程的安全性。但是它又不是直接的使用單例模式創建的，在創建實例的過程中使用了Builder模式，它可以使Picasso在創建時初始化很多對象，以便後期使用，那麼我們就來看看這個Builder是怎麼操作的：

在Builder的構造方法中就只是獲取到當前應用級別的上下文，也就說明瞭Picasso是針對應用級別的使用，不會是隨著Activity或是Fragment的生命周期而產生變化，只有噹噹前的應用退出或是銷毀時Picasso才會停止它的行為。

那麼接下來看下build方法中做了哪些操作呢：

這裡代碼也是很簡單，主要是初始化了downloader，cache，service，dispatcher等幾個實例變數，而這幾個變數值也是已設置的：

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

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

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

    ...

這些設置就像我們平常使用AlertDialog一樣，貨到到Builder之後分別進行設置就行。

ok，我們現在來看看初始化中幾個非常重要的變數：

downloader 下載器

首先看下downloader，builder中首先判斷downloader是否為空值，當為空值時就為它初始化預設值，如：

if (downloader == null) {
        downloader = Utils.createDefaultDownloader(context);
}

來看下Utils中是怎麼實現downloader 的初始化的：

createDefaultDownloader方法中首先使用java反射機制來查找項目中是否使用了okhttp網路載入框架，如果使用了則會使用okhttp作為圖片的載入方式，如果沒有使用，則會使用內置的封裝載入器UrlConnectionDownloader。

註：由於okhttp3的包名已更換，所以在這裡都是使用內置的封裝下載器，這個是一個小bug等待完善。當修複之後Picasso+okhttp3則是最理想的載入方式。

service 線程池

同樣的使用，首先判斷是否為空，如果為空則初始化預設對象：

if (service == null) {
    service = new PicassoExecutorService();
}

我們在來看看PicassoExecutorService的源碼：

PicassoExecutorService直接繼承與ThreadPoolExecutor線程池，在構造方法中初始化了主線程大小，最大線程等，如：

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;

當然，在Picasso線程池中主線程和最大線程數是可變的，根據用戶使用的網路類型來設置線程數量，後面會詳細說明它的應用。

dispatcher 事務分發器

dispatcher 在Picasso中扮演著十分重要的角色，可以說它是整個圖片載入過程中的中轉站，主線程和子線程來回的切換主要都是依賴它的存在。下麵我們將來仔細的研究下它的設計，理解好它的存在對整個Picasso框架的理解也基本明朗。

首先，來看看它的登場亮相：

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

它的登場就是創建一個Dispatcher 對象實例，當然，它傳遞了在Builder中所初始化的對象實例，比如downloader下載器，用於圖片的下載，當然下載是不能再主線程進行的，所以這裡也傳遞了service線程池，而下載好的資源也是不能直接在子線程中進行更新UI的，所以同時也把主線程中的HANDLER傳遞進去，同時應用級別的上下文context，和緩存cache，狀態變化stats等也傳遞進去進行相對應的業務操作。

經過上面的分析，我們可以很清楚的看出，就這麼簡單的一個創建實例已經很明確的表達出了Dispatcher存在的意義，而且我們也明確了它大概的職責。

那麼我們接著看看Dispatcher的構造方法中具體的做了哪些操作：

在Dispatcher的構造方法中我把它分為了5個部分，下麵來詳細的解析下：

①：dispatcherThread，它是一個HandlerThread線程，如：

 static class DispatcherThread extends HandlerThread {
    DispatcherThread() {
      super(Utils.THREAD_PREFIX + DISPATCHER_THREAD_NAME, THREAD_PRIORITY_BACKGROUND);
    }
  }

它的創建主要是開啟一個子線程供Dispatcher調用，目的就是為了在子線程中去執行耗時的圖片下載操作。

②：對象實例的接受，主要是接受在Picasso中初始化的對象實例，這個沒有什麼好說的。

③：創建用於保存數據、對象的集合，也就是為了保存對象或狀態用的。

④：DispatcherHandler，這是一個Handler，並且是作用在dispatcherThread線程中的Handler，它用於把在dispatcherThread子線程的操作轉到到Dispatcher中去，它的構造方法中接受了Dispatcher對象：

我們在來看看他的handleMessage方法是怎麼處理消息的：

@Override public void handleMessage(final Message msg) {
      switch (msg.what) {
        case REQUEST_SUBMIT: {
          Action action = (Action) msg.obj;
          dispatcher.performSubmit(action);
          break;
        }
        case REQUEST_CANCEL: {
          Action action = (Action) msg.obj;
          dispatcher.performCancel(action);
          break;
        }
        case TAG_PAUSE: {
          Object tag = msg.obj;
          dispatcher.performPauseTag(tag);
          break;
        }
        case TAG_RESUME: {
          Object tag = msg.obj;
          dispatcher.performResumeTag(tag);
          break;
        }
        case HUNTER_COMPLETE: {
          BitmapHunter hunter = (BitmapHunter) msg.obj;
          dispatcher.performComplete(hunter);
          break;
        }
        case HUNTER_RETRY: {
          BitmapHunter hunter = (BitmapHunter) msg.obj;
          dispatcher.performRetry(hunter);
          break;
        }
        case HUNTER_DECODE_FAILED: {
          BitmapHunter hunter = (BitmapHunter) msg.obj;
          dispatcher.performError(hunter, false);
          break;
        }
        case HUNTER_DELAY_NEXT_BATCH: {
          dispatcher.performBatchComplete();
          break;
        }
        case NETWORK_STATE_CHANGE: {
          NetworkInfo info = (NetworkInfo) msg.obj;
          dispatcher.performNetworkStateChange(info);
          break;
        }
        case AIRPLANE_MODE_CHANGE: {
          dispatcher.performAirplaneModeChange(msg.arg1 == AIRPLANE_MODE_ON);
          break;
        }
        default:
          Picasso.HANDLER.post(new Runnable() {
            @Override public void run() {
              throw new AssertionError("Unknown handler message received: " + msg.what);
            }
          });
      }
    }

而從它的處理消息的handleMessage中我們可以看出，所有的消息並沒有被直接進行處理而是轉移到了dispatcher中，在dispatcher中進行相應的處理。

⑤：監聽網路變化操作，它是用於監聽用戶手機網路變化而存在的。我們主要來看看NetworkBroadcastReceiver這個類：

在構造參數中也接收到Dispatcher對象，並有註冊廣播和銷毀廣播的方法，當然它也沒有直接的處理，也是傳遞到Dispatcher中進行消化的。

我們在來看看當用戶的網路發生變化時，它會做哪些操作：

我們可以看到主要分為兩個，一個是航班模式，一個是正常的網路狀態變化，航班模式我們先不用理會，主要看下網路變化的操作：

void dispatchNetworkStateChange(NetworkInfo info) {  
         handler.sendMessage(handler.obtainMessage(NETWORK_STATE_CHANGE, info));
}

這裡的handler就是DispatcherHandler，那麼我們看看它又是怎麼做的：

 case NETWORK_STATE_CHANGE: {
          NetworkInfo info = (NetworkInfo) msg.obj;
          dispatcher.performNetworkStateChange(info);
          break;
        }

調用dispatcher的performNetworkStateChange方法來處理：

當網路變化時，它會傳遞給我們的PicassoExecutorService線程池，在adjustThreadCount方法中判斷用戶是使用的那類型網路，如wifi，4G等，然後為線程池設置相應的線程數。來看：

  void adjustThreadCount(NetworkInfo info) {
    if (info == null || !info.isConnectedOrConnecting()) {
      setThreadCount(DEFAULT_THREAD_COUNT);
      return;
    }
    switch (info.getType()) {
      case ConnectivityManager.TYPE_WIFI:
      case ConnectivityManager.TYPE_WIMAX:
      case ConnectivityManager.TYPE_ETHERNET:
        setThreadCount(4);
        break;
      case ConnectivityManager.TYPE_MOBILE:
        switch (info.getSubtype()) {
          case TelephonyManager.NETWORK_TYPE_LTE:  // 4G
          case TelephonyManager.NETWORK_TYPE_HSPAP:
          case TelephonyManager.NETWORK_TYPE_EHRPD:
            setThreadCount(3);
            break;
          case TelephonyManager.NETWORK_TYPE_UMTS: // 3G
          case TelephonyManager.NETWORK_TYPE_CDMA:
          case TelephonyManager.NETWORK_TYPE_EVDO_0:
          case TelephonyManager.NETWORK_TYPE_EVDO_A:
          case TelephonyManager.NETWORK_TYPE_EVDO_B:
            setThreadCount(2);
            break;
          case TelephonyManager.NETWORK_TYPE_GPRS: // 2G
          case TelephonyManager.NETWORK_TYPE_EDGE:
            setThreadCount(1);
            break;
          default:
            setThreadCount(DEFAULT_THREAD_COUNT);
        }
        break;
      default:
        setThreadCount(DEFAULT_THREAD_COUNT);
    }
  }

  private void setThreadCount(int threadCount) {
    setCorePoolSize(threadCount);
    setMaximumPoolSize(threadCount);
  }

就如上面所說，根據用戶使用不同的網路類型分別設置線程的數量，比如當用戶使用的是wifi，線程數量將會設置為4個，4G的話設為3個等，這樣根據用戶的具體情況來設計線程數量是非常人性化的，也是值得我們效仿的。

ok，到此我們重要的Dispatcher對象的構造方法已完全的解析完成了，從上面的解析中我們很清楚的看到了Dispatcher作為中轉站存在的意義，幾乎所有的線程轉換操作都是由Dispatcher來操控的，當然可能還有小伙伴們並不清楚它是怎麼運作的，怎麼進入子線程的，那是因為我們的講解還沒有進行到進入子線程的步驟而已，下麵將會進一步的講解。

總結下Dispatcher中所包含的重要對象實例：

①：PicassoExecutorService線程池
②：downloader 下載器
③：針對DispatcherThread線程的DispatcherHandler處理器
④：NetworkBroadcastReceiver網路監聽器
⑤：mainThreadHandler主線程的Handler
⑥：保存數據的集合：hunterMap，pausedActions，batch等

理解好了上面這些對象存在的意義將對下麵的理解有著巨大的好處，請沒有完全理解的在仔細的閱讀一遍（非常重要）。

ok，知道了Dispatcher包含哪些重要的對象實例之後，讓我們再回到Picasso的Builder中，在build方法中最終返回的是一個Picasso的對象實例：

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

在Picasso的構造方法中值得我們只要註意的是針對requestHandlers的應用：

這裡把Picasso能都應用的RequestHandler都添加到集合中，然後根據具體的需求運用相對應的Handler進行業務的處理。

ok，到此Picasso中with方法中所做的事情已經完完全全的展示在您的面前了，相信您對這一步應用理解的很透徹了。

那麼來總結下，Picasso現在擁有了那些重要的對象實例：

①：dispatcher，重要性不言而喻，上面已充分的展示了它的重要性，作為中轉站，Picasso是必須要擁有了的。最終目的是讓我們的主線程進入子線程中去進行耗時的下載操作。

②：requestHandlers，它的存在是為了選擇一種請求處理方式，比如說，下載網路圖片需要使用NetworkRequestHandler這個請求器。

③：HANDLER，這是主線程的Handler，用來處理返回結果的，比如說圖片下載成功後要更新UI就是通過它來完成的，這會在後面圖片下載完成後更新UI時詳細講解

④：一些配置對象實例等，如：緩存cache，圖片載入預設配置defaultBitmapConfig，狀態存儲stats等等。

load

with方法中主要是做了一個基礎的配置工作，比如Picasso的配置，Dispatcher的配置，這些都是非常重要的前提工作，只有做好了這些配置我們使用起來才能顯得毫不費勁。

下麵我們就來看看它的應用吧。在load方法中需要我們傳遞一個參數，這個參數可以是Url，可以是一個path路徑，也可以是一個文件，一個資源佈局等：

①：url
public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
}

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

③：file
public RequestCreator load(File file) {
    if (file == null) {
      return new RequestCreator(this, null, 0);
    }
    return load(Uri.fromFile(file));
}

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

不管傳遞的是一個什麼參數，它都是返回一個請求構造器RequestCreator，我們來看看它的構造方法做了哪些事情：

主要是獲取到Picasso對象，並Builder模式構建一個Request中的Builder對象：

Builder(Uri uri, int resourceId, Bitmap.Config bitmapConfig) {
      this.uri = uri;
      this.resourceId = resourceId;
      this.config = bitmapConfig;
    }

這個Builder對象主要接受了一些參數信息，包括url，資源佈局，和預設的圖片配置。

由於load方法返回的是一個RequestCreator對象，所以我們可以使用方法鏈的形式進行調用其他的方法，比如給請求添加占點陣圖，異常圖，轉換器等等，具體的可以看源碼。

ok，總體來說這load方法中主要是創建了一個RequestCreator對象，並且RequestCreator中構造了一個Request.Builder對象。

那麼來看看RequestCreator擁有哪些重要的對象實例：

①：picasso對象
②：Request.Builder對象實例data，它裡面包括我們請求的URL地址，資源文件以及圖片預設配置。

into

在load方法中主要創建了一個RequestCreator對象，並獲取到了要載入的url/path/file/resourceId資源地址路徑，那麼接下來要做的就是在into方法中來載入圖片了。先來看看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);
  }

如上源碼可以知道into還是做了很多的事情，下麵一一解析：

①：checkMain()：首先檢查主否在主線程運行，如果不是在主線程就會拋出一個應該在主線程運行的異常：throw new IllegalStateException("Method call should happen from the main thread.");這說明到這一步還是在主線程運行的。

②：data.hasImage()：這裡的data是在之前初始化的Request.Builder對象，它裡面包含url地址，resourceId和預設配置，這裡是判斷uri或resourceId是否為空為0，如果是的話就取消imageview的請求：picasso.cancelRequest(target);

③：deferred：延遲，如果需要延遲的話就會得到執行，然後會去獲取data中圖片的大小，如果沒有的話，就得到target的寬高來重新設置要載入的圖片的尺寸：data.resize(width, height);

④：createRequest：在data.build()方法中創建Request對象，該對象將會包含uri或resourceId以及預設圖片config。然後在得到的Request對象後進行轉換，該轉換主要是與我們在Picasso構建時是否自定義了RequestTransformer有關。

⑤：createKey：它主要的是返回已String類型key，主要目的是建立ImageView和key的關聯，可以通過key來獲取到Imageview的狀態，比如說是否已緩存

⑥：shouldReadFromMemoryCache：看方法名也能知道，它的作用是是否從記憶體緩存中讀取數據，如果是的話，就從緩存中讀取數據，假如獲取到數據則會取消當前ImageView的請求並直接給它設置Bitmap，而且如果有回調的話將會回調成功的方法。

⑦：ImageViewAction：構建一個ImageViewAction對象，值得註意的是在構建對象時，會把ImageView添加到RequestWeakReference進行存儲，以便於使用時查找，RequestWeakReference是一個WeakReference類型的弱引用。同時ImageViewAction也是在完成圖片載入時真正更新UI的關鍵類，這在後面會進行詳細講解。

⑧：enqueueAndSubmit：調用picasso的enqueueAndSubmit方法進行提交任務。

在來看submit方法的操作：

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

在這裡再次使用到了dispatcher任務分發器，把我們的任務action提交到Dispatcher中進行處理。然後在來看下dispatchSubmit方法：

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

由Dispatcher的構造方法我們可以知道此時的handler是DispatcherHandler，那麼我們看下它是怎麼處理我們的任務行為的：

 case REQUEST_SUBMIT: {
          Action action = (Action) msg.obj;
          dispatcher.performSubmit(action);
          break;

在handleMessage中直接獲取到我們的任務行為Action，然後調用performSubmit方法：

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

performSubmit方法是真正意義上的任務提交的具體地方，我們來解讀下它的源碼：

①：首先根據action的標誌來查詢是否已存在於暫停列表中，如果存在將會把action存放到pausedActions的集合列表中，以便等待喚醒請求。

②：然後通過action的key從hunterMap集合中查詢是否已存在該hunterMap的請求項，如果存在將會調用hunter的attach方法，進行合併請求，避免一個ImageView進行多次的重覆請求：

把action存放到ArrayList當中，如果有相同的action根據ArrayList的不重覆性將會保存一個action，並且更新新的屬性值priority。

③：當線程池service沒有關閉的時候，通過forRequest方法獲取一個Runnable類型的BitmapHunter線程，來看下forRequest的源碼：

分別從action和picasso獲取到Request請求和所有的requestHandlers請求處理器，然後遍歷所有的請求器獲取每一個請求處理器，調用canHandleRequest嘗試看是否該處理器能夠處理，來看下canHandleRequest方法：

public abstract boolean canHandleRequest(Request data);

它是一個抽象方法，需要到子類去查找，而實現它的子類都是根據以下的約束條件來判斷是否可以處理該請求的：

String scheme = data.uri.getScheme();

也就是說通過url地址的Scheme約束條件進行判斷的，而以我們現在的action中的Request獲取到url，是以http/https開頭的，那麼來看下NetworkRequestHandler中的canHandleRequest源碼：

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處理器。

匹配好了請求處理器，將會返回一個BitmapHunter的線程，獲取到線程之後會線上程池進行開啟線程，並把該線程存放到hunterMap線程集合中以便多次請求可以合併相同的線程：

    hunter.future = service.submit(hunter);
    hunterMap.put(action.getKey(), hunter);

ok，現在可以到我們的線程池PicassoExecutorService中看看它到底是怎麼執行的，submit源碼如下：

@Override
  public Future<?> submit(Runnable task) {
    PicassoFutureTask ftask = new PicassoFutureTask((BitmapHunter) task);
    execute(ftask);
    return ftask;
  }

用把我們的線程task封裝到PicassoFutureTask 中，PicassoFutureTask 是一個更便於我們控住處理的線程，然後調用execute開啟線程，之後會把我們的線程轉移到addWorker方法中，在addWorker中開啟線程start：

boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }

上述源碼是執行在ThreadPoolExecutor線程池中的，可以看下源碼。

當線程開啟後，在哪執行呢？

我們知道我們的封裝的線程最初始的是BitmapHunter，那麼我們就到它裡面來看看是怎麼執行的：

在BitmapHunter的run方法中，先修改線程名稱，然後執行hunt方法，把執行結果存放到result中，那我們先看看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);
    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;
  }

解析下源碼：

①：還是首先獲取到action行為對應key，通過key從緩存cache中查找bitmap是否存在，如果存在修改stats狀態並直接的把bitmap返回。

②：如果緩存中不存在則是要去網路載入requestHandler.load();我們通過上面的分析知道能處理當前requesr的requestHandler是NetworkRequestHandler，那麼我們去NetworkRequestHandler的load方法中查看：

這裡很清晰的可以看到是直接調用downloader的load方法，而我們的downloader在Picasso構建Builder的時候也很清晰的說明是UrlConnectionDownloader，那麼在去UrlConnectionDownloader的load方法看看：

protected HttpURLConnection openConnection(Uri path) throws IOException {
    HttpURLConnection connection = (HttpURLConnection) new URL(path.toString()).openConnection();
    connection.setConnectTimeout(Utils.DEFAULT_CONNECT_TIMEOUT_MILLIS);
    connection.setReadTimeout(Utils.DEFAULT_READ_TIMEOUT_MILLIS);
    return connection;
  }

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

這裡的代碼相信我們都很熟悉，就是構建一個HttpURLConnection 去進行網路請求，當然還有就是根據networkPolicy進行一些網路緩存的策略。最後把結果存放到Response對象中。

然後NetworkRequestHandler的load方法又會從Response對象中獲取數據，並把它存放到Result對象中。然後返回給BitmapHunter中hunt方法的RequestHandler.Result result中，從result中獲取輸入流，解析輸入流轉化為Bitmap並返回。

到此我們已從網路中下載了數據，並轉化為bitmap了，然後在返回我們的BitmapHunter中的run方法中，在run方法中我們獲取到了bitmap，然後調用dispatcher進行事物分發，成功獲取則調用dispatchComplete，否則調用dispatchFailed。

下麵我們看看dispatcher中的dispatchComplete方法：

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

同樣的道理，這裡的handler還是DispatcherHandler，那麼來看看它的處理：

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

轉到dispatcher的performComplete方法中：

這裡首先把我們的結果保存在cache緩存中，然後從hunterMap集合中移除BitmapHunter對應的key，原因是請求已完成。然後調用 batch(hunter);方法：

首先判斷BitmapHunter是否已取消，然後把BitmapHunter存放在一個List< BitmapHunter > batch集合中，最後通過DispatcherHandler發送一個空的延遲消息，目的是為了延遲下下一個網路載入以便處理當前的bitmap工作，來看下它是怎麼處理的：

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

進入performBatchComplete中查看：

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

performBatchComplete中首先獲取存放BitmapHunter的集合，然後調用mainThreadHandler發送消息。

還記得mainThreadHandler是怎麼嗎？

在Picasso類中構建Builder的build方法中，創建一個Dispatcher對象，裡面傳進一個HANDLER的參數，請看：

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

這個HANDLER就是mainThreadHandler。

那麼它發送的消息是怎麼處理的呢？

獲取到BitmapHunter集合進行遍歷，然後直接調用Picasso中的complete方法：

void complete(BitmapHunter hunter) {
    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);
    }

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

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

在complete方法中，直接從BitmapHunter中獲取原已封裝的Action，Uri，Bitmap等等數據信息，然後調用deliverAction方法：

這裡進行一系列的判斷，當action沒有取消，並且Bitmap不為空時，將會調用action.complete(result, from);來完成操作。

那還記得我們在創建action時的操作嗎？

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

那麼很清晰的就知道我們的Action 其實就是ImageViewAction呢

那麼我們來看下ImageViewAction的complete是怎麼操作的呢？

target就是我們在創建ImageViewAction時傳遞的ImageView，現在獲取到它，然後調用PicassoDrawable.setBitmap方法來完成設置圖片：

當我們看到target.setImageDrawable(drawable);時，是不是終於鬆了一口氣呢，終於看到了為ImageView設置圖片的信息了。

好了，到了這一步整個Picasso載入圖片的源碼執行流程就已完全的解析完畢了，相信您可以非常清楚的瞭解了整個框架的載入過程，同時我也相信可能很少人能做到我這麼詳細的完完全全的分析整個執行過程，而且整個過程中並沒有給大家留下什麼盲點，是真真正正的源碼大解析。

各位如果還有哪裡不明白的，或是我這裡講的還不夠透徹，亦或是講錯了的地方請留言指正，讓我們共同進步，謝謝

同時，請大家掃一掃關註我的微信公眾號，雖然寫的不是很勤，但是每一篇都有質量保證，讓您學習到真正的知識。