Glide源码阅读理解一小时

Glide.with(fragment)
    .load(url)
    .into(imageView);

@GlideModule
public final class GlideModuleConfig extends AppGlideModule {
    @Override
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
        super.applyOptions(context, builder);
        long memoryCacheSizeBytes = 1024 * 1024 * 20;
        builder.setMemoryCache(new LruResourceCache(memoryCacheSizeBytes));
        long diskCacheSizeBytes = 1024 * 1024 * 100;
        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, diskCacheSizeBytes));
    }
}

@GlideModule
public final class OkHttpLibraryGlideModule extends LibraryGlideModule {
    @Override
    public void registerComponents(
            @NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
        //将GlideUrl数据转为InputStream的ModelLoader替换为Okhttp
        registry.replace(GlideUrl.class, InputStream.class, new OkHttpUrlLoader.Factory());
    }
}

final class GeneratedAppGlideModuleImpl extends GeneratedAppGlideModule {
    private final GlideModuleConfig appGlideModule;
    public GeneratedAppGlideModuleImpl(Context context) {
      appGlideModule = new GlideModuleConfig();
    }
    //GlideBuilder的配置项进行应用
    @Override
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
      appGlideModule.applyOptions(context, builder);
    }
    //注册自定义GlideModule
    @Override
    public void registerComponents(@NonNull Context context, @NonNull Glide glide,
        @NonNull Registry registry) {
      new OkHttpLibraryGlideModule().registerComponents(context, glide, registry);
      appGlideModule.registerComponents(context, glide, registry);
    }
    /***部分代码省略***/
}

public class Glide implements ComponentCallbacks2 {
    /**
    * Get the singleton.
    * @return the singleton
    */
    @NonNull
    public static Glide get(@NonNull Context context) {
        if (glide == null) {
            //
            GeneratedAppGlideModule annotationGeneratedModule = 
                getAnnotationGeneratedGlideModules(context.getApplicationContext());
            synchronized (Glide.class) {
                if (glide == null) {
                    checkAndInitializeGlide(context, annotationGeneratedModule);
                }
            }
        }
        return glide;
    }
    //通过Java反射机制获取通过注解生成的GeneratedAppGlideModuleImpl
    private static GeneratedAppGlideModule getAnnotationGeneratedGlideModules(Context context) {
        GeneratedAppGlideModule result = null;
        try {
        Class<GeneratedAppGlideModule> clazz =
            (Class<GeneratedAppGlideModule>)
                Class.forName("com.bumptech.glide.GeneratedAppGlideModuleImpl");
        result =
            clazz.getDeclaredConstructor(Context.class).newInstance(context.getApplicationContext());
        } catch (ClassNotFoundException e) {
        /***部分代码省略**/
        }
        return result;
    }
}

public class Glide implements ComponentCallbacks2 {
    @GuardedBy("Glide.class")
    private static void initializeGlide(
        @NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
        initializeGlide(context, new GlideBuilder(), generatedAppGlideModule);
    }
    @GuardedBy("Glide.class")
    @SuppressWarnings("deprecation")
    private static void initializeGlide(
        @NonNull Context context,
        @NonNull GlideBuilder builder,
        @Nullable GeneratedAppGlideModule annotationGeneratedModule) {
        Context applicationContext = context.getApplicationContext();
        List<com.bumptech.glide.module.GlideModule> manifestModules = Collections.emptyList();
        //如果Manifest文件中配置了GlideModule，并且annotationGeneratedModule允许Manifest文件中配置生效，那么需要解析出来
        if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
            manifestModules = new ManifestParser(applicationContext).parse();
        }
        //如果annotationGeneratedModule配置了扩展模块需要解析出来，并且不能与果Manifest中的重复
        if (annotationGeneratedModule != null
            && !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
            Set<Class<?>> excludedModuleClasses = annotationGeneratedModule.getExcludedModuleClasses();
            Iterator<com.bumptech.glide.module.GlideModule> iterator = manifestModules.iterator();
            while (iterator.hasNext()) {
                com.bumptech.glide.module.GlideModule current = iterator.next();
                if (!excludedModuleClasses.contains(current.getClass())) {
                    continue;
                }
                /***省略部分日志***/
                iterator.remove();
            }
        }
        /***省略部分日志***/
        //获取Request的构造管理工厂类
        RequestManagerRetriever.RequestManagerFactory factory =
            annotationGeneratedModule != null
                ? annotationGeneratedModule.getRequestManagerFactory()
                : null;
        builder.setRequestManagerFactory(factory);
        //Manifest中的配置项进行应用
        for (com.bumptech.glide.module.GlideModule module : manifestModules) {
            module.applyOptions(applicationContext, builder);
        }
        //annotationGeneratedModule进行配置项的应用
        if (annotationGeneratedModule != null) {
            annotationGeneratedModule.applyOptions(applicationContext, builder);
        }
        //构造Glide
        Glide glide = builder.build(applicationContext);
        //Manifest中的组件进行注册
        for (com.bumptech.glide.module.GlideModule module : manifestModules) {
            try {
                module.registerComponents(applicationContext, glide, glide.registry);
            } catch (AbstractMethodError e) {
                /***省略部分日志***/
            }
        }
        //annotationGeneratedModule中的组件进行注册
        if (annotationGeneratedModule != null) {
            annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
        }
        //application注册Glide组件
        applicationContext.registerComponentCallbacks(glide);
        Glide.glide = glide;
    }
}

public class Glide implements ComponentCallbacks2 {
    private final Engine engine;//负责启动负载以及管理活动和缓存的资源。
    private final BitmapPool bitmapPool;//Bitmap的缓存池（LruBitmapPool）
    private final MemoryCache memoryCache;//Resource缓存池（LruResourceCache）
    private final GlideContext glideContext;
    private final Registry registry;
    private final ArrayPool arrayPool;//存储大小可变的数组的缓存池(LruArrayPool)
    //一组静态方法用来创建一个新的RequestManager或者从已经存在的activity和fragment中获取
    private final RequestManagerRetriever requestManagerRetriever;
    private final ConnectivityMonitorFactory connectivityMonitorFactory;
    new Glide(
        @NonNull context,//上下文环境
        @NonNull engine,//任务执行引擎
        @NonNull memoryCache,//内存资源缓存
        @NonNull bitmapPool,//内存Bitmap缓存
        @NonNull arrayPool,//数据缓存池
        @NonNull requestManagerRetriever,//RequestManager管理集合
        @NonNull connectivityMonitorFactory,//网络监听器的生产工厂
        int logLevel,//log日志等级，默认为Log.info=4
        @NonNull defaultRequestOptionsFactory,//默认的RequestOptions生产工厂
        @NonNull defaultTransitionOptions,//默认的资源展现过渡配置容器，，默认map大小为0
        @NonNull defaultRequestListeners,//在图像加载时的监听器数组，默认数组大小为0
        boolean isLoggingRequestOriginsEnabled,//是否需要请求日志
        boolean isImageDecoderEnabledForBitmaps,//在安卓P或更高版本进行解码bitmap
        int hardwareBitmapFdLimit,//700,
        int minHardwareDimension){//128,
        /***部分代码省略***/
    }
}

public class Engine
    implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {
    /***部分代码省略***/
    public Engine(
        MemoryCache memoryCache,//内存缓存
        DiskCache.Factory diskCacheFactory,//磁盘缓存
        //磁盘缓存执行器，该线程池的核心线程数和最大线程数为1
        GlideExecutor diskCacheExecutor,
        //检索资源尚未在缓存中，该线程池的核心线程数和最大线程数为cpu内核数量，最大为4
        GlideExecutor sourceExecutor,
        ////newScheduledThreadPool，核心线程数为0，用来执行网络操作
        GlideExecutor sourceUnlimitedExecutor,
        //加载动画线程池，加载动画图像的帧时使用，尤其是GitDrawable，该线程池的核心线程数和最大线程数为1或2（cpu内核数量>=4）
        GlideExecutor animationExecutor,
        //活动资源是否允许被保留，默认为false
        boolean isActiveResourceRetentionAllowed) {
            /***部分代码省略***/
    }
    /***部分代码省略***/
}

public class Registry {
    public static final String BUCKET_GIF = "Gif";
    public static final String BUCKET_BITMAP = "Bitmap";
    public static final String BUCKET_BITMAP_DRAWABLE = "BitmapDrawable";
    private static final String BUCKET_PREPEND_ALL = "legacy_prepend_all";
    private static final String BUCKET_APPEND_ALL = "legacy_append";
    //维护{@link ModelLoader}的有序放置以及它们处理的模型和数据类型,从最高优先级到最低优先级的顺序。
    private final ModelLoaderRegistry modelLoaderRegistry;
    //编码数据容器，有序列表
    private final EncoderRegistry encoderRegistry;
    //包含能够解码任意数据类型的{@link ResourceDecoder}的有序列表
    //分为从最高优先级解码器到最低优先级解码器的任意资源类型。
    private final ResourceDecoderRegistry decoderRegistry;
    //包含能够编码任意资源*类型的{@link ResourceEncoder}的有序列表。
    private final ResourceEncoderRegistry resourceEncoderRegistry;
    //DataRewinder的生产工厂
    private final DataRewinderRegistry dataRewinderRegistry;
    //注册和转化ResourceTranscoder
    private final TranscoderRegistry transcoderRegistry;
    //包含能够解析图像标题的{@link ImageHeaderParser}的无序列表。
    private final ImageHeaderParserRegistry imageHeaderParserRegistry;
    //维护“模型+资源”类的高速缓存到一组已注册资源类的集合，这些资源类是可以从模型类中解码的资源类的子类。
    private final ModelToResourceClassCache modelToResourceClassCache = new ModelToResourceClassCache();
    //维护数据，资源和转码类的缓存
    private final LoadPathCache loadPathCache = new LoadPathCache();
    //异常列表维护容器
    private final Pool<List<Throwable>> throwableListPool = FactoryPools.threadSafeList();
    /***部分代码省略***/
}

//用于将数据写入某些持久性数据存储的接口，例如文件
public interface Encoder<T> {
    //将给定数据写入给定输出流，如果写入完成，则返回True
    boolean encode(@NonNull T data, @NonNull File file, @NonNull Options options);
}

//用于将数据从资源写入某些持久性数据存储的接口，例如文件
public interface ResourceEncoder<T> extends Encoder<Resource<T>> {
    //获取对应的策略模式
    @NonNull
    EncodeStrategy getEncodeStrategy(@NonNull Options options);
}
//ResourceEncoder进行资源编码缓存枚举
public enum EncodeStrategy {
    //将资源的原始未修改数据写入磁盘,不包括采样和转化
    SOURCE,
    //将资源的解码，下采样和转换后的数据写入磁盘。
    TRANSFORMED,
    /** Will write no data. */
    NONE,
}

/**
 *用于解码资源的接口。
 *@param <T>将从中解码资源的类型（文件，InputStream等）。
 *@param <Z>解码资源的类型（位图，可绘制等）。
 */
public interface ResourceDecoder<T, Z> {
    /**
     *如果此解码器能够使用给定的源解码给定的源，则返回true选项，否则为false。
     *解码器应尽最大努力快速确定是否可能够解码数据，但不应尝试完全读取给定的数据。
     *典型的实现将检查文件头，以确保它们与解码器期望的内容匹配句柄（即GIF解码器应验证图像是否包含GIF标头块)。
     */
    boolean handles(@NonNull T source, @NonNull Options options) throws IOException;
    //从给定的数据返回已解码的资源；如果无法解码任何资源，则返回null。
    //注意width和height参数仅是提示，没有要求解码后的资源与给定尺寸完全匹配。
    //一个典型的用例将使用目标尺寸来确定对位图进行降采样的量，以避免分配过多。
    @Nullable
    Resource<Z> decode(@NonNull T source, int width, int height, @NonNull Options options)throws IOException;
}

/**
 * 将一种类型的资源转码为另一种类型的资源。
 * @param <Z> 要被转码的资源类型
 * @param <R> 需要转成的资源类型
 */
public interface ResourceTranscoder<Z, R> {
    //将给定资源转码为新资源类型并返回新资源。
    @Nullable
    Resource<R> transcode(@NonNull Resource<Z> toTranscode, @NonNull Options options);
}

//com.bumptech.glide.load.model.MultiModelLoaderFactory
//通过仅在以下位置创建加载器来避免堆栈溢出递归地创建模型加载器
//递归请求（如果尚未在链中的早期创建）。例如：Uri加载程序可以转换为另一个模型，而后者又可以转换回Uri。
//尽管原始Uri加载程序不会提供给中间模型加载程序，其他的Uri装载程序也会。
synchronized <Model> List<ModelLoader<Model, ?>> build(@NonNull Class<Model> modelClass) {
    try {
        List<ModelLoader<Model, ?>> loaders = new ArrayList<>();
        for (Entry<?, ?> entry : entries) {
            if (alreadyUsedEntries.contains(entry)) {//去重
                continue;
            }
            if (entry.handles(modelClass)) {
                alreadyUsedEntries.add(entry);
                //递归调用MultiModelLoaderFactory.build
                loaders.add(this.<Model, Object>build(entry));
                alreadyUsedEntries.remove(entry);
            }
        }
        return loaders;
    } catch (Throwable t) {
        alreadyUsedEntries.clear();
        throw t;
    }
}
//调用ModelLoaderFactory.build
private <Model, Data> ModelLoader<Model, Data> build(@NonNull Entry<?, ?> entry) {
    return (ModelLoader<Model, Data>) Preconditions.checkNotNull(entry.factory.build(this));
}

public static class StreamFactory implements ModelLoaderFactory<String, InputStream> {
    @NonNull
    @Override
    public ModelLoader<String, InputStream> build(@NonNull MultiModelLoaderFactory multiFactory) {
        return new StringLoader<>(multiFactory.build(Uri.class, InputStream.class));
    }
    @Override
    public void teardown() {
      // Do nothing.
    }
}

//com.bumptech.glide.load.model.MultiModelLoaderFactory
public synchronized <Model, Data> ModelLoader<Model, Data> build(
      @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass) {
    try {
        List<ModelLoader<Model, Data>> loaders = new ArrayList<>();
        boolean ignoredAnyEntries = false;
        for (Entry<?, ?> entry : entries) {
            if (alreadyUsedEntries.contains(entry)) {//去重
                ignoredAnyEntries = true;
                continue;
            }
            if (entry.handles(modelClass, dataClass)) {
                alreadyUsedEntries.add(entry);
                //递归调用MultiModelLoaderFactory.build
                loaders.add(this.<Model, Data>build(entry));
                alreadyUsedEntries.remove(entry);
            }
        }
        if (loaders.size() > 1) {//数量大于1的时候构建MultiModelLoader存储loaders
            return factory.build(loaders, throwableListPool);
        } else if (loaders.size() == 1) {
            return loaders.get(0);
        } else {
            //如果递归导致没有可用的加载程序，请避免崩溃。该断言应该捕获完全未处理的类型，递归可能意味着未在某处处理子类型进入堆栈，这通常是可以的。 
            if (ignoredAnyEntries) {
                return emptyModelLoader();
            } else {
                throw new NoModelLoaderAvailableException(modelClass, dataClass);
            }
        }
    } catch (Throwable t) {
        alreadyUsedEntries.clear();
        throw t;
    }
}

public enum DataSource {
    //表示数据可能是从设备本地检索的，尽管可能已经是通过可能已从远程源获取数据的内容提供者获得的。
    LOCAL,
    //表示从设备以外的远程源检索到数据。
    REMOTE,
    //表示从设备缓存中检索的数据未经修改。
    DATA_DISK_CACHE,
    //表示数据是从设备上缓存中的已修改内容中检索到的。
    RESOURCE_DISK_CACHE,
    //表示已从内存缓存中检索数据。
    MEMORY_CACHE,
}

/**
 * 懒惰地检索可用于加载资源的数据。
 * @param <T> 要加载的数据类型  (InputStream, byte[], File etc).
 */
public interface DataFetcher<T> {
    //获取可以从中解码资源的数据。
    //没有数据的时候调用，异步线程执行，io不会阻塞
    void loadData(@NonNull Priority priority, @NonNull DataCallback<? super T> callback);
    //清理或回收此数据获取器使用的任何资源。
    void cleanup();
    //取消任务
    void cancel();
    //返回此访存器将尝试获取的数据的类。
    @NonNull
    Class<T> getDataClass();
    //返回要处理的资源数据类型
    @NonNull
    DataSource getDataSource();
}

public interface ModelLoaderFactory<T, Y> {
    //为此模型类型构建一个具体的ModelLoader。
    @NonNull
    ModelLoader<T, Y> build(@NonNull MultiModelLoaderFactory multiFactory);
    //一种生命周期方法，该工厂即将被替换时将被调用。
    void teardown();
}

/**
 *工厂接口，用于将任意复杂的数据模型转换为具体的数据类型,DataFetcher可以使用来获取由模型。
 *此接口有两个目标：
 *1.将特定模型转换为可以被解码为资源。
 *2.允许将模型与视图的尺寸组合以获取模型的资源具体尺寸。
 *这不仅避免了必须在xml和代码中重复尺寸，以便确定具有不同密度的设备上视图的大小，
 *但也允许您使用布局权重或通过编程方式放置视图的尺寸而不会强迫您获取通用资源大小。
 *您获取的资源越小，使用的带宽和电池寿命越少，并且越低每个资源的内存占用量。
 *
 *@param <Model> 模型的类型。
 *@param <Data> 可以使用的数据类型ResourceDecoder来解码资源。
 */
public interface ModelLoader<Model, Data> {
    //返回可以解码model的LoadData来进行资源解码
    //注意-如果无法返回有效的数据提取程序（例如，如果模型的URL为空），然后可以从此方法返回空数据获取程序。
    @Nullable
    LoadData<Data> buildLoadData(@NonNull Model model, int width, int height, @NonNull Options options);
    //当前的数据模型是否能被处理
    boolean handles(@NonNull Model model);
}

//包含一组标识负载源的keys，指向等效数据的备用缓存键以及DataFetcher，可用于获取在缓存中找不到的数据。
class LoadData<Data> {
  public final Key sourceKey;//数据源标识
  public final List<Key> alternateKeys;//备用的标识
  public final DataFetcher<Data> fetcher;//可用于加载资源的数据
  public LoadData(@NonNull Key sourceKey, @NonNull DataFetcher<Data> fetcher) {
    this(sourceKey, Collections.<Key>emptyList(), fetcher);
  }
  public LoadData(
    @NonNull Key sourceKey,
    @NonNull List<Key> alternateKeys,
    @NonNull DataFetcher<Data> fetcher) {
    this.sourceKey = Preconditions.checkNotNull(sourceKey);
    this.alternateKeys = Preconditions.checkNotNull(alternateKeys);
    this.fetcher = Preconditions.checkNotNull(fetcher);
  }
}

DataUrlLoader.StreamFactory.build=DataUrlLoader
  
StringLoader.StreamFactory.build
  =MultiModelLoaderFactory(Uri.class, InputStream.class)=MultiModelLoader
  ==>DataUrlLoader.StreamFactory=DataUrlLoader
  ==>HttpUriLoader.Factory=HttpUriLoader
  ==>==>MultiModelLoaderFactory(Uri.class, ParcelFileDescriptor.class)
  ==>==>==>AssetUriLoader.FileDescriptorFactory=AssetUriLoader
  ==>==>==>UriLoader.FileDescriptorFactory=AssetUriLoader
  ==>==>==>AssetUriLoader(去重)
  ==>AssetUriLoader.StreamFactory=AssetUriLoader
  ==>MediaStoreImageThumbLoader.Factory=MediaStoreImageThumbLoader
  ==>MediaStoreVideoThumbLoader.Factory=MediaStoreVideoThumbLoader
  ==>UriLoader.StreamFactory=AssetUriLoader
  ==>UrlUriLoader.StreamFactory
  ==>==>MultiModelLoaderFactory(GlideUrl.class, InputStream.class)
  ==>==>==>HttpGlideUrlLoader.Factory=HttpGlideUrlLoader
  
StringLoader.FileDescriptorFactory.build
  =MultiModelLoaderFactory(Uri.class, ParcelFileDescriptor.class)=MultiModelLoader
  ==>AssetUriLoader.FileDescriptorFactory=AssetUriLoader
  ==>UriLoader.FileDescriptorFactory=UriLoader
  
StringLoader.AssetFileDescriptorFactory.build
  =MultiModelLoaderFactory(Uri.class, AssetFileDescriptor.class)
  =UriLoader.AssetFileDescriptorFactory=UriLoader

StringLoader.StreamFactory=MultiModelLoader[7]
StringLoader.FileDescriptorFactory=MultiModelLoader[2]
StringLoader.AssetFileDescriptorFactory=UriLoader

//唯一标识某些数据放置的接口。
public interface Key {
    String STRING_CHARSET_NAME = "UTF-8";
    Charset CHARSET = Charset.forName(STRING_CHARSET_NAME);
    //将所有唯一标识信息添加到给定的摘要中。
    void updateDiskCacheKey(@NonNull MessageDigest messageDigest);
    @Override
    boolean equals(Object o);
    @Override
    int hashCode();
}
//用于在实现资源上执行任意转换的类
//equals和hashCode来标识内存缓存中的转换
//updateDiskCacheKey来标识磁盘中的转换缓存。
public interface Transformation<T> extends Key {
    //转换给定资源并返回转换后的资源
    @NonNull
    Resource<T> transform(@NonNull Context context, @NonNull Resource<T> resource, int outWidth, int outHeight);
}

public interface DataRewinder<T> {
    interface Factory<T> {
      @NonNull
      DataRewinder<T> build(@NonNull T data);
      @NonNull
      Class<T> getDataClass();
    }
    //将包装的数据回退到实例化此对象时的位置，然后返回重新包装的数据
    @NonNull
    T rewindAndGet() throws IOException;
    //当不再需要该复卷机并可以对其进行清理时调用。
    void cleanup();
}

//包装视图的目标将能够提供所有必要的参数并开始过渡。
public interface Transition<R> {
    //包含视图的接口，该视图公开了运行各种类型的必需的方法
    //Glide中所有ViewTarget的子类都实现了该接口
    interface ViewAdapter {
        //返回包装的view
        View getView();
        //返回在视图中显示的当前可绘制对象；如果不存在这样的可绘制对象，则返回null（或无法检索）。
        @Nullable
        Drawable getCurrentDrawable();
        //设置当前可绘制对象（通常是动画可绘制对象）以在包装视图中显示。
        void setDrawable(Drawable drawable);
    }
    //从当前正在使用的上一个Drawable进行动画处理在给定视图中显示，
    //如果在运行过渡过程中将新资源放在视图中，则为True，
    //如果调用者需要手动将当前资源放在视图上，则为false。
    boolean transition(R current, ViewAdapter adapter);
}
//一个工厂类，可以根据请求的状态产生不同的Transition
public interface TransitionFactory<R> {
    //返回一个新的Transition
    //isFirstResource如果这是要加载到目标中的第一个资源，则为True。
    Transition<R> build(DataSource dataSource, boolean isFirstResource);
}

Glide.with(context)
    .load(myUrl)
    .into(imageView);

Glide.with(context)

//com.bumptech.glide.Glide.java
@NonNull
public static RequestManager with(@NonNull Context context) {
    return getRetriever(context).get(context);
}

//用于管理和启动对Glide的请求的类。可以使用活动，片段和连接性生命周期事件智能地停止，启动和重新启动请求。
//通过实例化一个新对象或利用Activity和Fragment生命周期内置的处理功能进行检索，请对Fragment或Activity使用静态Glide.load方法。
public class RequestManager
    implements ComponentCallbacks2, LifecycleListener, ModelTypes<RequestBuilder<Drawable>> {
    /***代码全都省略***/
}

public interface LifecycleListener {
    void onStart();//fragmetn或者activity的onstart
    void onStop();//fragmetn或者activity的onstop
    void onDestroy();//fragmetn或者activity的ondestroy
}

interface ModelTypes<T> {
    @NonNull
    @CheckResult
    T load(@Nullable Bitmap bitmap);
    T load(@Nullable Drawable drawable);
    T load(@Nullable String string);
    T load(@Nullable Uri uri);
    T load(@Nullable File file);
    T load(@RawRes @DrawableRes @Nullable Integer resourceId);
    T load(@Nullable URL url);
    T load(@Nullable byte[] model);
    T load(@Nullable Object model);
}

//com.bumptech.glide.manager.RequestManagerRetriever.java
//Application的生命周期单独管理
private volatile RequestManager applicationManager;
//一个是support包，一个是Android的api，RequestManagerFragment的临时存储
//RequestManagerFragment用来管理RequestManager和同步生命周期
final Map<android.app.FragmentManager, RequestManagerFragment> pendingRequestManagerFragments = new HashMap<>();
final Map<FragmentManager, SupportRequestManagerFragment> pendingSupportRequestManagerFragments = new HashMap<>();
public RequestManager get(@NonNull Context context) {
    if (context == null) {
        throw new IllegalArgumentException("You cannot start a load on a null Context");
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
        if (context instanceof FragmentActivity) {//FragmentActivity
            return get((FragmentActivity) context);
        } else if (context instanceof Activity) {//Activity
            return get((Activity) context);
        } else if (context instanceof ContextWrapper//找到context的basecontext
            && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
            return get(((ContextWrapper) context).getBaseContext());
        }
    }
    return getApplicationManager(context);
}

public RequestManager get(@NonNull Fragment fragment) {
    Preconditions.checkNotNull(fragment.getContext(),"fragment必须被attch，不能被destroy");
    if (Util.isOnBackgroundThread()) {//如果应用在后台，那么切换为Application
        return get(fragment.getContext().getApplicationContext());
    } else {
        FragmentManager fm = fragment.getChildFragmentManager();
        return supportFragmentGet(fragment.getContext(), fm, fragment, fragment.isVisible());
    }
}
private RequestManager supportFragmentGet(
      @NonNull Context context,
      @NonNull FragmentManager fm,
      @Nullable Fragment parentHint,
      boolean isParentVisible) {
    //获取当前上下文中的SupportRequestManagerFragment
    SupportRequestManagerFragment current =
        getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
    //获取SupportRequestManagerFragment的RequestManager
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
        //给新创建的SupportRequestManagerFragment添加RequestManager
        Glide glide = Glide.get(context);
        requestManager =
            factory.build(
                glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
        current.setRequestManager(requestManager);
    }
    return requestManager;
}
private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, @Nullable Fragment parentHint, boolean isParentVisible) {
    //先看看当前的FragmentManager中有没有SupportRequestManagerFragment，有就复用
    SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
        //pendingSupportRequestManagerFragments，只是一个临时性的存储,因为每次put之后必定会remove
        //因为add之后立即进行findFragmentByTag是获取不到的，所以需要临时存储
        current = pendingSupportRequestManagerFragments.get(fm);
        if (current == null) {
            //创建新的SupportRequestManagerFragment
            current = new SupportRequestManagerFragment();
            current.setParentFragmentHint(parentHint);  
            //如果fragment已经展示，那么添加的SupportRequestManagerFragment也要同步生命周期
            if (isParentVisible) {
                current.getGlideLifecycle().onStart();
            }
            //添加临时存储
            pendingSupportRequestManagerFragments.put(fm, current);
            //创建的SupportRequestManagerFragment添加到FragmentManager中
            fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
            //删除临时存储
            handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
        }
    }
    return current;
}

public interface Target<R> extends LifecycleListener {
    //表示我们希望资源保持其原始的未修改宽度和/或高度
    int SIZE_ORIGINAL = Integer.MIN_VALUE;
    //开始加载
    void onLoadStarted(@Nullable Drawable placeholder);
    //加载失败
    void onLoadFailed(@Nullable Drawable errorDrawable);
    //资源加载完成时将调用的方法。
    void onResourceReady(@NonNull R resource, @Nullable Transition<? super R> transition);
    //在取消负载及其资源释放时调用
    void onLoadCleared(@Nullable Drawable placeholder);
    //一种检索此目标大小的方法
    void getSize(@NonNull SizeReadyCallback cb);
    //如果给定的回调仍保留，则将其从待处理集中删除
    void removeCallback(@NonNull SizeReadyCallback cb);
    //设置为此目标保留的当前请求
    void setRequest(@Nullable Request request);
    //检索对此目标的当前请求
    @Nullable
    Request getRequest();
}

Glide.with(context)
    .load(myUrl)

//com.bumptech.glide.RequestManager.java
public RequestBuilder<Drawable> load(@Nullable String string) {
    return asDrawable().load(string);
}

//com.bumptech.glide.RequestManager.java
public RequestBuilder<Drawable> asDrawable() {
    return as(Drawable.class);
}
public <ResourceType> RequestBuilder<ResourceType> as(
      @NonNull Class<ResourceType> resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
}

//com.bumptech.glide.RequestBuilder.java
public RequestBuilder<TranscodeType> load(@Nullable String string) {
    return loadGeneric(string);
}
private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
}

Glide.with(context)
    .load(myUrl)
    .into(imageView);

public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);
    BaseRequestOptions<?> requestOptions = this;
    //下面是根据view修改requestOptions的属性
    if (!requestOptions.isTransformationSet()
        && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
      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,
        Executors.mainThreadExecutor());
}

public class GlideContext extends ContextWrapper {
    public <X> ViewTarget<ImageView, X> buildImageViewTarget(
        @NonNull ImageView imageView, @NonNull Class<X> transcodeClass) {
        return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
    }
    /***部分代码省略***/
}
public class ImageViewTargetFactory {
    @NonNull
    @SuppressWarnings("unchecked")
    public <Z> ViewTarget<ImageView, Z> buildTarget(
        @NonNull ImageView view, @NonNull Class<Z> clazz) {
        if (Bitmap.class.equals(clazz)) {
            return (ViewTarget<ImageView, Z>) new BitmapImageViewTarget(view);
        } else if (Drawable.class.isAssignableFrom(clazz)) {
            return (ViewTarget<ImageView, Z>) new DrawableImageViewTarget(view);
        } else {
            throw new IllegalArgumentException(
            "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
      }
    }
}

private <Y extends Target<TranscodeType>> Y into(
      @NonNull Y target,
      @Nullable RequestListener<TranscodeType> targetListener,
      BaseRequestOptions<?> options,
      Executor callbackExecutor) {
    Preconditions.checkNotNull(target);
    //检测是否设置了model
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }
    //创建请求,Executors.mainThreadExecutor()标识callback在主线程
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
    Request previous = target.getRequest();
    //如果target上的当前请求与上一次的相同，且请求缓存磁盘并且上一个请求为完成时使用上一个请求
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      //如果请求已完成，请重新开始，以确保重新发送结果，触发RequestListeners和Targets。
      //如果请求失败，将重新开始重新启动请求，使它有另一个完成的机会。
      //如果请求已经正在运行，我们可以让它继续运行而不会受到干扰。
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        //使用上一个请求而不是新请求来进行优化，例如跳过设置占位符，跟踪和取消跟踪目标并获取视图尺寸在单独的请求中完成。 
        previous.begin();
      }
      return target;
    }
    //清除target之前的请求
    requestManager.clear(target);
    //给target设置新的请求
    target.setRequest(request);
    //target同步requestmanager的声明周期，并将request添加到请求列表
    requestManager.track(target, request);
    return target;
}
private boolean isSkipMemoryCacheWithCompletePreviousRequest(
    BaseRequestOptions<?> options, Request previous) {
    return !options.isMemoryCacheable() && previous.isComplete();
}

public interface Request {
    void begin();//开始异步加载
    //防止从以前的请求中加载任何位图，释放由此持有的任何资源请求，并将该请求标记为具有已取消。
    void clear();
    //暂停请求
    void pause();
    //如果此请求正在运行并且尚未完成或失败，则返回true。
    boolean isRunning();
    //如果请求成功完成，则返回true
    boolean isComplete();
    //如果请求已清除，则返回true
    boolean isCleared();
    //判断两个请求是否相同
    boolean isEquivalentTo(Request other);
}

Request request = buildRequest(target, targetListener, options, callbackExecutor);

public interface SizeReadyCallback {
    void onSizeReady(int width, int height);
}

public interface ResourceCallback {
  //成功加载资源时调用。
  void onResourceReady(Resource<?> resource, DataSource dataSource);
  //当资源无法成功加载时调用。
  void onLoadFailed(GlideException e);
  //返回通知单个请求时要使用的锁
  Object getLock();
}

//com.bumptech.glide.RequestManager
//对request进行追踪，默认的new RequestTracker()；
private final RequestTracker requestTracker；
//对target进行追踪
private final TargetTracker targetTracker = new TargetTracker();
synchronized void track(@NonNull Target<?> target, @NonNull Request request) {
    //添加到RequestManger的target追踪容器中
    targetTracker.track(target);
    //运行request
    requestTracker.runRequest(request);
}

//com.bumptech.glide.manager.RequestTracker
public void runRequest(@NonNull Request request) {
    //添加到请求容器中
    requests.add(request);
    //如果当前的RequestManager不处于暂停状态，那么直接开始请求
    if (!isPaused) {
        request.begin();
    } else {
        //否则延迟该请求
        request.clear();
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Paused, delaying request");
        }
         pendingRequests.add(request);
    }
}

//com.bumptech.glide.manager.RequestTracker
@Override
public void begin() {
    synchronized (requestLock) {
        assertNotCallingCallbacks();//如果已经进行了回调，那么抛异常
        stateVerifier.throwIfRecycled();//如果任务已经被回收，那么抛异常
        startTime = LogTime.getLogTime();
        if (model == null) {
            //校验宽高是否有效
            if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
                width = overrideWidth;
                height = overrideHeight;
            }
            //详细的日志级别进行记录
            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 (status == Status.COMPLETE) {
            onResourceReady(resource, DataSource.MEMORY_CACHE);
            return;
        }
        //重新启动既未完成也未运行的请求，可以视为新请求并可以从头开始再次运行。
        status = Status.WAITING_FOR_SIZE;
        if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
           onSizeReady(overrideWidth, overrideHeight);//内部有请求资源的实现方法调用
        } else {
           target.getSize(this);//重新回调onSizeReady方法
        }
        //加载占位图
        if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
            && canNotifyStatusChanged()) {
            target.onLoadStarted(getPlaceholderDrawable());
        }
    }
}

//com.bumptech.glide.request.SingleRequest
@Override
public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();//如果任务已经被回收，那么抛异常
    synchronized (requestLock) {//加锁，进行数据请求
        if (status != Status.WAITING_FOR_SIZE) {//必须size确定
            return;
        }
        status = Status.RUNNING;//进入运行状态
        //在加载资源之前，对Target的大小应用乘数。对于加载缩略图或避免加载大量资源非常有用。默认为1f。
        float sizeMultiplier = requestOptions.getSizeMultiplier();
        this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
        this.height = maybeApplySizeMultiplier(height, sizeMultiplier);
        loadStatus =
                engine.load(
                        glideContext,
                        model,//myUrl
                        requestOptions.getSignature(),//缓存签名，默认为EmptySignature
                        this.width,
                        this.height,
                        requestOptions.getResourceClass(),//不设置decode的话，默认为Object
                        transcodeClass,//Drawable.class
                        priority,
                        requestOptions.getDiskCacheStrategy(),
                        requestOptions.getTransformations(),
                        requestOptions.isTransformationRequired(),
                        requestOptions.isScaleOnlyOrNoTransform(),
                        requestOptions.getOptions(),
                        requestOptions.isMemoryCacheable(),
                        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
                        requestOptions.getUseAnimationPool(),
                        requestOptions.getOnlyRetrieveFromCache(),
                        this,
                        callbackExecutor);
        /***部分代码省略***/
    }
}

//com.bumptech.glide.load.engine.Engine
public <R> LoadStatus load(/***部分代码省略***/) {
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;
    EngineKey key = //构造缓存的key
            keyFactory.buildKey(
                    model,//数据myUrl
                    signature,//签名
                    width,
                    height,
                    transformations,//转变
                    resourceClass,//Object.class
                    transcodeClass,//Drawable.class
                    options);
    EngineResource<?> memoryResource;
    synchronized (this) {
        //先从缓存中加载
        memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);
        if (memoryResource == null) {
            return waitForExistingOrStartNewJob(/***部分代码省略***/);
        }
    }
    //回调可以并发，不需要进行锁操作
    cb.onResourceReady(memoryResource, DataSource.MEMORY_CACHE);
    return null;
}

private EngineResource<?> loadFromMemory(EngineKey key, boolean isMemoryCacheable, long startTime) {
    if (!isMemoryCacheable) {//如果不允许使用内存，那么直接返回null
        return null;
    }
    EngineResource<?> active = loadFromActiveResources(key);//获取活跃的资源
    if (active != null) {
        return active;
    }
    EngineResource<?> cached = loadFromCache(key);//获取内存缓存中的资源
    if (cached != null) {
        return cached;
    }
    return null;
}

private EngineResource<?> loadFromActiveResources(Key key) {
    EngineResource<?> active = activeResources.get(key);
    if (active != null) {
        active.acquire();
    }
    return active;
}

private EngineResource<?> loadFromCache(Key key) {
    EngineResource<?> cached = getEngineResourceFromCache(key);
    if (cached != null) {
        cached.acquire();
        activeResources.activate(key, cached);
    }
    return cached;
}
private EngineResource<?> getEngineResourceFromCache(Key key) {
    Resource<?> cached = cache.remove(key);
    final EngineResource<?> result;
    if (cached == null) {
        result = null;
    } else if (cached instanceof EngineResource) {
        result = (EngineResource<?>) cached;
    } else {
        result = new EngineResource<>(cached, true, true, key, this);
    }
    return result;
}
@Override
public void onResourceReleased(Key cacheKey, EngineResource<?> resource) {
    activeResources.deactivate(cacheKey);
    if (resource.isMemoryCacheable()) {
        cache.put(cacheKey, resource);
    } else {
        resourceRecycler.recycle(resource);
    }
}

private <R> LoadStatus waitForExistingOrStartNewJob(/***部分代码省略***/) {
    EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);//从hashmap中获取加载key的工作引擎
    if (current != null) {//如果已经存在那么直接返回
        current.addCallback(cb, callbackExecutor);
        return new LoadStatus(cb, current);
    }
    EngineJob<R> engineJob = //通过添加和删除负载的回调并在负载完成时通知回调来管理负载的类。
            engineJobFactory.build(/***部分代码省略***/);
    DecodeJob<R> decodeJob = //负责从缓存的数据或原始源解码资源，并应用转换和转码。
            decodeJobFactory.build(/***部分代码省略***/);
    jobs.put(key, engineJob);//添加到hashmap中
    engineJob.addCallback(cb, callbackExecutor);//添加回调信息
    engineJob.start(decodeJob);//开始工作
    return new LoadStatus(cb, engineJob);
}

//com.bumptech.glide.load.engine.EngineJob
public synchronized void start(DecodeJob<R> decodeJob) {
    this.decodeJob = decodeJob;
    //根据磁盘缓存策略，判断使用哪个线程池执行任务
    GlideExecutor executor = decodeJob.willDecodeFromCache() ? diskCacheExecutor : getActiveSourceExecutor();
    executor.execute(decodeJob);
}

//com.bumptech.glide.load.engine.DecodeJob
public void run() {
    /***部分代码省略***/
    DataFetcher<?> localFetcher = currentFetcher;
    try {
        if (isCancelled) {//如果任务已经取消，那么进行失败回调
            notifyFailed();
            return;
        }
        runWrapped();//开始执行任务
    } catch (CallbackException e) {
        //如果不受Glide控制的回调引发异常，则应避免使用Glide下面的特定调试逻辑。 
    } catch (Throwable t) {
        //通知失败，进行失败回调，抛出异常
    } finally {
        if (localFetcher != null) {
            localFetcher.cleanup();
        }
        GlideTrace.endSection();
    }
}

//com.bumptech.glide.load.engine.DecodeJob
private enum RunReason {
    //初始化
    INITIALIZE,
    //切换执行服务
    SWITCH_TO_SOURCE_SERVICE,
    //获取数据之后的资源编解码
    DECODE_DATA,
}
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);
    }
}

public static final DiskCacheStrategy AUTOMATIC =
    new DiskCacheStrategy() {
        @Override
        public boolean isDataCacheable(DataSource dataSource) {
            return dataSource == DataSource.REMOTE;
        }
        @Override
        public boolean isResourceCacheable(
            boolean isFromAlternateCacheKey, DataSource dataSource, EncodeStrategy encodeStrategy) {
            return ((isFromAlternateCacheKey && dataSource == DataSource.DATA_DISK_CACHE)
                    || dataSource == DataSource.LOCAL)
                && encodeStrategy == EncodeStrategy.TRANSFORMED;
        }
        @Override
        public boolean decodeCachedResource() {
            return true;
        }
        @Override
        public boolean decodeCachedData() {
            return true;
        }
    };

//com.bumptech.glide.load.engine.DecodeJob
private Stage getNextStage(Stage current) {
    switch (current) {
        case INITIALIZE://AUTOMATIC默认为true，所以初始化的第一步应该检测Stage.RESOURCE_CACHE
            return diskCacheStrategy.decodeCachedResource()
                ? Stage.RESOURCE_CACHE
                : getNextStage(Stage.RESOURCE_CACHE);
        case RESOURCE_CACHE://AUTOMATIC默认为true，所以初始化的下一步应该检测Stage.DATA_CACHE
            return diskCacheStrategy.decodeCachedData()
                ? Stage.DATA_CACHE
                : getNextStage(Stage.DATA_CACHE);
        case DATA_CACHE:////如果用户选择仅从缓存中检索资源，则从源跳过加载。否则应该检测Stage.SOURCE
            return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
        case SOURCE:
        case FINISHED:
            return Stage.FINISHED;
        default:
            throw new IllegalArgumentException("Unrecognized stage: " + current);
    }
}

//com.bumptech.glide.load.engine.DecodeJob
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);
    }
}

interface DataFetcherGenerator {
    //尝试使用一个新的DataFetcher，则返回true已启动，否则为false。
    boolean startNext();
    //尝试取消当前正在运行的提取程序
    void cancel();
}

interface DataCallback<T> {
    //如果加载成功，则使用加载的数据进行调用；如果加载失败，则使用null进行调用。
    void onDataReady(@Nullable T data);
    //加载失败时调用
    void onLoadFailed(@NonNull Exception e);
}

//com.bumptech.glide.load.engine.EngineJob
private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    while (!isCancelled && currentGenerator != null 
        && !(isStarted = currentGenerator.startNext())) {//执行当前数据构造的判断是否能加载数据
        stage = getNextStage(stage);//切换数据状态
        currentGenerator = getNextGenerator();//获取新的数据构造器
        if (stage == Stage.SOURCE) {//需要需要进行源数据加载那么切换执行线程
            reschedule();
            return;
        }
    }
    //如果已经完成或者取消，而且没开始获取数据。那么通知失败
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
        notifyFailed();
    }
    //否则，生成器将开始新的加载，我们希望将其调回onDataFetcherReady。
}

class ResourceCacheGenerator implements DataFetcherGenerator, DataFetcher.DataCallback<Object> {    
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        List<Key> sourceIds = helper.getCacheKeys();//能处理Model（myUrl）的LoadData列表，返回其Key
        if (sourceIds.isEmpty()) {//如果没有，那么标示Model（myUrl）这个数据类型无法处理，直接返回false
            return false;
        }
        //获取glide中注册的，能加载Model（url），能解码resourceClass（Drawable），能转码transcodeClass(Object)的组件集合
        List<Class<?>> resourceClasses = helper.getRegisteredResourceClasses();
        if (resourceClasses.isEmpty()) {//如果没有适配的组件集合，而且转码的类型为文件的话那么抛异常。因为File都不能转码那么根本无法磁盘缓存
            if (File.class.equals(helper.getTranscodeClass())) {
                return false;
            }
            throw new IllegalStateException(/***部分代码省略***/);
        }
        while (modelLoaders == null || !hasNextModelLoader()) {//如果还有modelLoader
            resourceClassIndex++;
            //双重判断使LoadData列表进行完全遍历
            if (resourceClassIndex >= resourceClasses.size()) {
                sourceIdIndex++;
                if (sourceIdIndex >= sourceIds.size()) {
                    return false;
                }
                resourceClassIndex = 0;
            }
            Key sourceId = sourceIds.get(sourceIdIndex);
            Class<?> resourceClass = resourceClasses.get(resourceClassIndex);
            Transformation<?> transformation = helper.getTransformation(resourceClass);
            //ResourceCacheKey用于下采样和转换的资源数据的缓存密钥+任何请求的签名。
            currentKey =
                new ResourceCacheKey(
                    helper.getArrayPool(),
                    sourceId,//modelLoaddata
                    helper.getSignature(),//签名
                    helper.getWidth(),//宽
                    helper.getHeight(),//高
                    transformation,//转换
                    resourceClass,//解码
                    helper.getOptions());
            cacheFile = helper.getDiskCache().get(currentKey);
            //判断Resource是否有缓存，如果有那么加载这个缓存文件数据
            if (cacheFile != null) {
                sourceKey = sourceId;
                modelLoaders = helper.getModelLoaders(cacheFile);//获取能加载文件的ModelLoader列表
                modelLoaderIndex = 0;
            }
        }
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {
            ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
            //ModelLoader根据cacheFile，width，height，options构造LoadData
            loadData = modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
            //该LoadData是否被Glide进行加载过，是否可用
            if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }

        return started;
    }
    @Override
    public void cancel() {
        LoadData<?> local = loadData;
        if (local != null) {
            local.fetcher.cancel();
        }
    }
    @Override//数据已经准备好，标识数据源为RESOURCE_DISK_CACHE
    public void onDataReady(Object data) {
        cb.onDataFetcherReady(
            sourceKey, data, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE, currentKey);
    }
    @Override//加载失败，标识数据源为RESOURCE_DISK_CACHE
    public void onLoadFailed(@NonNull Exception e) {
        cb.onDataFetcherFailed(currentKey, e, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE);
    }
}

class DataCacheGenerator implements DataFetcherGenerator, DataFetcher.DataCallback<Object> {
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        //如果还有modelLoader
        while (modelLoaders == null || !hasNextModelLoader()) {
            sourceIdIndex++;
            //cacheKyes（helper.getCacheKeys）在构造的时候传入，和ResourceCacheGenerator的相同
            if (sourceIdIndex >= cacheKeys.size()) {
                return false;
            }
            Key sourceId = cacheKeys.get(sourceIdIndex);
            //原始源数据的缓存键和任何请求的签名。
            Key originalKey = new DataCacheKey(sourceId, helper.getSignature());
            cacheFile = helper.getDiskCache().get(originalKey);
            //判断Resource是否有缓存，如果有那么加载这个缓存文件数据
            if (cacheFile != null) {
                this.sourceKey = sourceId;
                modelLoaders = helper.getModelLoaders(cacheFile);//获取能加载文件的ModelLoader列表
                modelLoaderIndex = 0;
            }
        }
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {
            ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
            //ModelLoader根据cacheFile，width，height，options构造LoadData
            loadData = modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
            //该LoadData是否被Glide进行加载过，是否可用
            if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }
        return started;
    }
    @Override
    public void onDataReady(Object data) {//数据已经准备好，标识数据源为DATA_DISK_CACHE
        cb.onDataFetcherReady(sourceKey, data, loadData.fetcher, DataSource.DATA_DISK_CACHE, sourceKey);
    }
    @Override
    public void onLoadFailed(@NonNull Exception e) {//加载失败，标识数据源为DATA_DISK_CACHE
        cb.onDataFetcherFailed(sourceKey, e, loadData.fetcher, DataSource.DATA_DISK_CACHE);
    }
}

class SourceGenerator implements DataFetcherGenerator,DataFetcher.DataCallback<Object>,
                DataFetcherGenerator.FetcherReadyCallback {
    private DataCacheGenerator sourceCacheGenerator;//磁盘缓存的数据构造器
    private Object dataToCache;//需要缓存的数据
    private DataCacheKey originalKey;//磁盘缓存的key
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        if (dataToCache != null) {//是否已经拥有缓存的数据
            Object data = dataToCache;
            dataToCache = null;
            cacheData(data);//进行据缓存，缓存后sourceCacheGenerator不为空
        }
        //由SourceGenerator转到DataCacheGenerator（网络转磁盘）
        if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
            return true;
        }
        sourceCacheGenerator = null;
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {//如果还有LoadData(model,width，height，options构造LoadData)
            loadData = helper.getLoadData().get(loadDataListIndex++);
            //fetcher.getDataSource()是否可以进行磁盘缓存
            if (loadData != null && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
                    || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {//该LoadData是否被Glide进行加载过，是否可用
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }
        return started;
    }
    /***部分代码省略***/
    private void cacheData(Object dataToCache) {
        long startTime = LogTime.getLogTime();
        try {//获取dataToCache对应的解码器，StreamEncoder
            Encoder<Object> encoder = helper.getSourceEncoder(dataToCache);
            DataCacheWriter<Object> writer = new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
            originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());//生成数据源的key
            helper.getDiskCache().put(originalKey, writer);//将writer写入到磁盘缓存中，对应的key为originalKey
        } finally {
            loadData.fetcher.cleanup();
        }
        //构造原始数据缓存构造器，转到磁盘读取数据
        sourceCacheGenerator = new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
    }
    @Override//数据加载成功回调，date类型为InputStream
    public void onDataReady(Object data) {DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
        //如果数据不为空，而且可以缓存那么机进行SourceGenerator转DataCacheGenerator
        if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
            dataToCache = data;
            cb.reschedule();//切换线程，切换完之后currentGenerator还是SourceGenerator
        } else {//否早直接将数据进行回调
            cb.onDataFetcherReady(loadData.sourceKey,data,loadData.fetcher,loadData.fetcher.getDataSource(),originalKey);
        }
    }
    @Override//数据加载失败回调
    public void onLoadFailed(@NonNull Exception e) {
        cb.onDataFetcherFailed(originalKey, e, loadData.fetcher, loadData.fetcher.getDataSource());
    }
    @Override//DataCacheGenerator的数据加载成功回调，data类型为ByteBuffer
    public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher<?> fetcher, DataSource dataSource, Key attemptedKey) {
        // 此数据提取程序将从文件中加载并提供错误的数据源，因此请覆盖使用原始提取程序的数据源 
        cb.onDataFetcherReady(sourceKey, data, fetcher, loadData.fetcher.getDataSource(), sourceKey);
    }
    @Override//DataCacheGenerator的数据加载失败回调
    public void onDataFetcherFailed(Key sourceKey, Exception e, DataFetcher<?> fetcher, DataSource dataSource) {
        cb.onDataFetcherFailed(sourceKey, e, fetcher, loadData.fetcher.getDataSource());
    }
}

//com.bumptech.glide.load.engine.DecodeJob
public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher<?> fetcher, DataSource dataSource, Key attemptedKey) {
    this.currentSourceKey = sourceKey;//url
    this.currentData = data;//ByteBuffer
    this.currentFetcher = fetcher;//ByteBufferFetcher
    this.currentDataSource = dataSource;//REMOTE
    this.currentAttemptingKey = attemptedKey;//url
    //如果当前线程不是主线程，那么切换到主线程执行数据解码（调用decodeFromRetrievedData）
    if (Thread.currentThread() != currentThread) {
        runReason = RunReason.DECODE_DATA;
        callback.reschedule(this);
    } else {
        GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
        try {
            decodeFromRetrievedData();//进行数据解码
        } finally {
            GlideTrace.endSection();
        }
    }
}

//com.bumptech.glide.Registry
@Nullable
public <Data, TResource, Transcode> LoadPath<Data, TResource, Transcode> getLoadPath(
      @NonNull Class<Data> dataClass,//ByteBuffer.class
      @NonNull Class<TResource> resourceClass,//Object.class
      @NonNull Class<Transcode> transcodeClass) {//Drawable.class
    LoadPath<Data, TResource, Transcode> result = loadPathCache.get(dataClass, resourceClass, transcodeClass);
    if (loadPathCache.isEmptyLoadPath(result)) {
        return null;
    } else if (result == null) {
        List<DecodePath<Data, TResource, Transcode>> decodePaths = getDecodePaths(dataClass, resourceClass, transcodeClass);
        //可能无法将给定的类型解码或转码为所需的类型数据类。 
        if (decodePaths.isEmpty()) {
            result = null;
        } else {
            result = new LoadPath<>(dataClass, resourceClass, transcodeClass, decodePaths, throwableListPool);
        }
        loadPathCache.put(dataClass, resourceClass, transcodeClass, result);
    }
    return result;
}

//com.bumptech.glide.Registry
@NonNull
private <Data, TResource, Transcode> List<DecodePath<Data, TResource, Transcode>> getDecodePaths(
      @NonNull Class<Data> dataClass,
      @NonNull Class<TResource> resourceClass,
      @NonNull Class<Transcode> transcodeClass) {
    List<DecodePath<Data, TResource, Transcode>> decodePaths = new ArrayList<>();
    //GifDrawable,Bitmap,BitmapDrawable
    List<Class<TResource>> registeredResourceClasses = decoderRegistry.getResourceClasses(dataClass, resourceClass);
    for (Class<TResource> registeredResourceClass : registeredResourceClasses) {
        List<Class<Transcode>> registeredTranscodeClasses = transcoderRegistry.getTranscodeClasses(registeredResourceClass, transcodeClass);
        for (Class<Transcode> registeredTranscodeClass : registeredTranscodeClasses) {
            List<ResourceDecoder<Data, TResource>> decoders = decoderRegistry.getDecoders(dataClass, registeredResourceClass);
            ResourceTranscoder<TResource, Transcode> transcoder = transcoderRegistry.get(registeredResourceClass, registeredTranscodeClass);
            //transcoder=DrawableBytesTranscoder
            DecodePath<Data, TResource, Transcode> path =
                new DecodePath<>(
                    dataClass,//ByteBuffer
                    registeredResourceClass,//GifDrawable/Bitmap/BitmapDrawable
                    registeredTranscodeClass,//Drawable/Drawable/Drawable
                        //ByteBufferGifDecoder/ByteBufferBitmapDecoder/BitmapDrawableDecoder
                    decoders,
                        ///UnitTranscoder/BitmapDrawableTranscoder/UnitTranscoder
                    transcoder,
                    throwableListPool);
            decodePaths.add(path);
        }
    }
    return decodePaths;
}