Android 图片加载框架 Glide 4.11.0 源码解析 （一）

从源码的角度分析 Glide 执行流程

       在众多的图片加载框架中，Glide是Google推荐的，并在自家的项目中大量使用的一个非常强大的框架，专注于平滑滚动，并且还提供Gif，本地Vedio首帧的解码和显示。Glide提供了非常便捷的链式调用接口，以及丰富的拓展和自定义功能，开发者可以非常简单地对框架进行配置和图片再加工。

       如今Gilde已经更新到4.x，了解其源码对更好的使用Glide，以及学习相关的图片处理技术，学习更优雅的编码会有很大的帮助。不得不说，Glide整个框架的极其复杂的，特别是在对资源的转换和解码过程中，涉及了许多的嵌套循环，同时也使用了大量的工厂模式用于生产转换模块，编码模块，解码模块等。

       本文基于Glide 4.11.0 版本进行分析Glide 的执行流程。

       下来来看在Glide中最简单的图片加载代码：

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

    1. with 方法

       glide 的 with 方法有很多重载方法，代码如下

  @NonNullpublic static RequestManager with(@NonNull Context context) {return getRetriever(context).get(context);}@NonNullpublic static RequestManager with(@NonNull Activity activity) {return getRetriever(activity).get(activity);}@NonNullpublic static RequestManager with(@NonNull FragmentActivity activity) {return getRetriever(activity).get(activity);}@NonNullpublic static RequestManager with(@NonNull Fragment fragment) {return getRetriever(fragment.getContext()).get(fragment);}@Deprecated@NonNullpublic static RequestManager with(@NonNull android.app.Fragment fragment) {return getRetriever(fragment.getActivity()).get(fragment);}@NonNullpublic static RequestManager with(@NonNull View view) {return getRetriever(view.getContext()).get(view);}

       其实最常用就是 Activity、Fragment、Context 这3中参数类型的with方法，下面我们主要以Activity 参数类型的 with 方法为主来分析Glide源码。
在with方法中调用 getRetriever 方法，代码如下所示：

  @NonNullprivate 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.// 对 context 做判空检查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();}

       在 getRetriever 方法中先是进行了context 的非空检查，然后调用Glide 的 get 方法，代码如下所示：

  @NonNullpublic static Glide get(@NonNull Context context) {if (glide == null) {// 这里拿到 @GlideModule 标识的注解处理器生成的 GeneratedAppGlideModuleImpl 。GeneratedAppGlideModule annotationGeneratedModule =getAnnotationGeneratedGlideModules(context.getApplicationContext());synchronized (Glide.class) {if (glide == null) {checkAndInitializeGlide(context, annotationGeneratedModule);}}}return glide;}

       这里的 Glide get(Context) 是一种双重检测单例模式(DCL)，保证了多线程下安全， 我们继续看 checkAndInitializeGlide 这个方法，代码如下所示：

  @GuardedBy("Glide.class")private static void checkAndInitializeGlide(@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {// In the thread running initGlide(), one or more classes may call Glide.get(context).// Without this check, those calls could trigger infinite recursion.// isInitializing  是否已经初始化标志，如果已经初始化再调用初始化方法就会抛出异常。if (isInitializing) {throw new IllegalStateException("You cannot call Glide.get() in registerComponents(),"+ " use the provided Glide instance instead");}isInitializing = true;// 开始进行初始化initializeGlide(context, generatedAppGlideModule); // ... 1isInitializing = false;}

       在注释1处调用 initializeGlide 方法开始进行初始化，代码如下所示：

  @GuardedBy("Glide.class")private static void initializeGlide(@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {//实例化一个 GlideBuilder 再进行初始化//GlideBuilder 默认的一些配置信息initializeGlide(context, new GlideBuilder(), generatedAppGlideModule);}

       在分析 initializeGlide 的另一个重载方法之前，我们先了解一下 GlideModule 配置加载

       在使用Glide的时候，我们都会有一些想要设置的系统级配置，如设置缓存的存储位置，缓存区的大小，网络加载模块等等。在Glide4.x中使用 GlideModule 注解进行配置，代码如下所示：

@GlideModule
public class GlideConfiguration extends AppGlideModule {@Overridepublic void applyOptions(Context context, GlideBuilder builder) {//设置缓存到外部存储器builder.setDiskCache(new ExternalPreferredCacheDiskCacheFactory(context)); }
}

       然后在项目的AndroidMenifest.xml中进行指定：

<meta-data android:name="com.lx.glide.GlideConfiguration"android:value="GlideModule"/>

        接着继续看 initializeGlide 的另一个重载方法，代码如下所示：

  @GuardedBy("Glide.class")@SuppressWarnings("deprecation")private static void initializeGlide(@NonNull Context context,@NonNull GlideBuilder builder,@Nullable GeneratedAppGlideModule annotationGeneratedModule) {// 由于 Glide 使用的单利模式，在这里获取Application中的上下文对象，避免内存泄漏Context applicationContext = context.getApplicationContext();// 生成 Mainfest 解析器 ManifestParser ，用于获取配置的 GlideModule ， 并存放在 manifestModules 中。List<com.bumptech.glide.module.GlideModule> manifestModules = Collections.emptyList();if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {manifestModules = new ManifestParser(applicationContext).parse();}/** 移除被过滤的GlideModule ，如果条件成立，即编译时自动生成的类中，包含了需要排除的GlideModule，逐个将其移除。*  Glide将逐个调用剩下的GlideModule，并回调applyOptions和registerComponents接口，这时，用户配置的GlideModule就会被调用，同时用户设置的参数也就被配置到Glide中。*/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;}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());}}// 通过注解生成的代码拿到 RequestManagerFactory RequestManagerRetriever.RequestManagerFactory factory =annotationGeneratedModule != null? annotationGeneratedModule.getRequestManagerFactory(): null;// 将拿到的工厂添加到 GlideBuilder 中。builder.setRequestManagerFactory(factory);// 逐个回调用户配置的GlideModulefor (com.bumptech.glide.module.GlideModule module : manifestModules) {module.applyOptions(applicationContext, builder);}// 回调注解标记的AppGlideModuleif (annotationGeneratedModule != null) {annotationGeneratedModule.applyOptions(applicationContext, builder);}// 通过 Builder 建造者模式，构建出 Glide 实例对象Glide glide = builder.build(applicationContext); // ... 1// 注册回调。for (com.bumptech.glide.module.GlideModule module : manifestModules) {try {module.registerComponents(applicationContext, glide, glide.registry);} catch (AbstractMethodError e) {throw new IllegalStateException("Attempting to register a Glide v3 module. If you see this, you or one of your"+ " dependencies may be including Glide v3 even though you're using Glide v4."+ " You'll need to find and remove (or update) the offending dependency."+ " The v3 module name is: "+ module.getClass().getName(),e);}}if (annotationGeneratedModule != null) {annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);}applicationContext.registerComponentCallbacks(glide);// 将构建出来的 glide 对象 赋值给 Glide 的静态变量Glide.glide = glide;}

       在注释1处通过建造者模式构建出glide对象，接下来我们分析 GlideBuilder 是如何构造 glide 对象的，代码如下所示：

package com.bumptech.glide;/** A builder class for setting default structural classes for Glide to use. */
@SuppressWarnings("PMD.ImmutableField")
public final class GlideBuilder {private final Map<Class<?>, TransitionOptions<?, ?>> defaultTransitionOptions = new ArrayMap<>();//  管理线程池private Engine engine;//  对象池（享元模式），这样做避免重复创建对象，降低内存开销private BitmapPool bitmapPool;private ArrayPool arrayPool;// 内存缓存private MemoryCache memoryCache;// GlideExecutor 线程池private GlideExecutor sourceExecutor;private GlideExecutor diskCacheExecutor;// 本地磁盘缓存private DiskCache.Factory diskCacheFactory;// 内存大小计算private MemorySizeCalculator memorySizeCalculator;// 网络连接监控private ConnectivityMonitorFactory connectivityMonitorFactory;private int logLevel = Log.INFO;private RequestOptionsFactory defaultRequestOptionsFactory =new RequestOptionsFactory() {@NonNull@Overridepublic RequestOptions build() {return new RequestOptions();}};@Nullable private RequestManagerFactory requestManagerFactory;private GlideExecutor animationExecutor;private boolean isActiveResourceRetentionAllowed;@Nullable private List<RequestListener<Object>> defaultRequestListeners;private boolean isLoggingRequestOriginsEnabled;private boolean isImageDecoderEnabledForBitmaps;...@NonNullGlide build(@NonNull Context context) {// 实例化网络请求的线程池，用于加载Url 或者 本地资源。if (sourceExecutor == null) {sourceExecutor = GlideExecutor.newSourceExecutor();}// 实例化本地磁盘缓存的线程池，不用于加载网络url资源。if (diskCacheExecutor == null) {diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();}// 实例化加载动画的线程池if (animationExecutor == null) {animationExecutor = GlideExecutor.newAnimationExecutor();}// 实例化一个对图片加载到内存的一个计算if (memorySizeCalculator == null) {memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();}// 实例化默认网络连接监控工厂if (connectivityMonitorFactory == null) {connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();}// 实例化 Bitmap 对象池，避免由于大量创建和回收Bitmap导致内存抖动if (bitmapPool == null) {int size = memorySizeCalculator.getBitmapPoolSize();if (size > 0) {bitmapPool = new LruBitmapPool(size);} else {bitmapPool = new BitmapPoolAdapter();}}// 实例化数组对象池if (arrayPool == null) {arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());}// 实例化内存缓存if (memoryCache == null) {memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());}// 实例化磁盘缓存工厂if (diskCacheFactory == null) {diskCacheFactory = new InternalCacheDiskCacheFactory(context);}// 构建执行缓存策略 和   线程池的引擎if (engine == null) {engine =new Engine(memoryCache,diskCacheFactory,diskCacheExecutor,sourceExecutor,GlideExecutor.newUnlimitedSourceExecutor(),animationExecutor,isActiveResourceRetentionAllowed);}if (defaultRequestListeners == null) {defaultRequestListeners = Collections.emptyList();} else {defaultRequestListeners = Collections.unmodifiableList(defaultRequestListeners);}//实例化一个 RequestManagerRetriever 请求管理类RequestManagerRetriever requestManagerRetriever =new RequestManagerRetriever(requestManagerFactory);//实例化 Glidereturn new Glide(context,engine,memoryCache,bitmapPool,arrayPool,requestManagerRetriever,connectivityMonitorFactory,logLevel,defaultRequestOptionsFactory,defaultTransitionOptions,defaultRequestListeners,isLoggingRequestOriginsEnabled,isImageDecoderEnabledForBitmaps);}
}

       通过以上一系列工具的新建，Glide建立了资源请求线程池，本地缓存加载线程池，动画线程池，内存缓存器，磁盘缓存工具等等，接着构造了Engine数据加载引擎，最后再将Engine注入Glide，构建Glide。

Glide(@NonNull Context context,@NonNull Engine engine,@NonNull MemoryCache memoryCache,@NonNull BitmapPool bitmapPool,@NonNull ArrayPool arrayPool,@NonNull RequestManagerRetriever requestManagerRetriever,@NonNull ConnectivityMonitorFactory connectivityMonitorFactory,int logLevel,@NonNull RequestOptionsFactory defaultRequestOptionsFactory,@NonNull Map<Class<?>, TransitionOptions<?, ?>> defaultTransitionOptions,@NonNull List<RequestListener<Object>> defaultRequestListeners,boolean isLoggingRequestOriginsEnabled,boolean isImageDecoderEnabledForBitmaps) {// 将GlideBuilder构建的线程池、对象池、缓存对象保存到Glide中。this.engine = engine;this.bitmapPool = bitmapPool;this.arrayPool = arrayPool;this.memoryCache = memoryCache;this.requestManagerRetriever = requestManagerRetriever;this.connectivityMonitorFactory = connectivityMonitorFactory;this.defaultRequestOptionsFactory = defaultRequestOptionsFactory;final Resources resources = context.getResources();// 新建注册器registry = new Registry();registry.register(new DefaultImageHeaderParser());// Right now we're only using this parser for HEIF images, which are only supported on OMR1+.// If we need this for other file types, we should consider removing this restriction.if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {registry.register(new ExifInterfaceImageHeaderParser());}List<ImageHeaderParser> imageHeaderParsers = registry.getImageHeaderParsers();// 构建解码器和编码器ByteBufferGifDecoder byteBufferGifDecoder =new ByteBufferGifDecoder(context, imageHeaderParsers, bitmapPool, arrayPool);ResourceDecoder<ParcelFileDescriptor, Bitmap> parcelFileDescriptorVideoDecoder =VideoDecoder.parcel(bitmapPool);...  省略部分构建解码器和编码器代码// 开始注册各个类型对应的解码器和编码器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);if (ParcelFileDescriptorRewinder.isSupported()) {registry.append(Registry.BUCKET_BITMAP,ParcelFileDescriptor.class,Bitmap.class,new ParcelFileDescriptorBitmapDecoder(downsampler));}... 省略部分注册各个类型对应的解码器和编码器的代码// 新建图片显示目标对象工厂，并构建Glide上下文。ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();glideContext =new GlideContext(context,arrayPool,registry,imageViewTargetFactory,defaultRequestOptionsFactory,defaultTransitionOptions,defaultRequestListeners,engine,isLoggingRequestOriginsEnabled,logLevel);}

       到这里，Glide单例就构建完成了，我们返回到Glide 的 with 方法中，在构建好Glide后，通 getRequestManagerRetriever 方法将会得到一个RequestManagerRetriever，即RequestManager的检索器，RequestManagerRetriever 的 get 方法将为每个请求页面创建一个RequestManager。这里的 get 也有很多重载的函数，我们就看 Activity 参数的重载。代码如下所示：

  @NonNullpublic RequestManager get(@NonNull Activity activity) {// 判断当前是否在子线程中请求任务if (Util.isOnBackgroundThread()) {// 通过 Application 的 context 加载return get(activity.getApplicationContext());} else {// 检查Activity是否已经销毁，如果activity已经销毁就会抛出异常assertNotDestroyed(activity);// 拿到当前 Activity 的 FragmentManager android.app.FragmentManager fm = activity.getFragmentManager();// 生成一个 Fragment 然后绑定 请求管理 RequestManagerreturn fragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity));}}

    首先，判断是否为后台线程，如果是，则使用ApplicationContext重新获取。重点来看else代码块。先断言请求的页面是否已经销毁。否则获取当前页面的FragmentManager，并传给fragmentGet方法，代码如下所示：

  @Deprecated@NonNullprivate RequestManager fragmentGet(@NonNull Context context,@NonNull android.app.FragmentManager fm,@Nullable android.app.Fragment parentHint,boolean isParentVisible) {// 在当前的 Acitivty 添加一个 Fragment 用于管理请求的生命周期RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);// 拿到当前请求的管理类RequestManager requestManager = current.getRequestManager();//如果不存在，则创建一个请求管理者保持在当前管理生命周期的 Fragment 中，相当于 2 者进行绑定，避免内存泄漏。if (requestManager == null) {// TODO(b/27524013): Factor out this Glide.get() call.// 获取单例 GlideGlide glide = Glide.get(context);//构建请求管理，current.getGlideLifecycle(),就是 ActivityFragmentLifecycle 后面我们会讲到这个类requestManager =factory.build(glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context); // ... 1//将构建出来的请求管理绑定在 Fragment 中。current.setRequestManager(requestManager); // ... 2}return requestManager;}

       在fragmentGet中首先通过getRequestManagerFragment方法来获取一个命名为FRAGMENT_TAG的fragment，如不存在，则新建一个RequestManagerFragment，并添加到当前页面中。  通过上面的代码可知，Glide是通过在页面中添加一个Fragment来动态监听页面的创建和销毁，从而达到依赖页面生命周期，动态管理请求的目的。getRequestManagerFragment方法的代码如下所示：

  @NonNullprivate RequestManagerFragment getRequestManagerFragment(@NonNull final android.app.FragmentManager fm,@Nullable android.app.Fragment parentHint,boolean isParentVisible) {//通过 TAG 拿到已经实例化过的 Fragment ,相当于如果同一个 Activity Glide.with..多次，那么就没有必要创建多个Frament.RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);//如果在当前 Activity 中没有拿到管理请求生命周期的 Fragment ，那么就从缓存中看有没有   if (current == null) {current = pendingRequestManagerFragments.get(fm);//如果缓存也没有，就直接实例化一个 Fragmentif (current == null) {current = new RequestManagerFragment();current.setParentFragmentHint(parentHint);// 如果已经有执行的请求就开始if (isParentVisible) {current.getGlideLifecycle().onStart();}// 添加到 Map 缓存中pendingRequestManagerFragments.put(fm, current);// 通过当前 Activity 的 FragmentManager 开始提交添加一个 Fragment 容器fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();//添加到 FragmentManager 成功，发送清理缓存。handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();}}return current;}

       最后就到了 把请求管理类绑定到 Fragment 中，我们回到 fragmentGet 方法中，在注释1处通过 RequestManagerFactory 创建 requestManager 对象，代码如下所示：

  private static final RequestManagerFactory DEFAULT_FACTORY =new RequestManagerFactory() {@NonNull@Overridepublic RequestManager build(@NonNull Glide glide,@NonNull Lifecycle lifecycle,@NonNull RequestManagerTreeNode requestManagerTreeNode,@NonNull Context context) {// 实例化 RequestManager 对象return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);}};

       接下来我们查看 RequestManager 的构造方法，代码如下所示：

  public RequestManager(@NonNull Glide glide,@NonNull Lifecycle lifecycle,@NonNull RequestManagerTreeNode treeNode,@NonNull Context context) {this(glide,lifecycle,treeNode,new RequestTracker(),glide.getConnectivityMonitorFactory(),context);}// Our usage is safe here.@SuppressWarnings("PMD.ConstructorCallsOverridableMethod")RequestManager(Glide glide,Lifecycle lifecycle,RequestManagerTreeNode treeNode,RequestTracker requestTracker,ConnectivityMonitorFactory factory,Context context) {this.glide = glide;this.lifecycle = lifecycle;this.treeNode = treeNode;this.requestTracker = requestTracker;this.context = context;connectivityMonitor =factory.build(context.getApplicationContext(),new RequestManagerConnectivityListener(requestTracker));// If we're the application level request manager, we may be created on a background thread.// In that case we cannot risk synchronously pausing or resuming requests, so we hack around the// issue by delaying adding ourselves as a lifecycle listener by posting to the main thread.// This should be entirely safe.// 添加生命周期监听，Fragment 传递过来的if (Util.isOnBackgroundThread()) {mainHandler.post(addSelfToLifecycle);} else {lifecycle.addListener(this);}// 添加网路连接变化的监听lifecycle.addListener(connectivityMonitor);defaultRequestListeners =new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());glide.registerRequestManager(this);}

        在 fragmentGet 方法的注释2处，将注释1处构建的 requestManager 对象绑定到 Fragment 中。  到这里请求管理类 RequestManager + Fragment 已经绑定成功了，声明周期监听也设置了。

       那他们相互是怎么保证生命周期的传递，我们主要看 Fragment 生命周期方法，代码如下所示：

// 这里为什么监控 Fragment 的生命周期，其实大家应该也知道 Fragment 是依附在 Activity 上的, Activity 的生命周期
// 在 Fragment 中都有，所以监听 Fragment 就行了。
public class RequestManagerFragment extends Fragment {// 这个就相当于是生命周期的回调private final ActivityFragmentLifecycle lifecycle;...@Overridepublic void onStart() {super.onStart();lifecycle.onStart();}@Overridepublic void onStop() {super.onStop();lifecycle.onStop();}@Overridepublic void onDestroy() {super.onDestroy();lifecycle.onDestroy();unregisterFragmentWithRoot();}...
}

       接下来我们查看ActivityFragmentLifecycle这个类是什么，代码如下所示：

class ActivityFragmentLifecycle implements Lifecycle {private final Set<LifecycleListener> lifecycleListeners =Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());private boolean isStarted;private boolean isDestroyed;@Overridepublic void addListener(@NonNull LifecycleListener listener) {lifecycleListeners.add(listener);if (isDestroyed) {listener.onDestroy();} else if (isStarted) {listener.onStart();} else {listener.onStop();}}@Overridepublic void removeListener(@NonNull LifecycleListener listener) {lifecycleListeners.remove(listener);}void onStart() {isStarted = true;for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {lifecycleListener.onStart();}}void onStop() {isStarted = false;for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {lifecycleListener.onStop();}}void onDestroy() {isDestroyed = true;for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {lifecycleListener.onDestroy();}}
}

       ActivityFragmentLifecycle 实现的是 Glide 中的 Lifecycle 生命周期接口，注册是在刚刚我们讲解 RequestManagerFactory 工厂中实例化的 RequestManager 然后在构造函数中添加了生命周期回调监听，而 RequestManager  实现了 LifecycleListener 接口，代码如下所示

public class RequestManager implements LifecycleListener,ModelTypes<RequestBuilder<Drawable>> {...@Overridepublic synchronized void onStart() {resumeRequests();targetTracker.onStart();}@Overridepublic synchronized void onStop() {pauseRequests();targetTracker.onStop();}@Overridepublic synchronized void onDestroy() {targetTracker.onDestroy();for (Target<?> target : targetTracker.getAll()) {clear(target);}targetTracker.clear();requestTracker.clearRequests();lifecycle.removeListener(this);lifecycle.removeListener(connectivityMonitor);mainHandler.removeCallbacks(addSelfToLifecycle);glide.unregisterRequestManager(this);}...
}

       这 3 处回调就是 Fragment 传递过来的，用于实时监听请求的状态。

       with 小总结:

       根据 with 源码分析，我们知道，Glide.with(Activity) 主要做了 线程池 + 缓存 + 请求管理与生命周期绑定+其它配置初始化的构建，到这里 Glide.with 我们已经分析完了。

     2. load 方法

       下面我们就来以 load(String url) 网络图片地址为例来讲解 load 过程，load 是 RequestManager 的方法，代码如下所示：

  @NonNull@CheckResult@Overridepublic RequestBuilder<Drawable> load(@Nullable String string) {// 这里使用 Drawable 图片加载请求器 为其加载return asDrawable().load(string);}@NonNull@CheckResultpublic RequestBuilder<Drawable> asDrawable() {return as(Drawable.class);}@NonNull@CheckResultpublic <ResourceType> RequestBuilder<ResourceType> as(@NonNull Class<ResourceType> resourceClass) {// 创建 RequestBuilder<ResourceType> 对象。return new RequestBuilder<>(glide, this, resourceClass, context);}

       在 RequestManager 的 load 方法中，通过asDrawable  方法获取一个 RequestBuilder<Drawable> 对象，然后再调用它的 load 方法，代码如下所示:

  @NonNull@Override@CheckResultpublic RequestBuilder<TranscodeType> load(@Nullable String string) {return loadGeneric(string);}@NonNullprivate RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {// 描述加载的数据源-这里可以看做是我们刚刚传递进来的 http://xxxx.pngthis.model = model;// 描述这个请求是否已经添加了加载的数据源isModelSet = true;return this;}

       到这里 RequestBuilder 就构建好了，这里并没有马上进入数据请求加载过程，而是简单的将数据模式进行了保存，并将isModelSet设置为true，然后返回。 接下来就等待执行这个请求了,

       关于 RequestBuilder 的 into 方法，我们在下一篇文章中继续分析。