写在之前

上一篇博文写的是Android 图片加载框架Glide4.0源码完全解析（一），主要分析了Glide4.0源码中的with方法和load方法，原本打算是一起发布的，但是由于into方法复杂性远不是前两个方法所能比拟的，又不愿意马马虎虎的随便应付的写作，还是保持一贯的一步步深入的讲解，所以就提前发布了一篇，以减少篇幅。

正文

这篇是讲Glide源码中into方法的实现原理，可以说with和load方法只是做了前期的初始化配置工作，而真正意义上的图片加载就是在into方法中实现的，所以该方法的复杂程度是可以想象的，还是依照我之前的写作习惯，一步步的分析，不留下任何的盲点给大家带来困惑，那么下面就开始吧。

Glide 源码分析

into()

前面两个方法把所需的基础配置基本已做好，那么接下来就是真正的要去加载资源了，那么我们来看看吧：

首先进去into方法中：

public Target<TranscodeType> into(ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);

    if (!requestOptions.isTransformationSet()
        && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
      if (requestOptions.isLocked()) {
        requestOptions = requestOptions.clone();
      }
      switch (view.getScaleType()) {
        case CENTER_CROP:
          requestOptions.optionalCenterCrop();
          break;
        case CENTER_INSIDE:
          requestOptions.optionalCenterInside();
          break;
        case FIT_CENTER:
        case FIT_START:
        case FIT_END:
          requestOptions.optionalFitCenter();
          break;
        case FIT_XY:
          requestOptions.optionalCenterInside();
          break;
        case CENTER:
        case MATRIX:
        default:
          // Do nothing.
      }
    }

    return into(context.buildImageViewTarget(view, transcodeClass));
  }

主要是为requestOptions 做一些配置，这个配置时根据View的属性而来的。

然后调用GlideContext的buildImageViewTarget方法，并把view和transcodeClass传递进去来构造一个viewTarget的对象，跟进去看看：

直接的调用imageViewTargetFactory的buildTarget方法，然后看下buildTarget的源码：

还记得我多次提醒transcodeClass是什么吗？没错就是Drawable.class，就是在这个分支中使用到，那么在buildTarget中就是创建一个DrawableImageViewTarget对象，并它view传递进去，DrawableImageViewTarget继承于ImageViewTarget，又把view传递到了ViewTarget中，最终把view存放到了ViewTarget中的view变量中，并且还创建了一个SizeDeterminer对象：

ok，这就是我们的ImageView的最终去向，知道了view的去向，我们在返回到RequestBuilder中，创建个DrawableImageViewTarget对象后，又把它重定向到into方法中：

这个方法是非常重要的，必须要理解清楚，其实真正的理解好了也就很简单的了：

首先，从target中调用getRequest方法获取Request请求，这个getRequest方法是在ViewTarget父类中：

它首先从View中获取tag标识，但是我们从未为view设置标识，它也就不存在什么标识，所以getTag方法会返回一个null值，由此request也就是一个null空值。

在从taget中获取不到request，那么就需要为它去构造request对象，所以它调用了buildRequest：

private Request buildRequest(Target<TranscodeType> target) {
    return buildRequestRecursive(target, null, transitionOptions, requestOptions.getPriority(),
        requestOptions.getOverrideWidth(), requestOptions.getOverrideHeight());
  }

buildRequest方法又调用了buildRequestRecursive方法：

private Request buildRequestRecursive(Target<TranscodeType> target,
      @Nullable ThumbnailRequestCoordinator parentCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority, int overrideWidth, int overrideHeight) {
    ...
      return obtainRequest(target, requestOptions, parentCoordinator, transitionOptions, priority,
          overrideWidth, overrideHeight);
  }

buildRequestRecursive做了一堆判断，最终会调用obtainRequest方法：

在这里它直接的调用SingleRequest.obtain方法，并返回一个Request对象，由此我们看到最终是调用到SingleRequest来真正的构造Request对象：

 public static <R> SingleRequest<R> obtain(
      GlideContext glideContext,
      Object model,
      Class<R> transcodeClass,
      RequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target<R> target,
      RequestListener<R> requestListener,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory<? super R> animationFactory) {
    @SuppressWarnings("unchecked") SingleRequest<R> request =
        (SingleRequest<R>) POOL.acquire();
    if (request == null) {
      request = new SingleRequest<>();
    }
    request.init(
        glideContext,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        requestListener,
        requestCoordinator,
        engine,
        animationFactory);
    return request;
  }

由obtain方法看到，创建了一个SingleRequest对象，并调用它的init方法来进行初始化操作。

ok，到此Request创建完毕，来看看它拥有哪些成员：

让我们再回到into方法中，创建了Request对象后，把它设置给我们的target，最终则是调用setTag方法为view设置tag：

private void setTag(@Nullable Object tag) {
    if (tagId == null) {
      isTagUsedAtLeastOnce = true;
      view.setTag(tag);
    } else {
      view.setTag(tagId, tag);
    }
  }

设置完毕之后将会调用requestManager中的track方法：

void track(Target<?> target, Request request) {
    targetTracker.track(target);
    requestTracker.runRequest(request);
  }

track方法中分别把target和request添加到targetTracker和requestTracker追踪器中。

然后来看看runRequest方法：

它将会调用Request对象的begin方法来企图开启我们的请求，我们知道request其实就是我们的SingleRequest对象，那么到它的begin方法中看看到底做了哪些事情：

@Override
  public void begin() {
    stateVerifier.throwIfRecycled();
    startTime = LogTime.getLogTime();
    if (model == null) {
      if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        width = overrideWidth;
        height = overrideHeight;
      }
      // Only log at more verbose log levels if the user has set a fallback drawable, because
      // fallback Drawables indicate the user expects null models occasionally.
      int logLevel = getFallbackDrawable() == null ? Log.WARN : Log.DEBUG;
      onLoadFailed(new GlideException("Received null model"), logLevel);
      return;
    }

    status = Status.WAITING_FOR_SIZE;
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
      onSizeReady(overrideWidth, overrideHeight);
    } else {
      target.getSize(this);
    }

    if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
        && canNotifyStatusChanged()) {
      target.onLoadStarted(getPlaceholderDrawable());
    }
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
      logV("finished run method in " + LogTime.getElapsedMillis(startTime));
    }
  }

首先，它判断model是否为空，如果请求url为空的话，那就不用请求了，直接调用onLoadFailed加载失败。

然后，调用onSizeReady方法，真正的资源加载就是从这个方法中开始的。

最后，根据Status对象状态和是否有占位图来设置加载过程中的占位图。

那么重点就是在onSizeReady方法中了，我们来详细的看看它的源码：

  @Override
  public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
      logV("Got onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
    if (status != Status.WAITING_FOR_SIZE) {
      return;
    }
    status = Status.RUNNING;

    float sizeMultiplier = requestOptions.getSizeMultiplier();
    this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
    this.height = maybeApplySizeMultiplier(height, sizeMultiplier);

    if (Log.isLoggable(TAG, Log.VERBOSE)) {
      logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
    }
    loadStatus = engine.load(
        glideContext,
        model,
        requestOptions.getSignature(),
        this.width,
        this.height,
        requestOptions.getResourceClass(),
        transcodeClass,
        priority,
        requestOptions.getDiskCacheStrategy(),
        requestOptions.getTransformations(),
        requestOptions.isTransformationRequired(),
        requestOptions.getOptions(),
        requestOptions.isMemoryCacheable(),
        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
        requestOptions.getOnlyRetrieveFromCache(),
        this);
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
      logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
  }

onSizeReady方法中首先把State状态更改为RUNNING，然后获取到ImageView的宽高属性值，这个属性值就是要加载的图片的宽高，顺便提一句，Glide框架会根据请求加载图片的ImageView的宽高来进行加载相对应的宽高图片，每次根据view的大小加载的图片是不一定一样的。最后调用engine中的load方法，我们再来看看load方法的源码：

public <R> LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class<?> resourceClass,
      Class<R> transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map<Class<?>, Transformation<?>> transformations,
      boolean isTransformationRequired,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb) {
    Util.assertMainThread();
    long startTime = LogTime.getLogTime();

    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);

    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return null;
    }

    EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
      cb.onResourceReady(active, DataSource.MEMORY_CACHE);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return null;
    }

    EngineJob<?> current = jobs.get(key);
    if (current != null) {
      current.addCallback(cb);
      if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logWithTimeAndKey("Added to existing load", startTime, key);
      }
      return new LoadStatus(cb, current);
    }

    EngineJob<R> engineJob = engineJobFactory.build(key, isMemoryCacheable,
        useUnlimitedSourceExecutorPool);
    DecodeJob<R> decodeJob = decodeJobFactory.build(
        glideContext,
        model,
        key,
        signature,
        width,
        height,
        resourceClass,
        transcodeClass,
        priority,
        diskCacheStrategy,
        transformations,
        isTransformationRequired,
        onlyRetrieveFromCache,
        options,
        engineJob);
    jobs.put(key, engineJob);
    engineJob.addCallback(cb);
    engineJob.start(decodeJob);

    if (Log.isLoggable(TAG, Log.VERBOSE)) {
      logWithTimeAndKey("Started new load", startTime, key);
    }
    return new LoadStatus(cb, engineJob);
  }

哇吼，所有重要的东西都在这里了，解析下：

①：判断是否在主线程运行，说明到目前为止还是在主线程执行的，并没有真正的开启子线程。

②：通过keyFactory工厂来构建一个EngineKey对象，key关联着model，也就是url，它很根据model，view的宽高等等属性来构建一个EngineKey对象，这个对象可以用来指定缓存地址，可以用来从缓存中查找资源等。

③：根据创建的key对象分别调用loadFromCache和loadFromActiveResources方法来从内存中查找是否有缓存资源，如果有，则回调cb.onResourceReady来直接设置图片了。

④：分别使用engineJobFactory和decodeJobFactory构建EngineJob和DecodeJob对象，这两个对象是真正的加载资源的两个重要类，EngineJob对象负责开启线程去加载资源，并且加载得资源后转换到主线程并进行回调；DecodeJob是真正的执行者，它就是去网络加载资源的地方，EngineJob开启线程，真正执行的是DecodeJob，DecodeJob之后完毕之后叫道EngineJob去分发回调。这就是这两个类的关系。

⑤：EngineJob和DecodeJob的构建是基本一致的，我们看看比较复杂的DecodeJob的构建：在build方法中，首先通过pool来创建一个DecodeJob对象，然后调用DecodeJob对象的init方法进行初始化，在初始化中值得注意的是调用了decodeHelper对象的init方法。decodeHelper方法是DecodeJob的重要辅助类，后面我们会详细的接触它。

⑥：上面也提到回调，这里先cb添加到engineJob.addCallback();中，然后调用EngineJob的start方法来开启线程。

我们再来看看start方法中的源码：

start方法中将会调用GlideExecutor的execute方法：

execute中正式的开启了线程池进行加载资源。由此我们也正式的由主线程转到了子线程中。

上面我们也分析了，真正执行线程的是在DecodeJob类中，那么我们去看看的run方法是怎么执行的：

run方法中调用runWrapped方法，主要就是在它里面执行的，来看看它的源码：

我们知道，在构造DecodeJob时调用init方法是runReason被赋值为INITIALIZE值，由此它将会进入到INITIALIZE分支中，调用getNextStage方法：

在getNextStage方法中经错几次的经转会返回Stage.SOURCE值，然后在调用getNextGenerator方法来获取当前的currentGenerator对象，我们在来看看获取的这个currentGenerator到底是什么？

getNextGenerator方法中根据stage值来创建对象，由此我们可以知道currentGenerator是一个SourceGenerator对象，那么我们继续往下走，来看看runGenerators方法：

runGenerators最重要的就是执行了currentGenerator的startNext方法，这里将会真正的去加载网络资源：

我们从上面知道currentGenerator就是SourceGenerator对象，那么我们去看看SourceGenerator中startNext的实现：

到这里就太关键了，因为很多人都死在这一步上，根本找不到是怎么去加载资源的，是怎么执行到我们熟悉的HttpURLConnection的，那么到这里你千万不能分神，稍微分神就会转迷糊了，哈哈，那么接下来就开始分析吧：

由于我们在创建SourceGenerator对象时，只是传递了DecodeHelper和回调cb对象，其他的一切初始化操作都是不存在的，所以在startNext中，前面的两个判断是不成立的，主要是看while循环里面的内容：

while循环中首先调用hasNextModelLoader进行判断，我们来看下hasNextModelLoader的内容，这里必须集中精力理解清楚，不然肯定不知所云：

private boolean hasNextModelLoader() {
    return loadDataListIndex < helper.getLoadData().size();
  }

在hasNextModelLoader中它要去helper加载数据，调用getLoadData方法，我们跟进去看看：

在getLoadData方法中是调用GlideContext中的getRegistry方法来回去Registry对象，它是在Glide的构造方法中创建的，而且注册添加了很多解析器还记得吗？不记得的赶快去看看Glide的构造方法。这里我们插入一点非常重要的分析，理解清楚它对接下来的网络执行非常的重要：回到Glidet的构造方法来看看Registry中几个特殊的解析类：

registry.register(xx)
        .append(xx)
        ...
        .append(Uri.class, InputStream.class, new HttpUriLoader.Factory())
        ...
        .append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())
        ...
        ;

还有印象这段很长的代码吧？

我们重点来看看上面的两个append方法，其他的都是一样或是类似的道理的。跟进去registry的append方法中：

继续进入modelLoaderRegistry.append方法中：

再跟进multiModelLoaderFactory.append方法中：

重点来了，最后进去add方法：

这里可以看到什么？你理解了吗？

创建了一个Entry对象，把我们的modelClass，dataClass和factory对象关联起来，然后存放到entries的list集合中，就这么简单，但是对这个Entry对象的理解关系到我们后面对整个网络加载的流程十分的巨大，ok，到这里，我们插入的讲解已经完了，主要想告诉你的就是这个entries集合包含了那些对象和创建Entry对象所关联的类和工厂。

那么现在回到DecodeHelper中的getLoadData方法中，它从GlideContext获取到Registry对象，Registry对象有哪些内容在上面的插入讲解中也已举特例分析了，然后调用getModelLoaders方法，并传进model对象，那么来看看它是怎么实现的：

它会从modelLoaderRegistry中获取，在来看：

它会通过model从getModelLoadersForClass方法中获取到modelLoaders的集合，来看看：

首先从cache缓存中获取，如果为空，将会从multiModelLoaderFactory工厂中获取，在继续跟进multiModelLoaderFactory的build方法看看:

从entries集合中分别的遍历出entry对象，然后调用entry.handles来进行匹配是否符合，来看handles方法：

this.modelClass是什么还记得吗？没错就是在Glide创建Registry对象是append的XX.class，例如：

.append(Uri.class, InputStream.class, new HttpUriLoader.Factory())

而modelClass呢，这里就是我们传递用来加载网络图片的一个url地址，那么调用isAssignableFrom方法进行匹配，我们知道entries包含很多的解析器，所以在这一步将会排除掉不匹配的解析器，然后调用调用build方法来创建加载器：

entry.factory知道是什么吧？没错就是append方法中new的一个工厂类。

还是以下面的特例来说：

.append(Uri.class, InputStream.class, new HttpUriLoader.Factory())

在这里这个factory就是HttpUriLoader.Factory，我们来看看它是怎么实现的：

这里它将会multiFactory.build方法来构造一个ModelLoader对象，看清楚它传递的参数：GlideUrl.class, InputStream.class，然后跟进去查看：

历史总是惊人的相似，再次从entries中获取Entry对象，然后调用entry.handles方法根据GlideUrl.class, InputStream.class这两个参数进行匹配过滤。

然后我们找到了以下的append内容相匹配的Entry对象

.append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())

找到HttpGlideUrlLoader.Factory之后，然后调用build方法去构建，在build方法中同样的方式调用entry.factory.build(this)，来看看HttpGlideUrlLoader.Factory()的build的源码：

直接的创建一个HttpGlideUrlLoader对象并返回。

到此我们获取了真正的图片加载对象，然后我们回到HttpUriLoader的Factory中：在multiFactory.build(GlideUrl.class, InputStream.class)获取到HttpGlideUrlLoader对象后，并传递到创建的HttpUriLoader对象中去，我们来看看：

把HttpGlideUrlLoader对象赋值给HttpUriLoader的成员变量this.urlLoader中。

ok，到此我们真正的加载器已经获取到了，当然并不是只有一个，可能有多个，因为在Registry注册了多个可以解析Uri.class的解析器。

好，我们在回到ModelLoaderRegistry类中的getModelLoaders方法中，从getModelLoadersForClass方法中我们获取到了可以解析我们请求modle的所有解析器，通过for循环遍历出所有的解析器，存放到filteredLoaders集合中并返回，一直返回到DecodeHelper类中的getLoadData方法中。

然后遍历modelLoaders集合，分别获取ModelLoader对象，并调用buildLoadData方法，我们知道modelLoaders集合中一定会包含一个ModelLoader是HttpUriLoader，那来看看它的buildLoadData方法：

它会调用urlLoader.buildLoadData方法，这个urlLoader就是HttpGlideUrlLoader对象，再来看看：

这里最重要的就是创建个一个HttpUrlFetcher对象：

然后把HttpUrlFetcher对象存放到新建的LoadData对象中：

最后把LoadData对象返回，我们往上返回到SourceGenerator的startNext方法中：

在获取到LoadData对象后，调用loadData.fetcher.loadData(helper.getPriority(), this);这个方法，从上面分析loadData.fetcher就是HttpUrlFetcher对象，那我们来看看它里面的loadData是怎么加载数据的：

它会调用loadDataWithRedirects方法来返回一个InputStream输入流，来看看loadDataWithRedirects的源码：

private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl,
      Map<String, String> headers) throws IOException {
    if (redirects >= MAXIMUM_REDIRECTS) {
      throw new HttpException("Too many (> " + MAXIMUM_REDIRECTS + ") redirects!");
    } else {
      // Comparing the URLs using .equals performs additional network I/O and is generally broken.
      // See http://michaelscharf.blogspot.com/2006/11/javaneturlequals-and-hashcode-make.html.
      try {
        if (lastUrl != null && url.toURI().equals(lastUrl.toURI())) {
          throw new HttpException("In re-direct loop");

        }
      } catch (URISyntaxException e) {
        // Do nothing, this is best effort.
      }
    }

    urlConnection = connectionFactory.build(url);
    for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
      urlConnection.addRequestProperty(headerEntry.getKey(), headerEntry.getValue());
    }
    urlConnection.setConnectTimeout(timeout);
    urlConnection.setReadTimeout(timeout);
    urlConnection.setUseCaches(false);
    urlConnection.setDoInput(true);

    // Stop the urlConnection instance of HttpUrlConnection from following redirects so that
    // redirects will be handled by recursive calls to this method, loadDataWithRedirects.
    urlConnection.setInstanceFollowRedirects(false);

    // Connect explicitly to avoid errors in decoders if connection fails.
    urlConnection.connect();
    if (isCancelled) {
      return null;
    }
    final int statusCode = urlConnection.getResponseCode();
    if (statusCode / 100 == 2) {
      return getStreamForSuccessfulRequest(urlConnection);
    } else if (statusCode / 100 == 3) {
      String redirectUrlString = urlConnection.getHeaderField("Location");
      if (TextUtils.isEmpty(redirectUrlString)) {
        throw new HttpException("Received empty or null redirect url");
      }
      URL redirectUrl = new URL(url, redirectUrlString);
      return loadDataWithRedirects(redirectUrl, redirects + 1, url, headers);
    } else if (statusCode == -1) {
      throw new HttpException(statusCode);
    } else {
      throw new HttpException(urlConnection.getResponseMessage(), statusCode);
    }
  }

这里的代码我们就非常的熟悉了，稍微的简单介绍下：

①：connectionFactory对象是在创建HttpUrlFetcher对象时在构造方法中初始化的，它就是DEFAULT_CONNECTION_FACTORY，也就是DefaultHttpUrlConnectionFactory工厂类，当调用它的build方法时：

通过url打开连接，返回一个HttpURLConnection对象，用于网络请求，这些代码平常我们都有接触，不多说。

②：建立连接，过去返回状态码，判断，然后通过getStreamForSuccessfulRequest方法返回一个InputStream输入流。

在获取到InputStream输入流之后，最会将会调用callback.onDataReady(result);回调方法，并把输入流传递过去。

那这个callback是什么呢？

还记得loadData.fetcher.loadData(helper.getPriority(), this);这段代码吧？

没错他就是SourceGenerator类实现的DataCallback回调类。

那么在进到SourceGenerator找到onDataReady方法吧：

在这里它又调用cb回调类的onDataFetcherReady方法，并传递了相关参数：loadData.fetcher是HttpUrlFetcher，loadData.fetcher.getDataSource()则是DataSource.REMOTE：

 @Override
  public DataSource getDataSource() {
    return DataSource.REMOTE;
  }

那么这个cb又是什么呢，它是FetcherReadyCallback回调类，在DecodeJob中实现，那么回到DecodeJob的onDataFetcherReady方法中：

在onDataFetcherReady方法中保存了相关的参数变量，判断是否是当前线程，然后调用decodeFromRetrievedData方法来解码数据：

首先创建一个Resource类型的变量，通过decodeFromData方法把输入流解码并返回给resource，由此可也看出，解码主要是在decodeFromData方法中：

在这里已经体现loadData.fetcher这个fetcher的用意，主要是去关闭输入流和HttpUrlConnection的。

@Override
  public void cleanup() {
    if (stream != null) {
      try {
        stream.close();
      } catch (IOException e) {
        // Ignore
      }
    }
    if (urlConnection != null) {
      urlConnection.disconnect();
    }
  }

在这之前它又调用decodeFromFetcher方法来进行解码返回一个Resource：

在这里获取到data.getClass，这个Class就是InputStrem.class，那么在调用decodeHelper.getLoadPath方法后，我们来看看做了哪些操作：

getLoadPath方法啥也没做，直接调用Registry中的getLoadPath，并传递了拥有的变量，其中resourceClass是Object.class，transcodeClass则是Drawable.class，这是在前面已构建初始化好的，直接拿来用。

我们在来跟进去看看

这里首先从loadPathCache缓存中获取LoadPath对象，如果没有则调用getDecodePaths方法进行获取：

getDecodePaths方法中还是蛮重要的，对真个解码过程的理解有很大的帮助，所以我们来认真的分析下：

①：首先从decoderRegistry.getResourceClasses方法中获取已经注册的registeredResourceClasses：

还记得我们创建Registry是注册了一大堆的东西吗？

对，通过handles方法对InputStrem.class和Object.class进行匹配的就是我们用红色框画出来的部分。由此我们可以得出registeredResourceClasses集合中分别对应的是Bitmap.class，BitmapDrawable.class和GifDrawable.class的三种Class对象。

②：遍历registeredResourceClasses集合，通过transcoderRegistry.getTranscodeClasses方法获取到已注册的registeredTranscodeClasses集合：

这是对registeredResourceClasses集合的再次匹配，我们知道transcodeClasses实际上是Drawable.class，在registeredResourceClasses集合中只有BitmapDrawable.class和GifDrawable.class是继承Drawable的，由此我们得出registeredTranscodeClasses包含BitmapDrawable.class和GifDrawable.class两种Class对象。

那么由此可知decoders存放了两种解码器：

对应的BitmapDrawable的BitmapDrawableDecoder解码器。
对应的GifDrawable.class的StreamGifDecoder解码器。

这个非常重要，在后面有使用到。必须理解清楚。

③：通过上面获取的registeredResourceClass和registeredTranscodeClass获取到transcoder转化器，主要是从transcoderRegistry集合中通过get方法获取，而transcoderRegistry又包含哪些转化器呢？

而又有get方法我们可以知道：

当时普通图片是transcoder将会是BitmapDrawableTranscoder，如是过动态图片gif的话transcoder将会是GifDrawableBytesTranscoder。

然后把它们存放到创建的DecodePath对象中：

最后是把封装好的DecodePath对象存储到decodePaths集合中并返回。

然后在回到Registry中的getLoadPath方法中，在获取到decodePaths集合中，把它和dataClass, resourceClass, transcodeClass又封装到LoadPath对象中，并缓存到loadPathCache对象中。

再次返回DecodeJob类中的decodeFromFetcher方法中，在获取到LoadPath后，调用runLoadPath方法，来看下它的源码：

它调用glideContext.getRegistry()获取Registry对象，然后调用Registry的getRewinder获取装置器，跟进去看看：

在getRewinder方法中直接的调用dataRewinderRegistry对象的build方法，那么这个dataRewinderRegistry又是什么呢？

它是在Registry构造方法中创建的对象：

this.dataRewinderRegistry = new DataRewinderRegistry();

而且在Glide中进行了注册：

获取到factory之后调用dataRewinderRegistry.register方法注册到Map集合rewinders中去：

再来看看factory.getDataClass()都获取到哪些key：

①：在ByteBufferRewinder.Factory中调用getDataClass()获取的key是ByteBuffer.class

②：在InputStreamRewinder.Factory中调用getDataClass()获取的key是InputStream.class

上面两个key值在接下来会使用到。

那么我们在返回到getRewinder方法中，调用dataRewinderRegistry对象的build方法到底做了什么：

在build的方法中总共做了四件事，分别用不同的线框标注出来了：

①：从rewinders集合中获取到和data.getClass()相匹配的Factory对象，从上面的分析中，我们知道rewinders注册的只有两个key，分别是ByteBuffer.class和InputStream.class，而我们又知道data.getClass()是一个InputStream.class，由此可以匹配成功。这个result就是InputStreamRewinder.Factory对象。

②：假如result没有匹配成功的话，也就是没有通过key匹配成功，那么就进行遍历rewinders集合，通过values值进行匹配，把匹配成功的Factory对象再赋值给result。

③：假如通过键key和值values都没有匹配成功，那么也不要紧，直接使用默认的DEFAULT_FACTORY

④：最后调用result的build方法。

这里由于我们通过键key直接已匹配成功，所以我们知道result就是InputStreamRewinder.Factory对象，那么来看看调用它的build方法做了什么事情：

这里直接的返回了一个InputStreamRewinder对象，在InputStreamRewinder的构造方法中又创建了RecyclableBufferedInputStream对象，并它InputStream流传递进去：

RecyclableBufferedInputStream继承FilterInputStream流，那么我们的InputStream流最终保存的位置就是在FilterInputStream类中。

ok，到这里我们知道了InputStream数据流的去向，而在InputStreamRewinder中又有对InputStream流的引用，那么在回到InputStreamRewinder之后我们来看看接下来又做了什么呢？

再次定位到DecodeJob类中的runLoadPath方法，在获取到InputStreamRewinder后，它会调用path.load方法并返回Resource资源类，这个path是在之前获取到的LoadPath对象，这里注意下，传递了一个new DecodeCallback 对象的回调类，后面会用到。最后调用InputStreamRewinder.cleanup()进行资源释放。那么我们来看看LoadPath的load方法是怎么实现的：

它直接调用loadWithExceptionList方法进行移交：

在loadWithExceptionList方法中则会调用decode方法进行解码：

decode方法中调用decodeResource方法，然后在调用decodeResourceWithList方法真正的开始解码：

①：这里首先遍历decoders集合，分别的获取到ResourceDecoder解码器，还记得我们的decoders都包含哪些解码器吗？没错主要包含两种：BitmapDrawable.class和GifDrawable.class。不记得的往上面翻下，上面已详细的讲解过了。

②：然后通过rewinder.rewindAndGet()获取我们的InputStream数据流：

③：通过decoder.handles(data, options)方法来过滤掉不相匹配的解码器，再来看看前面的这张图：

Bitmap.class已被我们过滤掉，剩下的就只有BitmapDrawable.class和GifDrawable.class，当我们调用handles方法进行匹配时，StreamGifDecoder解码器是怎么处理的：

它主要是针对options属性为gif的图片来解码的，其实这不用我说大家也是知道的，而我们加载的只是普通的静态图片，因此它是不符合我们的匹配规则的，在来看BitmapDrawableDecoder中，它传入的是StreamBitmapDecoder的解码器：

而downsampler.handles(source);中只要source是InputStream就返回true，因此匹配成功。

那么由上分析，我们真正的decoder就是BitmapDrawableDecoder。

回到decodeResourceWithList方法中，获取到真正的decoder解码器，将会调用decode方法正式解码：

它又会交给StreamBitmapDecoder的decode方法，然后在转移到Downsampler类中的decode方法中：

这里就不再一个一个的看方法了，主要是在Downsampler中decodeFromWrappedStreams方法中把InputStream数据流根据width, height, options给转化成Bitmap图片，然后把Bitmap存放到BitmapResource对象中去且直接的返回本身。

ok，获取到BitmapResource对象后，再次返回最初开始解码的DecodePath类中的decode方法中：

从上面分析我们知道，我们解析的是普通的图片，所以这个transcoder就是BitmapDrawableTranscoder转换器类。（前面有详细的分析，忘记的可以向上翻看）

接着我们去BitmapDrawableTranscoder中的transcode方法看看：

在transcode方法中通过toTranscode.get()获取bitmap图片，这个bitmap虽然经过多层的包装，它其实就是一个BitmapResource对象，这在上面我们有清楚的分析，只不过在返回的回调方法中有多次的封装而已。

获取到Bitmap图片后，调用LazyBitmapDrawableResource的obtain方法再次进行一次的封装：

把Bitmap封装到LazyBitmapDrawableResource对象中进行返回。

ok，到这里其实已完成了完完全全的解码和封装到。

一路把LazyBitmapDrawableResource对象返回到DecodeJob类中的decodeFromRetrievedData中，并赋值给resource变量：

当resource不为空时，将会调用notifyEncodeAndRelease方法并传递参数：

方法里面就不多解析了，它会调用notifyComplete方法：

这里调用了callback.onResourceReady(resource, dataSource);方法，那这个callback是什么呢？它其实是一个ResourceCallback，在SingleRequest中发起的，并且SingleRequest还实现了ResourceCallback接口内的方法：

public void onResourceReady(Resource<?> resource, DataSource dataSource) {
    stateVerifier.throwIfRecycled();
    loadStatus = null;
    if (resource == null) {
      GlideException exception = new GlideException("Expected to receive a Resource<R> with an "
          + "object of " + transcodeClass + " inside, but instead got null.");
      onLoadFailed(exception);
      return;
    }

    Object received = resource.get();
    if (received == null || !transcodeClass.isAssignableFrom(received.getClass())) {
      releaseResource(resource);
      GlideException exception = new GlideException("Expected to receive an object of "
          + transcodeClass + " but instead" + " got "
          + (received != null ? received.getClass() : "") + "{" + received + "} inside" + " "
          + "Resource{" + resource + "}."
          + (received != null ? "" : " " + "To indicate failure return a null Resource "
          + "object, rather than a Resource object containing null data."));
      onLoadFailed(exception);
      return;
    }

    if (!canSetResource()) {
      releaseResource(resource);
      // We can't put the status to complete before asking canSetResource().
      status = Status.COMPLETE;
      return;
    }

    onResourceReady((Resource<R>) resource, (R) received, dataSource);
  }

重点讲解下：在onResourceReady中使用resource.get()，我们知道这个resource就是LazyBitmapDrawableResource对象，来看看这个get获取到了什么：

在get中获取到了BitmapDrawable对象直接复制给了received变量，然后调用重载方法onResourceReady方法：

在onResourceReady方法中调用了target.onResourceReady(result, animation);还记得target是什么吗？

它在load方法中已讲解过，就是DrawableImageViewTarget对象，调用它的onResourceReady会转移到父类ImageViewTarget中：

然后在调用setResourceInternal方法：

setResource是抽象方法，由它的子类实现，我们在回到DrawableImageViewTarget中：

到这里直接调用view进行设置图片了，这个view就是我们Imageview了，所以到这里就设置好了加载的图片了。

ok，到这里就完完全全的解析完了Glide的执行原理了。

说实在的Glide的源码非常的复杂，往往深入进入就无法出来了，相信这篇博客很能好的给大家一个参考，能让大家对整个Glide有个全面的理解。

好了，终于写完了，真的很不容易，很辛苦，希望大家也能从中学到知识。

各位如果还有哪里不明白的，或是我这里讲的还不够透彻，亦或是讲错了的地方请留言指正，让我们共同进步，谢谢

同时，请大家扫一扫关注我的微信公众号，虽然写的不是很勤，但是每一篇都有质量保证，让您学习到真正的知识。