Android 图片加载框架Glide主流程源码分析

下一篇 Android 图片加载框架Glide缓存原理源码分析

Glide图片加载框架最近比较火，谷歌官方强烈推荐，使用也比较简单，功能强大，支持网络图片本地图片的加载，支持静态图片和动态图片。反正一句话就是很火很牛，我们需要它。

github地址：

https://github.com/bumptech/glide   点击打开链接

这里采用的Glide4.4版本进行分析，现在直接根据加载方法开始分析吧。

Glide.with(vh.imageView)
          .load(image.link)

          .into(vh.imageView);

先看Glide.with()，

public class Glide implements ComponentCallbacks2 {
  ...
  public static RequestManager with(View view) {
    return getRetriever(view.getContext()).get(view);
  }

  private static RequestManagerRetriever getRetriever(@Nullable Context context) {
    // Context could be null for other reasons (ie the user passes in null), but in practice it will
    // only occur due to errors with the Fragment lifecycle.
    // 上下文为空直接抛出空指针
    Preconditions.checkNotNull(
        context,
        "You cannot start a load on a not yet attached View or a Fragment where getActivity() "
            + "returns null (which usually occurs when getActivity() is called before the Fragment "
            + "is attached or after the Fragment is destroyed).");
    return Glide.get(context).getRequestManagerRetriever();
   }
    
  ...
}

可以看到17行开始构造Glide实例，进入到get()里面，

public class Glide implements ComponentCallbacks2 {
   ...
    /**
   * Get the singleton.
   *
   * @return the singleton
   */
  public static Glide get(Context context) {
    // 获取Glide单例
    if (glide == null) {
      synchronized (Glide.class) {
        if (glide == null) {
          checkAndInitializeGlide(context);
        }
      }
    }

    return glide;
  }
    
   ...
}

这里已经能看到构造了一个Glide单例，继续往里面看，看是怎么构造这个单例的

public class Glide implements ComponentCallbacks2 {
  ...
    /**
   * 检查并初始化Glide
   * @param context
   */
  private static void checkAndInitializeGlide(Context context) {
    // In the thread running initGlide(), one or more classes may call Glide.get(context).
    // Without this check, those calls could trigger infinite recursion.
    if (isInitializing) {
      throw new IllegalStateException("You cannot call Glide.get() in registerComponents(),"
          + " use the provided Glide instance instead");
    }
    isInitializing = true;
    initializeGlide(context);
    isInitializing = false;
  }

    private static void initializeGlide(Context context) {
    initializeGlide(context, new GlideBuilder());
  }

  @SuppressWarnings("deprecation")
  private static void initializeGlide(Context context, GlideBuilder builder) {
    // 初始化Glide
    Context applicationContext = context.getApplicationContext();
    // 获取GeneratedAppGlideModule的实例
    GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules();
    List manifestModules = Collections.emptyList();
    if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
      // 解析AndroidManifest.xml，把配置的自定义的GlideModule的实例保存到list中
      // 
      // 
      manifestModules = new ManifestParser(applicationContext).parse();
    }

    if (annotationGeneratedModule != null
        && !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
      // 这里有个疑问，annotationGeneratedModule.getExcludedModuleClasses()永远都是空的，根本不会执行下面的代码
      // 不知道这里加上这句判断有何作用
      Set> excludedModuleClasses =
          annotationGeneratedModule.getExcludedModuleClasses();
      Iterator iterator = manifestModules.iterator();
      while (iterator.hasNext()) {
        com.bumptech.glide.module.GlideModule current = iterator.next();
        if (!excludedModuleClasses.contains(current.getClass())) {
          continue;
        }
        if (Log.isLoggable(TAG, Log.DEBUG)) {
          Log.d(TAG, "AppGlideModule excludes manifest GlideModule: " + current);
        }
        iterator.remove();
      }
    }

    if (Log.isLoggable(TAG, Log.DEBUG)) {
      for (com.bumptech.glide.module.GlideModule glideModule : manifestModules) {
        Log.d(TAG, "Discovered GlideModule from manifest: " + glideModule.getClass());
      }
    }

    RequestManagerRetriever.RequestManagerFactory factory =
        annotationGeneratedModule != null
            ? annotationGeneratedModule.getRequestManagerFactory() : null;
    builder.setRequestManagerFactory(factory);
    for (com.bumptech.glide.module.GlideModule module : manifestModules) {
      // 不在AndroidManifest.xml里面配置GlideModule，这个for进不来的，默认是不用配置的
      module.applyOptions(applicationContext, builder);
    }
    if (annotationGeneratedModule != null) {
      // 最新的glide4.0以上版本已经不再需要在AndroidManifest.xml中配置GlideModule;
      // applyOptions 是给自定义配置的，比如内存占比等，默认已经配置过
      annotationGeneratedModule.applyOptions(applicationContext, builder);
    }
    // 开始初始化Glide单例
    Glide glide = builder.build(applicationContext);
    // registerComponents 留给自定义的回调函数
    for (com.bumptech.glide.module.GlideModule module : manifestModules) {
      module.registerComponents(applicationContext, glide, glide.registry);
    }
    if (annotationGeneratedModule != null) {
      annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
    }
    applicationContext.registerComponentCallbacks(glide);
    Glide.glide = glide;
  }
    
  ...
}

这个构造流程相当长，具体的注释已经写在代码中了，这里分析几个关键部分，

28-74行，获取到GeneratedAppGlideModule 的实例，如果这个实例为空，就去AndroidManifest.xml中去查找com.bumptech.glide.module.GlideModule，用过Glide都知道，如果要修改缓存等配置就需要继承GlideModule并扩展，其实4.0版本以后Glide就增加了用注解的方式生成GlideModule，再也不用AndroidManifest.xml中注册自定义的GlideModule，这样确实方便很多

28行，这里就是去生成GeneratedAppGlideModule实例，跟踪进入，

public class Glide implements ComponentCallbacks2 {
  ...
     @Nullable
  @SuppressWarnings({"unchecked", "deprecation", "TryWithIdenticalCatches"})
  private static GeneratedAppGlideModule getAnnotationGeneratedGlideModules() {
    // 通过GeneratedAppGlideModuleImpl名称去获取Class对象
    GeneratedAppGlideModule result = null;
    try {
      Class clazz =
          (Class)
              Class.forName("com.bumptech.glide.GeneratedAppGlideModuleImpl");
      result = clazz.newInstance();
    } catch (ClassNotFoundException e) {
      if (Log.isLoggable(TAG, Log.WARN)) {
        Log.w(TAG, "Failed to find GeneratedAppGlideModule. You should include an"
            + " annotationProcessor compile dependency on com.github.bumptech.glide:compiler"
            + " in your application and a @GlideModule annotated AppGlideModule implementation or"
            + " LibraryGlideModules will be silently ignored");
      }
    } catch (InstantiationException e) {
      throw new IllegalStateException("GeneratedAppGlideModuleImpl is implemented incorrectly."
          + " If you've manually implemented this class, remove your implementation. The Annotation"
          + " processor will generate a correct implementation.", e);
      // These exceptions can't be squashed across all versions of Android.
    } catch (IllegalAccessException e) {
      throw new IllegalStateException("GeneratedAppGlideModuleImpl is implemented incorrectly."
          + " If you've manually implemented this class, remove your implementation. The Annotation"
          + " processor will generate a correct implementation.", e);
    }
    return result;
  }
    
  ...
}

可以看到根据Class文件名反射生成GeneratedAppGlideModuleImpl实例，这个类就是通过注解编译器在项目

编译阶段生成的.Java文件，如下图:     

Android 学习使用annotationprocessor自动生成java文件 

http://blog.csdn.net/msn465780/article/details/78888668

可能有个疑问如果改缓存配置难道要在这个自动生成的类中改吗？肯定不会了，下面看下这个类，

@SuppressWarnings("deprecation")
final class GeneratedAppGlideModuleImpl extends GeneratedAppGlideModule {
  private final ImgurGlideModule appGlideModule;

  GeneratedAppGlideModuleImpl() {
    appGlideModule = new ImgurGlideModule();
    if (Log.isLoggable("Glide", Log.DEBUG)) {
      Log.d("Glide", "Discovered AppGlideModule from annotation: com.bumptech.glide.samples.imgur.ImgurGlideModule");
    }
  }

  @Override
  public void applyOptions(Context context, GlideBuilder builder) {
    appGlideModule.applyOptions(context, builder);
  }

  @Override
  public void registerComponents(Context context, Glide glide, Registry registry) {
    appGlideModule.registerComponents(context, glide, registry);
  }

  @Override
  public boolean isManifestParsingEnabled() {
    return appGlideModule.isManifestParsingEnabled();
  }

  @Override
  public Set> getExcludedModuleClasses() {
    return Collections.emptySet();
  }
   ...
}

第6行，看到了吗？构造了一个ImgurGlideModule实例，里面所有需要开发这定义的方法都实际是这个实例去干的，所以具体的配置都应该在ImgurGlideModule里面操作，这个GlideModule其实就是4.0以前我们需要重写的那个，类名是根据主Module名生成的。

接着我们回到Glide的构造那，可能之前的都忘记了，这里我再贴下那串很长的代码，

public class Glide implements ComponentCallbacks2 {
  ...
  @SuppressWarnings("deprecation")
  private static void initializeGlide(Context context, GlideBuilder builder) {
    // 初始化Glide
    Context applicationContext = context.getApplicationContext();
    // 获取GeneratedAppGlideModule的实例
    GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules();
    List manifestModules = Collections.emptyList();
    if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
      // 解析AndroidManifest.xml，把配置的自定义的GlideModule的实例保存到list中
      // 
      // 
      manifestModules = new ManifestParser(applicationContext).parse();
    }

    if (annotationGeneratedModule != null
        && !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
      // 这里有个疑问，annotationGeneratedModule.getExcludedModuleClasses()永远都是空的，根本不会执行下面的代码
      // 不知道这里加上这句判断有何作用
      Set> excludedModuleClasses =
          annotationGeneratedModule.getExcludedModuleClasses();
      Iterator iterator = manifestModules.iterator();
      while (iterator.hasNext()) {
        com.bumptech.glide.module.GlideModule current = iterator.next();
        if (!excludedModuleClasses.contains(current.getClass())) {
          continue;
        }
        if (Log.isLoggable(TAG, Log.DEBUG)) {
          Log.d(TAG, "AppGlideModule excludes manifest GlideModule: " + current);
        }
        iterator.remove();
      }
    }

    if (Log.isLoggable(TAG, Log.DEBUG)) {
      for (com.bumptech.glide.module.GlideModule glideModule : manifestModules) {
        Log.d(TAG, "Discovered GlideModule from manifest: " + glideModule.getClass());
      }
    }

    RequestManagerRetriever.RequestManagerFactory factory =
        annotationGeneratedModule != null
            ? annotationGeneratedModule.getRequestManagerFactory() : null;
    builder.setRequestManagerFactory(factory);
    for (com.bumptech.glide.module.GlideModule module : manifestModules) {
      // 不在AndroidManifest.xml里面配置GlideModule，这个for进不来的，默认是不用配置的
      module.applyOptions(applicationContext, builder);
    }
    if (annotationGeneratedModule != null) {
      // 最新的glide4.0以上版本已经不再需要在AndroidManifest.xml中配置GlideModule;
      // applyOptions 是给自定义配置的，比如内存占比等，默认已经配置过
      annotationGeneratedModule.applyOptions(applicationContext, builder);
    }
    // 开始初始化Glide单例
    Glide glide = builder.build(applicationContext);
    // registerComponents 留给自定义的回调函数
    for (com.bumptech.glide.module.GlideModule module : manifestModules) {
      module.registerComponents(applicationContext, glide, glide.registry);
    }
    if (annotationGeneratedModule != null) {
      annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
    }
    applicationContext.registerComponentCallbacks(glide);
    Glide.glide = glide;
  }  
  ...
}

第57行，生成Glide实例，Glide中用了大量的bulder模式、工厂模式，里面详细的代码下一篇介绍，主要是初始化内存缓存磁盘缓存相关的，第66行，返回的glide实例赋值给成员变量glide，到这里Glide单例就构建成功了，这里注意43-36行，一个工厂模式，干嘛的呢？其实就是用于生成GlideRequests实例的前置铺垫，创建一个GeneratedRequestManagerFactory，这个一看前缀就知道是自动生成的.java文件，与之前GeneratedAppGlideModuleImpl原理一样，代码如下：

final class GeneratedAppGlideModuleImpl extends GeneratedAppGlideModule {
  private final ImgurGlideModule appGlideModule;

  ...
  @Override
  GeneratedRequestManagerFactory getRequestManagerFactory() {
    return new GeneratedRequestManagerFactory();
  }
}

看到被生成的代码了吧，详细的就具体分析了，不然这篇文章得非常长，这里知道这个就可以了，然后回到开始这段代码，

public class Glide implements ComponentCallbacks2 {

  ...
  public static RequestManager with(View view) {
    return getRetriever(view.getContext()).get(view);
  }
    
}

get一个RequestManagerRetriever实例，接着根据传入的view继续get   RequestManager对象，跟踪进入，

public class RequestManagerRetriever implements Handler.Callback {

  ...
   public RequestManager get(View view) {
    if (Util.isOnBackgroundThread()) {
      return get(view.getContext().getApplicationContext());
    }

    Preconditions.checkNotNull(view);
    Preconditions.checkNotNull(view.getContext(),
        "Unable to obtain a request manager for a view without a Context");
    Activity activity = findActivity(view.getContext());
    // The view might be somewhere else, like a service.
    if (activity == null) {
      return get(view.getContext().getApplicationContext());
    }

    // Support Fragments.
    // Although the user might have non-support Fragments attached to FragmentActivity, searching
    // for non-support Fragments is so expensive pre O and that should be rare enough that we
    // prefer to just fall back to the Activity directly.
    if (activity instanceof FragmentActivity) {
      Fragment fragment = findSupportFragment(view, (FragmentActivity) activity);
      return fragment != null ? get(fragment) : get(activity);
    }

    // Standard Fragments.
    android.app.Fragment fragment = findFragment(view, activity);
    if (fragment == null) {
      return get(activity);
    }
    return get(fragment);
  }

   public RequestManager get(Fragment fragment) {
    Preconditions.checkNotNull(fragment.getActivity(),
          "You cannot start a load on a fragment before it is attached or after it is destroyed");
    if (Util.isOnBackgroundThread()) {
      return get(fragment.getActivity().getApplicationContext());
    } else {
      FragmentManager fm = fragment.getChildFragmentManager();
      return supportFragmentGet(fragment.getActivity(), fm, fragment);
    }
  }

  private RequestManager supportFragmentGet(Context context, FragmentManager fm,
      Fragment parentHint) {
    SupportRequestManagerFragment current = getSupportRequestManagerFragment(fm, parentHint);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      // TODO(b/27524013): Factor out this Glide.get() call.
      Glide glide = Glide.get(context);
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }
... 
}

假设加载环境是Fragment，Activity同理，现在的APP基本都是用的Fragment

52-58行，54行成员变量factory其实就是刚才说的GeneratedRequestManagerFactory实例，也就是构造Glide实例时创建的，

因此，factory.build() 其实就是GeneratedRequestManagerFactory.build()，返回GlideRequests实例

final class GeneratedRequestManagerFactory implements RequestManagerRetriever.RequestManagerFactory {
  @Override
  public RequestManager build(Glide glide, Lifecycle lifecycle, RequestManagerTreeNode treeNode,
      Context context) {
    return new GlideRequests(glide, lifecycle, treeNode, context);
  }
}

也就是Glide.with(view) 返回了 GlideRequests实例

接下来看GlideRequests.load()

public class GlideRequests extends RequestManager {
  ...
  
    @Override
  @CheckResult
  public GlideRequest load(@Nullable String arg0) {
    return (GlideRequest) super.load(arg0);
  }
    
  ...
}

public class RequestManager implements LifecycleListener,
    ModelTypes> 
  ...
  
  /**
   * Equivalent to calling {@link #asDrawable()} and then {@link RequestBuilder#load(String)}.
   *
   * @return A new request builder for loading a {@link Drawable} using the given model.
   */
  @CheckResult
  @Override
  public RequestBuilder load(@Nullable String string) {
    return asDrawable().load(string);
  }
    
  ...
}

先看13行，asDrawable()，

public class RequestManager implements LifecycleListener,
    ModelTypes> {
  ...
  
  @CheckResult
  public RequestBuilder asDrawable() {
    return as(Drawable.class);
  }

    @CheckResult
  public  RequestBuilder as(Class resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
  }
    
  ...
}

这里需要注意，resourceClass 是Drawable.class 实例，记住，后面会有用，继续跟踪，

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  
   protected RequestBuilder(Glide glide, RequestManager requestManager,
      Class transcodeClass, Context context) {
    this.glide = glide;
    this.requestManager = requestManager;
    this.transcodeClass = transcodeClass;
    this.defaultRequestOptions = requestManager.getDefaultRequestOptions();
    this.context = context;
    this.transitionOptions = requestManager.getDefaultTransitionOptions(transcodeClass);
    this.requestOptions = defaultRequestOptions;
    this.glideContext = glide.getGlideContext();
  }
  ...
}

构造了一个RequestBuilder实例，传入的参数赋值到RequestBuilder的成员变量，这里成员transcodeClass也就是刚才的Drawable.class，记住了，初始化了一个requestOptions，这2个成员记住了，后面会有用的，接着回到之前的一段代码，

public class RequestManager implements LifecycleListener,
    ModelTypes> {
  ...
  
    @CheckResult
  @Override
  public RequestBuilder load(@Nullable String string) {
    return asDrawable().load(string);
  }
  ...
}

现在跟踪load(string),

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  
  @Override
  @CheckResult
  public RequestBuilder load(@Nullable String string) {
    return loadGeneric(string);
  }

  private RequestBuilder loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
  }
  ...
}

第12行，这个model当前是图片url String的实例，赋值给RequestBuilder成员，这里记住了，后面的分析model都是图片url地址，刚才赋值了2个重要参数  transcodeClass、defaultRequestOptions，后面会用到，到这里load()步骤就完毕了

接着看最复杂的GlideRequest.into()，

由于GlideRequest继承RequestBuilder，自己又没重写into()方法，因此这个into()是在RequestBuilder里面的，

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  
    /**
   * Sets the {@link ImageView} the resource will be loaded into, cancels any existing loads into
   * the view, and frees any resources Glide may have previously loaded into the view so they may be
   * reused.
   *
   * @param view The view to cancel previous loads for and load the new resource into.
   * @return The {@link com.bumptech.glide.request.target.Target} used to wrap the given {@link
   * ImageView}.
   * @see RequestManager#clear(Target)
   */
  public ViewTarget into(ImageView view) {
    // 以下必须在主线程中执行，否则抛出异常
    Util.assertMainThread();
    Preconditions.checkNotNull(view);

    RequestOptions requestOptions = this.requestOptions;
    if (!requestOptions.isTransformationSet()
        && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
      // Clone in this method so that if we use this RequestBuilder to load into a View and then
      // into a different target, we don't retain the transformation applied based on the previous
      // View's scale type.
      switch (view.getScaleType()) {
        case CENTER_CROP:
          requestOptions = requestOptions.clone().optionalCenterCrop();
          break;
        case CENTER_INSIDE:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case FIT_CENTER:
        case FIT_START:
        case FIT_END:
          requestOptions = requestOptions.clone().optionalFitCenter();
          break;
        case FIT_XY:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case CENTER:
        case MATRIX:
        default:
          // Do nothing.
      }
    }

    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions);
  }
  ...
}

switch语句用于判断图片显示的模式，默认是CENTER_CROP,

49-53行，调用3个参数的into()，

第50行，根据之前提到的transcodeClass生成Target，Target是不是看起来很熟悉，我们继续跟踪，

public class GlideContext extends ContextWrapper {
  ...

  public  ViewTarget buildImageViewTarget(
    ImageView imageView, Class transcodeClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
  }

  ...
}

/**
 * A factory responsible for producing the correct type of
 * {@link com.bumptech.glide.request.target.Target} for a given {@link android.view.View} subclass.
 */
public class ImageViewTargetFactory {

  @SuppressWarnings("unchecked")
  public  ViewTarget buildTarget(ImageView view, Class clazz) {
    if (Bitmap.class.equals(clazz)) {
      return (ViewTarget) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
      return (ViewTarget) new DrawableImageViewTarget(view);
    } else {
      throw new IllegalArgumentException(
          "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
  }
}

这里的clazz就是刚才传过来的transcodeClass，这个呢之前记住过，在分析的例子里是Drawable.class，很明显了，进入

第12行，创建返回DrawableImageViewTarget实例，这里也要记住了，以后的target就是DrawableImageViewTarget实例，

接着返回RequestBuilder

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...

  public ViewTarget into(ImageView view) {
    // 以下必须在主线程中执行，否则抛出异常
    Util.assertMainThread();
    Preconditions.checkNotNull(view);
     ...

    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions);
  }

  ...
}

继续跟踪，

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      RequestOptions options) {
    // 不为主线程就抛出异常
    Util.assertMainThread();
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    options = options.autoClone();
    // 返回SingleRequest实例
    Request request = buildRequest(target, targetListener, options);

    // target从成员变量view中获取tag,这个tag是Request实例
    Request previous = target.getRequest();
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();
      // If the request is completed, beginning again will ensure the result is re-delivered,
      // triggering RequestListeners and Targets. If the request is failed, beginning again will
      // restart the request, giving it another chance to complete. If the request is already
      // running, we can let it continue running without interruption.
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        // Use the previous request rather than the new one to allow for optimizations like skipping
        // setting placeholders, tracking and un-tracking Targets, and obtaining View dimensions
        // that are done in the individual Request.
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }

  ...
}

这里把之前生成的2个参数传入了过来， DrawableImageViewTarget，requestOptions，

第17行会返回Request实例，其实是SingleRequest的实例，为啥是它的实例呢，这里得跟踪进入，不然32行begin()就会不知道到底是哪个Request调用的

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
   private Request buildRequest(
      Target target,
      @Nullable RequestListener targetListener,
      RequestOptions requestOptions) {
    return buildRequestRecursive(
        target,
        targetListener,
        /*parentCoordinator=*/ null,
        transitionOptions,
        requestOptions.getPriority(),
        requestOptions.getOverrideWidth(),
        requestOptions.getOverrideHeight(),
        requestOptions);
  }

  private Request buildRequestRecursive(
      Target target,
      @Nullable RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {

    ...
    Request mainRequest =
        buildThumbnailRequestRecursive(
            target,
            targetListener,
            parentCoordinator,
            transitionOptions,
            priority,
            overrideWidth,
            overrideHeight,
            requestOptions);

    if (errorRequestCoordinator == null) {
      return mainRequest;
    }

   ...
  }

  ...
}

30-40行为主流程，继续跟踪，

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  
    private Request buildThumbnailRequestRecursive(
      Target target,
      RequestListener targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {
    if (thumbnailBuilder != null) {
      ...

      ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
      Request fullRequest =
          obtainRequest(
              target,
              targetListener,
              requestOptions,
              coordinator,
              transitionOptions,
              priority,
              overrideWidth,
              overrideHeight);
      isThumbnailBuilt = true;
      // Recursively generate thumbnail requests.
      Request thumbRequest =
          thumbnailBuilder.buildRequestRecursive(
              target,
              targetListener,
              coordinator,
              thumbTransitionOptions,
              thumbPriority,
              thumbOverrideWidth,
              thumbOverrideHeight,
              thumbnailBuilder.requestOptions);
      isThumbnailBuilt = false;
      coordinator.setRequests(fullRequest, thumbRequest);
      return coordinator;
    } else if (thumbSizeMultiplier != null) {
      // Base case: thumbnail multiplier generates a thumbnail request, but cannot recurse.
      ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
      Request fullRequest =
          obtainRequest(
              target,
              targetListener,
              requestOptions,
              coordinator,
              transitionOptions,
              priority,
              overrideWidth,
              overrideHeight);
      RequestOptions thumbnailOptions = requestOptions.clone()
          .sizeMultiplier(thumbSizeMultiplier);

      Request thumbnailRequest =
          obtainRequest(
              target,
              targetListener,
              thumbnailOptions,
              coordinator,
              transitionOptions,
              getThumbnailPriority(priority),
              overrideWidth,
              overrideHeight);

      coordinator.setRequests(fullRequest, thumbnailRequest);
      return coordinator;
    } else {
      // Base case: no thumbnail.
      return obtainRequest(
          target,
          targetListener,
          requestOptions,
          parentCoordinator,
          transitionOptions,
          priority,
          overrideWidth,
          overrideHeight);
    }
  }

  ...
}

这个方法也挺长的，因为只研究网络图片加载的主流程，很多详细的地方就不描述了，第一次加载网络图片，会执行

74-83行，去构造这个Request实例，Request只是一个接口，实现它的有几个类，具体是哪个，我们继续跟踪，

答案即将揭晓

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  private Request obtainRequest(
      Target target,
      RequestListener targetListener,
      RequestOptions requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight) {
    return SingleRequest.obtain(
        context,
        glideContext,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListener,
        requestCoordinator,
        glideContext.getEngine(),
        transitionOptions.getTransitionFactory());
  }

  ...
}

看到了吧，SingleRequest.obtain(）去构造了SingleRequest实例并返回，我们也返回，

public class RequestBuilder implements Cloneable,
    ModelTypes> {
  ...
  private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      RequestOptions options) {
    // 不为主线程就抛出异常
    Util.assertMainThread();
    Preconditions.checkNotNull(target);
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }

    options = options.autoClone();
    // 返回SingleRequest实例
    Request request = buildRequest(target, targetListener, options);

    // target从成员变量view中获取tag,这个tag是Request实例
    Request previous = target.getRequest();
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      request.recycle();
      // If the request is completed, beginning again will ensure the result is re-delivered,
      // triggering RequestListeners and Targets. If the request is failed, beginning again will
      // restart the request, giving it another chance to complete. If the request is already
      // running, we can let it continue running without interruption.
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        // Use the previous request rather than the new one to allow for optimizations like skipping
        // setting placeholders, tracking and un-tracking Targets, and obtaining View dimensions
        // that are done in the individual Request.
        previous.begin();
      }
      return target;
    }

    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }

  ...
}

经过这些操作后32行，调用begin()，也就是SingleRequest.begin()，接着看到这个方法，好戏正上演

public final class SingleRequest implements Request,
    SizeReadyCallback,
    ResourceCallback,
    FactoryPools.Poolable {
  ...
   @Override
  public void begin() {
    assertNotCallingCallbacks();
    stateVerifier.throwIfRecycled();
    startTime = LogTime.getLogTime();
    if (model == null) {
      if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        // 不调用glide.override(),
        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;
    }

    if (status == Status.RUNNING) {
      throw new IllegalArgumentException("Cannot restart a running request");
    }

    // If we're restarted after we're complete (usually via something like a notifyDataSetChanged
    // that starts an identical request into the same Target or View), we can simply use the
    // resource and size we retrieved the last time around and skip obtaining a new size, starting a
    // new load etc. This does mean that users who want to restart a load because they expect that
    // the view size has changed will need to explicitly clear the View or Target before starting
    // the new load.
    if (status == Status.COMPLETE) {
      onResourceReady(resource, DataSource.MEMORY_CACHE);
      return;
    }

    // Restarts for requests that are neither complete nor running can be treated as new requests
    // and can run again from the beginning.

    status = Status.WAITING_FOR_SIZE;
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
      onSizeReady(overrideWidth, overrideHeight);
    } else {
      // 父类ViewTarget的getSize()，调用onSizeReady();
      target.getSize(this);
    }

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

  ...
}

11行，判断了model是否为null，model前面提过，在这篇文章里就是url地址，String类型，肯定不为空，所以跳过，

34-37行，这个是图片是否加载完成，加载完成后onResourceReady()回调函数，这类型的回调函数Glide用得很多，加载好的图片资源会一层一层的回调到Target去让ImageView显示，这里由于是第一次加载，所以跳过

42-48行，overrideWidth、overrideHeight是个啥呢，记得GlideRequest.override(int overrideWidth, int overrideHeight)，如果不设置这个，Glide是用的控件的尺寸来计算图片的缩放比例的，设置这个后，就会根据我们提供的宽高去计算图片的缩放比例，由于这篇文章没有设置，那就是默认的，因此跳过

47行，target，哈哈，又见到它了吧，前提反复提过，还记得起吧，这篇文章的是DrawableImageViewTarget实例，我们去看

getSize()，发现没有，对吧，说明这个方法是父类或者爷爷等类中描述的，最终找到在ViewTarget里面

public abstract class ViewTarget extends BaseTarget {
  ...
  @CallSuper
  @Override
  public void getSize(SizeReadyCallback cb) {
    sizeDeterminer.getSize(cb);
  }

    @VisibleForTesting
  static final class SizeDeterminer {
  ...
  
   void getSize(SizeReadyCallback cb) {
      // 计算控件的宽高
      int currentWidth = getTargetWidth();
      int currentHeight = getTargetHeight();
      if (isViewStateAndSizeValid(currentWidth, currentHeight)) {
        cb.onSizeReady(currentWidth, currentHeight);
        return;
      }

      // We want to notify callbacks in the order they were added and we only expect one or two
      // callbacks to be added a time, so a List is a reasonable choice.
      if (!cbs.contains(cb)) {
        cbs.add(cb);
      }
      if (layoutListener == null) {
        ViewTreeObserver observer = view.getViewTreeObserver();
        layoutListener = new SizeDeterminerLayoutListener(this);
        observer.addOnPreDrawListener(layoutListener);
      }
    }
    
  ...
}
  ...
}

还记得这里的cb是啥吗，也就是SingleRequest实例，这个cb的好几处都用到了，说白了就是后面需要进行回调，这里先有点印象先，18行，主流程，然后回到SingleRequest.onSizeReady()

public final class SingleRequest implements Request,
    SizeReadyCallback,
    ResourceCallback,
    FactoryPools.Poolable {
  ...
  /**
   * A callback method that should never be invoked directly.
   */
  @Override
  public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();
    if (IS_VERBOSE_LOGGABLE) {
      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 (IS_VERBOSE_LOGGABLE) {
      logV("finished setup for calling load in " + LogTime.getElapsedMillis(startTime));
    }
    // 构建Engine实例，整个加载过程的管理器
    loadStatus = engine.load(
            glideContext,
        model,
        requestOptions.getSignature(),
        this.width,
        this.height,
        requestOptions.getResourceClass(),
        transcodeClass,
        priority,
        requestOptions.getDiskCacheStrategy(),
        requestOptions.getTransformations(),
        requestOptions.isTransformationRequired(),
        requestOptions.isScaleOnlyOrNoTransform(),
        requestOptions.getOptions(),
        requestOptions.isMemoryCacheable(),
        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
        requestOptions.getUseAnimationPool(),
        requestOptions.getOnlyRetrieveFromCache(),
        this);

    // This is a hack that's only useful for testing right now where loads complete synchronously
    // even though under any executor running on any thread but the main thread, the load would
    // have completed asynchronously.
    if (status != Status.RUNNING) {
      loadStatus = null;
    }
    if (IS_VERBOSE_LOGGABLE) {
      logV("finished onSizeReady in " + LogTime.getElapsedMillis(startTime));
    }
  }

  ...
}

28行开始正式进入加载主题了，engine.load()，首先来看下engine是什么，这个对象其实就是整个加载流程的引擎，在哪被构造出来的呢，还记得构造Glide实例那里的代码吗

public class Glide implements ComponentCallbacks2 {
  ...
 
   @SuppressWarnings("deprecation")
  private static void initializeGlide(Context context, GlideBuilder builder) {
  ...
    // 开始初始化Glide单例
    Glide glide = builder.build(applicationContext);
    ...
    Glide.glide = glide;
  }

  ...
}

public final class GlideBuilder {
  ...
 
   public Glide build(Context context) {
   ...

    if (engine == null) {
      engine =
          new Engine(
              memoryCache,
              diskCacheFactory,
              diskCacheExecutor,
              sourceExecutor,
              GlideExecutor.newUnlimitedSourceExecutor(),
              GlideExecutor.newAnimationExecutor(),
              isActiveResourceRetentionAllowed);
    }

    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);

    return new Glide(
        context,
        engine,
        memoryCache,
        bitmapPool,
        arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
        logLevel,
        defaultRequestOptions.lock(),
        defaultTransitionOptions);
  }

  ...
}

明白了吧，在构造Glide单例的时候构造了Engine实例，继续跟踪

public class Glide implements ComponentCallbacks2 {
  ...
 
   public Glide build(Context context) {
   ...

  Glide(
      Context context,
      Engine engine,
      MemoryCache memoryCache,
      BitmapPool bitmapPool,
      ArrayPool arrayPool,
      RequestManagerRetriever requestManagerRetriever,
      ConnectivityMonitorFactory connectivityMonitorFactory,
      int logLevel,
      RequestOptions defaultRequestOptions,
      Map, TransitionOptions> defaultTransitionOptions) {
    this.engine = engine;
    this.bitmapPool = bitmapPool;
    this.arrayPool = arrayPool;
    this.memoryCache = memoryCache;
    this.requestManagerRetriever = requestManagerRetriever;
    this.connectivityMonitorFactory = connectivityMonitorFactory;

    DecodeFormat decodeFormat = defaultRequestOptions.getOptions().get(Downsampler.DECODE_FORMAT);
    bitmapPreFiller = new BitmapPreFiller(memoryCache, bitmapPool, decodeFormat);

    final Resources resources = context.getResources();

    registry = new Registry();
    registry.register(new DefaultImageHeaderParser());

    Downsampler downsampler = new Downsampler(registry.getImageHeaderParsers(),
        resources.getDisplayMetrics(), bitmapPool, arrayPool);
    ByteBufferGifDecoder byteBufferGifDecoder =
        new ByteBufferGifDecoder(context, registry.getImageHeaderParsers(), bitmapPool, arrayPool);
    VideoBitmapDecoder videoBitmapDecoder = new VideoBitmapDecoder(bitmapPool);
    ByteBufferBitmapDecoder byteBufferBitmapDecoder = new ByteBufferBitmapDecoder(downsampler);
    StreamBitmapDecoder streamBitmapDecoder = new StreamBitmapDecoder(downsampler, arrayPool);
    ResourceDrawableDecoder resourceDrawableDecoder =
        new ResourceDrawableDecoder(context);
    ResourceLoader.StreamFactory resourceLoaderStreamFactory =
        new ResourceLoader.StreamFactory(resources);
    ResourceLoader.UriFactory resourceLoaderUriFactory =
        new ResourceLoader.UriFactory(resources);
    ResourceLoader.FileDescriptorFactory resourceLoaderFileDescriptorFactory =
        new ResourceLoader.FileDescriptorFactory(resources);
    BitmapEncoder bitmapEncoder = new BitmapEncoder();

    registry
        .append(ByteBuffer.class, new ByteBufferEncoder())
        .append(InputStream.class, new StreamEncoder(arrayPool))
        /* Bitmaps */
        .append(Registry.BUCKET_BITMAP, ByteBuffer.class, Bitmap.class, byteBufferBitmapDecoder)
        .append(Registry.BUCKET_BITMAP, InputStream.class, Bitmap.class, streamBitmapDecoder)
        .append(
            Registry.BUCKET_BITMAP, ParcelFileDescriptor.class, Bitmap.class, videoBitmapDecoder)
        .append(
            Registry.BUCKET_BITMAP, Bitmap.class, Bitmap.class, new UnitBitmapDecoder())
        .append(Bitmap.class, Bitmap.class, UnitModelLoader.Factory.getInstance())
        .append(Bitmap.class, bitmapEncoder)
        /* BitmapDrawables */
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            ByteBuffer.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, byteBufferBitmapDecoder))
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            InputStream.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, streamBitmapDecoder))
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            ParcelFileDescriptor.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, videoBitmapDecoder))
        .append(BitmapDrawable.class, new BitmapDrawableEncoder(bitmapPool, bitmapEncoder))
        /* GIFs */
        .append(
            Registry.BUCKET_GIF,
            InputStream.class,
            GifDrawable.class,
            new StreamGifDecoder(registry.getImageHeaderParsers(), byteBufferGifDecoder, arrayPool))
        .append(Registry.BUCKET_GIF, ByteBuffer.class, GifDrawable.class, byteBufferGifDecoder)
        .append(GifDrawable.class, new GifDrawableEncoder())
        /* GIF Frames */
        // Compilation with Gradle requires the type to be specified for UnitModelLoader here.
        .append(
            GifDecoder.class, GifDecoder.class, UnitModelLoader.Factory.getInstance())
        .append(
            Registry.BUCKET_BITMAP,
            GifDecoder.class,
            Bitmap.class,
            new GifFrameResourceDecoder(bitmapPool))
        /* Drawables */
        .append(Uri.class, Drawable.class, resourceDrawableDecoder)
        .append(
            Uri.class, Bitmap.class, new ResourceBitmapDecoder(resourceDrawableDecoder, bitmapPool))
        /* Files */
        .register(new ByteBufferRewinder.Factory())
        .append(File.class, ByteBuffer.class, new ByteBufferFileLoader.Factory())
        .append(File.class, InputStream.class, new FileLoader.StreamFactory())
        .append(File.class, File.class, new FileDecoder())
        .append(File.class, ParcelFileDescriptor.class, new FileLoader.FileDescriptorFactory())
        // Compilation with Gradle requires the type to be specified for UnitModelLoader here.
        .append(File.class, File.class, UnitModelLoader.Factory.getInstance())
        /* Models */
        .register(new InputStreamRewinder.Factory(arrayPool))
        .append(int.class, InputStream.class, resourceLoaderStreamFactory)
        .append(
                int.class,
                ParcelFileDescriptor.class,
                resourceLoaderFileDescriptorFactory)
        .append(Integer.class, InputStream.class, resourceLoaderStreamFactory)
        .append(
                Integer.class,
                ParcelFileDescriptor.class,
                resourceLoaderFileDescriptorFactory)
        .append(Integer.class, Uri.class, resourceLoaderUriFactory)
        .append(int.class, Uri.class, resourceLoaderUriFactory)
        .append(String.class, InputStream.class, new DataUrlLoader.StreamFactory())
        .append(String.class, InputStream.class, new StringLoader.StreamFactory())
        .append(String.class, ParcelFileDescriptor.class, new StringLoader.FileDescriptorFactory())
        .append(Uri.class, InputStream.class, new HttpUriLoader.Factory())
        .append(Uri.class, InputStream.class, new AssetUriLoader.StreamFactory(context.getAssets()))
        .append(
                Uri.class,
                ParcelFileDescriptor.class,
                new AssetUriLoader.FileDescriptorFactory(context.getAssets()))
        .append(Uri.class, InputStream.class, new MediaStoreImageThumbLoader.Factory(context))
        .append(Uri.class, InputStream.class, new MediaStoreVideoThumbLoader.Factory(context))
        .append(
            Uri.class,
            InputStream.class,
            new UriLoader.StreamFactory(context.getContentResolver()))
        .append(Uri.class, ParcelFileDescriptor.class,
             new UriLoader.FileDescriptorFactory(context.getContentResolver()))
        .append(Uri.class, InputStream.class, new UrlUriLoader.StreamFactory())
        .append(URL.class, InputStream.class, new UrlLoader.StreamFactory())
        .append(Uri.class, File.class, new MediaStoreFileLoader.Factory(context))
        .append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())
        .append(byte[].class, ByteBuffer.class, new ByteArrayLoader.ByteBufferFactory())
        .append(byte[].class, InputStream.class, new ByteArrayLoader.StreamFactory())
        .append(Uri.class, Uri.class, UnitModelLoader.Factory.getInstance())
        .append(Drawable.class, Drawable.class, UnitModelLoader.Factory.getInstance())
        .append(Drawable.class, Drawable.class, new UnitDrawableDecoder())
        /* Transcoders */
        .register(
            Bitmap.class,
            BitmapDrawable.class,
            new BitmapDrawableTranscoder(resources))
        .register(Bitmap.class, byte[].class, new BitmapBytesTranscoder())
        .register(GifDrawable.class, byte[].class, new GifDrawableBytesTranscoder());

    ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
    glideContext =
        new GlideContext(
            context,
            arrayPool,
            registry,
            imageViewTargetFactory,
            defaultRequestOptions,
            defaultTransitionOptions,
            engine,
            logLevel);
  }

  ...
}

Glide的构造方法真长，这里为啥要都贴出来，是有原因的

157-167行，构造GlideContext实例，engine实例作为它的成员变量，

50-155行，registry实例在append数据，这里可是一个大伏笔，特别注意122-124行，这里是本篇文章后面分析要用到的

现在回到Engine.load()，接着上面继续看

public class Engine implements EngineJobListener,
    MemoryCache.ResourceRemovedListener,
    EngineResource.ResourceListener {
  ...
 
   public  LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class resourceClass,
      Class transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map, Transformation> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb) {
    Util.assertMainThread();
    long startTime = LogTime.getLogTime();

    // 根据各种参数创建图片key
    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
        resourceClass, transcodeClass, options);

    // 检查内存中弱引用是否有目标图片
    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;
    }

    // 检查内存中Lrucache是否有目标图片
    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;
    }

    // 内存中没有图片往下执行
    EngineJob current = jobs.get(key, onlyRetrieveFromCache);
    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 engineJob =
        engineJobFactory.build(
            key,
            isMemoryCacheable,
            useUnlimitedSourceExecutorPool,
            useAnimationPool,
            onlyRetrieveFromCache);

    DecodeJob decodeJob =
        decodeJobFactory.build(
            glideContext,
            model,
            key,
            signature,
            width,
            height,
            resourceClass,
            transcodeClass,
            priority,
            diskCacheStrategy,
            transformations,
            isTransformationRequired,
            isScaleOnlyOrNoTransform,
            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);
  }

  ...
}

这段代码也很长，我们从62行开始看，因为前面的代码都是关于缓存中已经有目标图片了，直接出来回调，由于本片文章是关于第一次网络加载，所以缓存部分暂时不过多描述

这里出现了2个类，非常重要，EngineJob、DecodeJob ，EngineJob相当于线程池，DecodeJob就是一个实现Runnable的任务，所以加载的具体业务都在DecodeJob中

92行，这里又是回调，我们要知道cb是啥，这里是SingleRequest实例，也是一级一级传过来的，作用还是待会图片加载好了传到target显示

93行，开启异步加载任务

class EngineJob implements DecodeJob.Callback,
    Poolable {
  ...
   public void start(DecodeJob decodeJob) {
    this.decodeJob = decodeJob;
    GlideExecutor executor = decodeJob.willDecodeFromCache()
        ? diskCacheExecutor
        : getActiveSourceExecutor();
    executor.execute(decodeJob);
  }

  ...
}

这里用的是GlideExecutor实例去加载，这里先不要管这个实例在哪构造的，就是一个线程池去开启了DecodeJob，接下来跟踪DecodeJob的run()方法

class DecodeJob implements DataFetcherGenerator.FetcherReadyCallback,
    Runnable,
    Comparable>,
    Poolable {
  ...
   @Override
  public void run() {
    ...
    try {
      if (isCancelled) {
        notifyFailed();
        return;
      }
      // 主流程代码
      runWrapped();
    } catch (Throwable t) {
      ...
    } 
      TraceCompat.endSection();
    }
  }

    private void runWrapped() {
     switch (runReason) {
      case INITIALIZE:
        stage = getNextStage(Stage.INITIALIZE);
        currentGenerator = getNextGenerator();
        runGenerators();
        break;
      case SWITCH_TO_SOURCE_SERVICE:
        runGenerators();
        break;
      case DECODE_DATA:
        decodeFromRetrievedData();
        break;
      default:
        throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
  }
  ...
}

24-35行，这里就是分步骤去相应的DataFetcherGenerator实例中去加载图片资源

class DecodeJob implements DataFetcherGenerator.FetcherReadyCallback,
    Runnable,
    Comparable>,
    Poolable {
  ...
  private DataFetcherGenerator getNextGenerator() {
    switch (stage) {
      case RESOURCE_CACHE:
        return new ResourceCacheGenerator(decodeHelper, this);
      case DATA_CACHE:
        return new DataCacheGenerator(decodeHelper, this);
      case SOURCE:
        return new SourceGenerator(decodeHelper, this);
      case FINISHED:
        return null;
      default:
        throw new IllegalStateException("Unrecognized stage: " + stage);
    }
  }
  ...
}

getNextGenerator()，用于计算当前加载处于哪一步，并返回相应的DataFetcherGenerator，

ResourceCacheGenerator 表示磁盘缓存图片资源，

DataCacheGenerator 表示磁盘处理后的缓存图片资源，

SourceGenerator 表示原始图片资源，

这里是第一次加载，所以缓存不存在，会返回SourceGenerator 实例，循环几次调用runGenerators()，当最后一次调用runGenerators()时，才是真正去加载图片

class DecodeJob implements DataFetcherGenerator.FetcherReadyCallback,
    Runnable,
    Comparable>,
    Poolable {
  ...
 
   private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    // startNext()里面加载图片
    while (!isCancelled && currentGenerator != null
        && !(isStarted = currentGenerator.startNext())) {
      stage = getNextStage(stage);
      currentGenerator = getNextGenerator();

      if (stage == Stage.SOURCE) {
        // 无缓存，再次执行run()
        reschedule();
        return;
      }
    }
    // We've run out of stages and generators, give up.
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
      notifyFailed();
    }

    // Otherwise a generator started a new load and we expect to be called back in
    // onDataFetcherReady.
  }
  ...
}

13行，这里就是去加载，currentGenerator.startNext()，DataFetcherGenerator接口定义了这么一个startNext()方法，它的实现类扩展这个方法，都是去加载图片的意思，不管是缓存图片还是网络图片

15-20行，用于获取加载步骤

24-26行，如果状态发生变化需要取消，就通知取消加载，最外面一层回调为加载失败

现在已经知道加载是SourceGenerator.startNext()，继续跟踪

class SourceGenerator implements DataFetcherGenerator,
    DataFetcher.DataCallback