圖片加載框架Picasso －源碼分析

時間 2019-11-29

標籤圖片加載框架 picasso 源碼分析简体版

原文原文鏈接

簡書：圖片加載框架Picasso －源碼分析 java

前一篇文章講了Picasso的詳細用法，Picasso 是一個強大的圖片加載緩存框架，一個很是優秀的開源庫，學習一個優秀的開源庫，,咱們不只僅是學習它的用法，停留在使用API層面，咱們也要試着去閱讀源碼，有兩個方面的緣由，第一，熟悉了源碼咱們才能更好的駕馭，項目中作咱們須要的定製。第二，學習它的設計思想、編碼風格、代碼的架構，而後在項目中對這些好的思想和架構加以實踐，變成本身的知識，這樣纔會對咱們有更多的提高和幫助。這也是咱們學習的目的，所以這篇文章對Picasso 的源碼和流程作一個分析。android

1、Picasso 加載圖片流程圖

上面就是Picasso加載圖片的流程，圖畫的醜，各位見諒。api

2、重要的類介紹

（0）Picasso: 圖片加載、轉換、緩存的管理類。單列模式，經過with方法獲取實例，也是加載圖片的入口。
（1）RequestCreator: Request構建類，Builder 模式，採用鏈式設置該Request的屬性(如佔位圖、緩存策略、裁剪規則、顯示大小、優先級等等)。最後調用build()方法生成一個請求（Request）。
（2）DeferredRequestCreator:RequestCreator的包裝類,當建立請求的時候還不能獲取ImageView的寬和高的時候，則建立一個DeferredRequestCreator，DeferredRequestCreator裏對 target 設置監聽，直到能夠獲取到寬和高的時候從新執行請求建立。
（3） Action: 請求包裝類，存儲了該請求和RequestCreator設置的這些屬性，最終提交給線程執行下載。
（4）Dispatcher:分發器，分發執行各類請求、分發結果等等。
（5）PicassoExecutorService:Picasso使用的線程池，默認池大小爲3。
（6）LruCache:一個使用最近最少使用策略的內存緩存。
（7）BitmapHunter:這是Picasso的一個核心的類，開啓線程執行下載，獲取結果後解碼成Bitmap,而後作一些轉換操做如圖片旋轉、裁剪等，若是請求設置了轉換器Transformation,也會在BitmapHunter裏執行這些轉換操做。
（8）NetworkRequestHandler:網絡請求處理器，若是圖片須要從網絡下載，則用這個處理器處理。
（9）FileRequestHandler:文件請求處理器，若是請求的是一張存在文件中的圖片，則用這個處理器處理。
（10）AssetRequestHandler: Asset 資源圖片處理器，若是是加載asset目錄下的圖片，則用這個處理器處理。
（11）ResourceRequestHandler:Resource資源圖片處理器，若是是加載res下的圖片，則用這個處理器處理。
（12）ContentStreamRequestHandler: ContentProvider 處理器，若是是ContentProvider提供的圖片，則用這個處理器處理
（13）MediaStoreRequestHandler: MediaStore 請求處理器，若是圖片是存在MediaStore上的則用這個處理器處理。
（14）ContactsPhotoRequestHandler:ContactsPhoto 請求處理器，若是加載com.android.contacts/ 下的tu圖片用這個處理器處理。如：緩存

// e.g. content://com.android.contacts/contacts/38)
//匹配的路徑以下：
static {
    matcher = new UriMatcher(UriMatcher.NO_MATCH);
    matcher.addURI(ContactsContract.AUTHORITY, "contacts/lookup/*/#", ID_LOOKUP);
    matcher.addURI(ContactsContract.AUTHORITY, "contacts/lookup/*", ID_LOOKUP);
    matcher.addURI(ContactsContract.AUTHORITY, "contacts/#/photo", ID_THUMBNAIL);
    matcher.addURI(ContactsContract.AUTHORITY, "contacts/#", ID_CONTACT);
    matcher.addURI(ContactsContract.AUTHORITY, "display_photo/#", ID_DISPLAY_PHOTO);
  }複製代碼

上面8-14 是默認的提供的幾個處理器，分別處理不一樣來源的請求。網絡

（15）Response: 返回的結果信息，Stream流或者Bitmap。
（16）Request: 請求實體類，存儲了應用在圖片上的信息。
（17）Target:圖片加載的監聽器接口，有3個回調方法，onPrepareLoad 在請求提交前回調，onBitmapLoaded 請求成功回調，並返回Bitmap,onBitmapFailed請求失敗回調。
（18）PicassoDrawable:繼承BitmapDrawable，實現了過渡動畫和圖片來源的標識（就是圖片來源的指示器，要調用 setIndicatorsEnabled(true)方法才生效），請求成功後都會包裝成BitmapDrawable顯示到ImageView 上。
（19）OkHttpDownloader:用OkHttp實現的圖片下載器，默認就是用的這個下載器。
（20）UrlConnectionDownloader:使用HttpURLConnection 實現的下載器。
（21）MemoryPolicy: 內存緩存策略，一個枚舉類型。
（22）NetworkPolicy: 磁盤緩存策略，一個枚舉類型。
(23) Stats: 這個類至關於日誌記錄，會記錄如：內存緩存的命中次數，丟失次數，下載次數，轉換次數等等，咱們能夠經過StatsSnapshot類將日誌打印出來，看一下整個項目的圖片加載狀況。
（24）StatsSnapshot :狀態快照，和上面的Stats對應，打印Stats紀錄的信息。架構

以上就是Picasso 的一些關鍵的類的介紹(還有一些簡單的沒有列舉)。app

3、流程分析

上一節介紹了Picasso 的一些關鍵類，接下來就以加載網絡圖片爲例，分析Picasso加載圖片的整個流程框架

Picasso.with(this).load(URL)
                .placeholder(R.drawable.default_bg)
                .error(R.drawable.error_iamge)
                .into(mBlurImage);複製代碼

1, 獲取Picasso instance

首先要獲取一個Picasso對象，採用的單例模式ide

//單例模式獲取Picasso 對象
public static Picasso with(Context context) {
    if (singleton == null) {
      synchronized (Picasso.class) {
        if (singleton == null) {
          singleton = new Builder(context).build();
        }
      }
    }
    return singleton;
  }

// 真正new 的地方在build()方法裏
 public Picasso build() {
      Context context = this.context;

      if (downloader == null) {
        //配置默認的下載器，首先經過反射獲取OkhttpClient,若是獲取到了，就使用OkHttpDwownloader做爲默認下載器
        //若是獲取不到就使用UrlConnectionDownloader做爲默認下載器
        downloader = Utils.createDefaultDownloader(context);
      }
      if (cache == null) {
       // 配置內存緩存，大小爲手機內存的15%
        cache = new LruCache(context);
      }
      if (service == null) {
       // 配置Picaso 線程池，核心池大小爲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);
    }複製代碼

2, 經過load方法生成一個RequestCreator

經過load方法生成一個RequestCreator，用鏈式api 來構建一個圖片下載請求函數

//load有幾個重載方法，參數爲string和File 的重載最重都會包裝成一個Uri 調用這個方法
 public RequestCreator load(Uri uri) {
    return new RequestCreator(this, uri, 0);
  }
// 若是是加載資源id 的圖片會調用這個方法
 public RequestCreator load(int resourceId) {
    if (resourceId == 0) {
      throw new IllegalArgumentException("Resource ID must not be zero.");
    }
    return new RequestCreator(this, null, resourceId);
  }複製代碼

RequestCreator提供了不少的API 來構建請求，如展位圖、大小、轉換器、裁剪等等,這些API實際上是爲對應的屬性賦值，最終會在into方法中構建請求。

// 配置佔位圖，在加載圖片的時候顯示
public RequestCreator placeholder(int placeholderResId) {
    if (!setPlaceholder) {
      throw new IllegalStateException("Already explicitly declared as no placeholder.");
    }
    if (placeholderResId == 0) {
      throw new IllegalArgumentException("Placeholder image resource invalid.");
    }
    if (placeholderDrawable != null) {
      throw new IllegalStateException("Placeholder image already set.");
    }
    this.placeholderResId = placeholderResId;
    return this;
  }

// 配置真正顯示的大小
 public RequestCreator resize(int targetWidth, int targetHeight) {
    data.resize(targetWidth, targetHeight);
    return this;
  }複製代碼

3,into 添加顯示的View，而且提交下載請求

into方法裏面幹了3件事情：

1, 判斷是否設置了fit 屬性，若是設置了，再看是否可以獲取ImageView 的寬高，若是獲取不到，生成一個DeferredRequestCreator（延遲的請求管理器），而後直接return,在DeferredRequestCreator中當監聽到能夠獲取ImageView 的寬高的時候，再執行into方法。

2, 判斷是否從內存緩存獲取圖片，若是沒有設置NO_CACHE,則從內存獲取，命中直接回調CallBack 而且顯示圖片。

3, 若是緩存未命中，則生成一個Action，並提交Action。

public void into(ImageView target, Callback callback) {
    long started = System.nanoTime();
   // 檢查是否在主線程
    checkMain();

    if (target == null) {
      throw new IllegalArgumentException("Target must not be null.");
    }
   //若是沒有url或者resourceId 則取消請求
    if (!data.hasImage()) {
      picasso.cancelRequest(target);
      if (setPlaceholder) {
        setPlaceholder(target, getPlaceholderDrawable());
      }
      return;
    }
    //判斷是否設置了fit屬性
    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());
        }
       //若是獲取不到寬高，生成一個DeferredRequestCreator（延遲的請求管理器），而後直接return,
      //在DeferredRequestCreator中當監聽到能夠獲取ImageView 的寬高的時候，再執行into方法。
        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 action =
        new ImageViewAction(picasso, target, request, memoryPolicy, networkPolicy, errorResId,
            errorDrawable, requestKey, tag, callback, noFade);

    picasso.enqueueAndSubmit(action);// 提交請求
  }複製代碼

4, 提交、分發、執行請求。

會通過下面這一系列的操做，最重將Action 交給BitmapHunter 執行。
enqueueAndSubmit －> submit －> dispatchSubmit －> performSubmit：

//將action 保存到了一個Map 中，目標View做爲key
 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);
  }


//執行請求提交
//1, 先查看保存暫停tag表裏面沒有包含Action的tag,若是包含，則將Action 存到暫停Action表裏
//2，從BitmapHunter表裏查找有沒有對應action的hunter,若是有直接attach
//3, 爲這個請求生成一個BitmapHunter，提交給線程池執行
 void performSubmit(Action action, boolean dismissFailed) {
    // 先查看保存暫停tag表裏面沒有包含Action的tag,若是包含，則將Action 存到暫停Action表裏
    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;
    }
   // 若是線程池北shutDown,直接return
    if (service.isShutdown()) {
      if (action.getPicasso().loggingEnabled) {
        log(OWNER_DISPATCHER, VERB_IGNORED, action.request.logId(), "because shut down");
      }
      return;
    }
    // 爲請求生成一個BitmapHunter
    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());
    }
  }複製代碼

5,指定對應的處理器（RequestHandler）

在上面執行的請求的performSubmit 方法裏，調用了forRequest 方法爲對應的Action 生成一個BitmapHunter,裏面有一個重要的步驟，指定請求處理器（在上面一節介紹Picasso有7種請求處理器,看一下對應的代碼：

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);
     // 循環請求處理器列表，若是找到有能處理這個請求的請求處理器
     // 則生成BitmapHunter
      if (requestHandler.canHandleRequest(request)) {
        return new BitmapHunter(picasso, dispatcher, cache, stats, action, requestHandler);
      }
    }

    return new BitmapHunter(picasso, dispatcher, cache, stats, action, ERRORING_HANDLER);
  }複製代碼

從Picasso裏獲取一個處理器列表，而後循環列表，看是否有能處理該請求的處理器，若是有，則生成BitmapHunter,那麼這個請求處理器的列表在哪兒初始化的呢？請看源碼：

// 1,首先調用了getRequestHandlers
 List<RequestHandler> getRequestHandlers() {
    return requestHandlers;
  }

// 2 requestHandlers 列表是在Picasso 構造函數裏出實話的
 Picasso(Context context, Dispatcher dispatcher, Cache cache, Listener listener,
      RequestTransformer requestTransformer, List<RequestHandler> extraRequestHandlers, Stats stats,
      Bitmap.Config defaultBitmapConfig, boolean indicatorsEnabled, boolean loggingEnabled) {

    ....
   //前面代碼省略

   // 添加了7個內置的請求處理器
  // 若是你本身經過Builder添了額外的處理器，也會添加在這個列表裏面

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

  //後面代碼省略 
    ...

  }複製代碼

小結：在Picasso 的構造函數裏初始化了內置的7中請求處理器，而後在生成BitmapHunter的時候，循環列表，找到能夠處理對應請求的處理器。

6, 重點：BitmapHunter (圖片捕獲器)

上一節重要類介紹的時候介紹過BitmapHunter，BitmapHunter繼承Runnable，其實就是開啓一個線程執行最終的下載。看一下源碼：
1, run() 方法

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

      if (picasso.loggingEnabled) {
        log(OWNER_HUNTER, VERB_EXECUTING, getLogIdsForHunter(this));
      }
     // 調用hunt() 方法獲取最終結果
      result = hunt();

      if (result == null) {
        dispatcher.dispatchFailed(this);//若是爲null，分發失敗的消息
      } else {
        dispatcher.dispatchComplete(this);//若是不爲null，分發成功的消息
      }
    } 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);
    }
  }複製代碼

當將一個bitmapHunter submit 給一個線程池執行的時候，就會執行run() 方法，run裏面調用的是hunt方法來獲取結果，看一下hunt方法：

Bitmap hunt() throws IOException {
    Bitmap bitmap = null;
   // 是否從內存緩存獲取Bitmap
    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;
   // 請求處理器處理請求，獲取結果，Result裏多是Bitmap，多是Stream
    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;
  }複製代碼

7,Downloader 下載器下載圖片

上面的hunt方法獲取結果的時候，最終調用的是配置的處理器的load方法，以下：

RequestHandler.Result result = requestHandler.load(data, networkPolicy);複製代碼

加載網絡圖片用的是NetworkRequestHandler，匹配處理器，有個canHandleRequest 方法：

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

判斷的條件是，Uri帶有"http://" 或者 https:// 前綴則能夠處理

咱們接下來看一下NetworkRequestHandler的load方法：

@Override public Result load(Request request, int networkPolicy) throws IOException {
    //最終調用downloader的load方法獲取結果
    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最終是調用的downloader 的load方法下載圖片。內置了2個Downloader，OkhttpDownloader和UrlConnectionDownloader 。咱們以UrlConnectionDownloader爲例，來看一下load方法：

@Override public Response load(Uri uri, int networkPolicy) throws IOException {
   // 若是SDK 版本大於等於14,安裝磁盤緩存，用的是HttpResponseCache（緩存http或者https的response到文件系統）
    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));
    // 最後獲取InputStream流包裝成Response返回
    return new Response(connection.getInputStream(), fromCache, contentLength);
  }複製代碼

小結：梳理一下調用鏈, BitmapHunter －> NetworkRequestHandler －> UrlConnectionDownloader(也有多是OkHttpDownloader),通過這一系列的調用，最後在BitmapHunter 的run 方法中就能夠獲取到咱們最終要的Bitmap。

8,返回結果並顯示在Target上

在BitmapHunter獲取結果後，分發器分發結果,經過Hander處理後，執行performComplete方法：

//1,
void performComplete(BitmapHunter hunter) {
    // 這裏將結果緩存到內存
    if (shouldWriteToMemoryCache(hunter.getMemoryPolicy())) {
      cache.set(hunter.getKey(), hunter.getResult());
    }
    hunterMap.remove(hunter.getKey());// 請求完畢，將hunter從表中移除
    batch(hunter);
    if (hunter.getPicasso().loggingEnabled) {
      log(OWNER_DISPATCHER, VERB_BATCHED, getLogIdsForHunter(hunter), "for completion");
    }
  }

// 2,而後將BitmapHunter添加到一個批處理列表，經過Hander發送一個批處理消息
private void batch(BitmapHunter hunter) {
    if (hunter.isCancelled()) {
      return;
    }
    batch.add(hunter);
    if (!handler.hasMessages(HUNTER_DELAY_NEXT_BATCH)) {
      handler.sendEmptyMessageDelayed(HUNTER_DELAY_NEXT_BATCH, BATCH_DELAY);
    }
  }
// 3，最後執行performBatchComplete 方法，經過主線程的Handler送處理完成的消息
void performBatchComplete() {
    List<BitmapHunter> copy = new ArrayList<BitmapHunter>(batch);
    batch.clear();
    mainThreadHandler.sendMessage(mainThreadHandler.obtainMessage(HUNTER_BATCH_COMPLETE, copy));
    logBatch(copy);
  }

// 4,最後在Picasso 中handleMessage,顯示圖片
 static final Handler HANDLER = new Handler(Looper.getMainLooper()) {
    @Override public void handleMessage(Message msg) {
      switch (msg.what) {
        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);
          }
          break;
        }
      //後面代碼省略
      ...
  };
// 5,最後回調到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));
    }

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

    Context context = picasso.context;
    boolean indicatorsEnabled = picasso.indicatorsEnabled;
   //將結果包裝成一個PicassoDrawable 並顯示
    PicassoDrawable.setBitmap(target, context, result, from, noFade, indicatorsEnabled);

    if (callback != null) {
      callback.onSuccess(); 回調callback
    }
  }複製代碼

小結：經過上面一系列的方法調用， performComplete －> batch —> performBatchComplete －> handleMessage －> complete 把BitmapHunter中獲取到的結果回調到主線程，而且顯示在Target上。

經過以上的8個步驟，就把圖片從加載到顯示的整個過程分析完了。

四，緩存特別說明

內存緩存很簡單，用的是LRUCache，大小爲手機內存的15% ,上面代碼中已經分析過了，這裏不過多說明，這裏重點說一下Disk Cahce。Picasso內存了2個默認的下載器，UrlConnectionDownloader和OkHttpDownloader,它們的磁盤緩存實現仍是有一些差別的，看一下代碼：

public OkHttpDownloader(final File cacheDir, final long maxSize) {
    this(defaultOkHttpClient());
    try {
      client.setCache(new com.squareup.okhttp.Cache(cacheDir, maxSize));
    } catch (IOException ignored) {
    }
  }複製代碼

在OkHttpDownloader 的構造方法裏設置了磁盤緩存，使用的okHttp 的 DiskLruCache 實現的。

而後看一下UrlConnectionDownloader的磁盤緩存實現，代碼：

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
      installCacheIfNeeded(context);
    }複製代碼

private static void installCacheIfNeeded(Context context) {
    // DCL + volatile should be safe after Java 5.
    if (cache == null) {
      try {
        synchronized (lock) {
          if (cache == null) {
            cache = ResponseCacheIcs.install(context);
          }
        }
      } catch (IOException ignored) {
      }
    }
  }

  private static class ResponseCacheIcs {
    static Object install(Context context) throws IOException {
      File cacheDir = Utils.createDefaultCacheDir(context);
      HttpResponseCache cache = HttpResponseCache.getInstalled();
      if (cache == null) {
        long maxSize = Utils.calculateDiskCacheSize(cacheDir);
        cache = HttpResponseCache.install(cacheDir, maxSize);
      }
      return cache;
    }

    static void close(Object cache) {
      try {
        ((HttpResponseCache) cache).close();
      } catch (IOException ignored) {
      }
    }
  }複製代碼

UrlConnectionDownloader 的磁盤緩存是用HttpResponseCache實現的

儘管2種磁盤緩存實現的方式不同，可是它們的最後結果都是同樣的：

1,磁盤緩存的地址： 磁盤緩存的地址在：data/data/your package name/cache/picasso-cache /
2,磁盤緩存的大小：磁盤緩存的大小爲手機磁盤大小的2% ，不超過50M不小於5M。
3, 緩存的控制方式同樣：都是在請求的header設置Cache-Control的值來控制是否緩存。

緩存清除：
有同窗在前一篇文章（圖片加載框架－Picasso最詳細的使用指南）下面留言問怎麼清除緩存，這裏統一說一下：
1, 清除內存緩存：調用invalidate方法,如：

Picasso.with(this)
                .invalidate("http://ww3.sinaimg.cn/large/610dc034jw1fasakfvqe1j20u00mhgn2.jpg");複製代碼

清除指定url 的內存緩存。

可是Picasso沒有提供清除所有內存緩存的方法，那就沒有辦法了嗎？辦法仍是有的,LRUCahce 提供了clear方法的,只是Picasso沒有向外部提供這個接口，所以能夠經過反射獲取到Picasso的cache字段，而後調用clear方法清除。

2, 清除磁盤緩存
很遺憾Picasso沒有提供清除磁盤緩存的方法。它沒有提供方法咱們就本身想辦法唄。

思路：很簡單，既然咱們知道磁盤緩存是存在：data/data/your package name/cache/picasso-cache 這個路徑下的，那咱們把這個文件夾下面的全部文件清除不就好了。

實現：

private void clearDiskCache(){
        File cache = new File(this.getApplicationContext().getCacheDir(), "picasso-cache");
        deleteFileOrDirectory(cache.getPath());
    }

    public static void deleteFileOrDirectory(String filePath){
        if(TextUtils.isEmpty(filePath)){
            return;
        }
        try {
            File file = new File(filePath);
            if(!file.exists()){
                return;
            }
            if(file.isDirectory()){
                File files[] = file.listFiles();
                for(int i=0;i<files.length;i++){
                    deleteFileOrDirectory(files[i].getAbsolutePath());
                }
            }else{
                file.delete();
                Log.e("zhouwei","delete cache...");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }複製代碼