Glide源码（4.11.0）主线流程梳理（一）---with方法的内部逻辑
本文旨在梳理代码流程
- Glide的使用
Glide.with(this).load(imageUrl).into(view);- 第一步with，涉及到的几个关键的类
- Glide：主要做一些 init 工作，比如缓存，线程池，复用池的构建等等
- RequestManagerRetriever ：主要是获得一个
RequestManager请求管理类，然后绑定一个 Fragment - SupportRequestManagerFragment ：空白的fragment，用于管理请求的生命周期
- RequestManager：主要用于对请求的管理封装
with 重载方法
public static RequestManager with(@NonNull Context context) { return getRetriever(context).get(context); } @NonNull public static RequestManager with(@NonNull Activity activity) { return getRetriever(activity).get(activity); } @NonNull public static RequestManager with(@NonNull FragmentActivity activity) { return getRetriever(activity).get(activity); } @NonNull public static RequestManager with(@NonNull Fragment fragment) { return getRetriever(fragment.getContext()).get(fragment); } @SuppressWarnings("deprecation") @Deprecated @NonNull public static RequestManager with(@NonNull android.app.Fragment fragment) { return getRetriever(fragment.getActivity()).get(fragment); } @NonNull public static RequestManager with(@NonNull View view) { return getRetriever(view.getContext()).get(view); }上面其实常用的就 Activity，Fragment, Context 这 3 种形式，下面我们就以 Activity 为主
- getRetriever(activity)
@NonNull private static RequestManagerRetriever getRetriever(@Nullable Context context) { //... return Glide.get(context).getRequestManagerRetriever(); }Glide.get(context):这里是最简单的DCL单例模式，或者Glide对象
@NonNull public static Glide get(@NonNull Context context) { if (glide == null) { // 这里拿到 @GlideModule 标识的注解处理器生成的 GeneratedAppGlideModuleImpl、//GeneratedAppGlideModuleFactory ...等等。 GeneratedAppGlideModule annotationGeneratedModule = getAnnotationGeneratedGlideModules(context.getApplicationContext()); synchronized (Glide.class) { if (glide == null) { checkAndInitializeGlide(context, annotationGeneratedModule); } } } return glide; }接着看一下glide对象的创建过程
1,checkAndInitializeGlide(context, annotationGeneratedModule);
@GuardedBy("Glide.class") private static void checkAndInitializeGlide( @NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) { if (isInitializing) { //如果正在初始化，这里就抛异常，不继续执行后续代码 } // 开始初始化的标记 isInitializing = true; // 开始初始化 initializeGlide(context, generatedAppGlideModule); // 初始化结束 isInitializing = false; }2,initializeGlide(context, generatedAppGlideModule);
@GuardedBy("Glide.class") private static void initializeGlide( @NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) { //实例化一个 GlideBuilder 在进行初始化 //GlideBuilder 默认的一些配置信息 initializeGlide(context, new GlideBuilder(), generatedAppGlideModule); }3,initializeGlide(context, new GlideBuilder(), generatedAppGlideModule);
@GuardedBy("Glide.class") @SuppressWarnings("deprecation") private static void initializeGlide( @NonNull Context context, @NonNull GlideBuilder builder, @Nullable GeneratedAppGlideModule annotationGeneratedModule) { //1. 拿到应用级别的上下文，这里可以避免内存泄漏，我们实际开发也可以通过这种形式拿上下文。 Context applicationContext = context.getApplicationContext(); // ... // 通过注解生成的代码拿到 RequestManagerFactory RequestManagerRetriever.RequestManagerFactory factory = annotationGeneratedModule != null ? annotationGeneratedModule.getRequestManagerFactory() : null; //将拿到的工厂添加到 GlideBuilder builder.setRequestManagerFactory(factory); // ... // 这里通过 Builder 建造者模式，构建出 Glide 实例对象 Glide glide = builder.build(applicationContext); // 开始注册组件回调 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; }上面的代码可以看到是通过构建者模式创建的glide
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; // ... @NonNull Glide build(@NonNull Context context) { //实例化一个网络请求的线程池 if (sourceExecutor == null) { sourceExecutor = GlideExecutor.newSourceExecutor(); }//实例化一个本地磁盘缓存的线程池 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 对象池 if (bitmapPool == null) { int size = memorySizeCalculator.getBitmapPoolSize(); //如果池子里还有可用的，直接加入 最近最少使用的 LruBitmap 容器里 if (size > 0) { bitmapPool = new LruBitmapPool(size); } else { //如果池子已经满了，那么就装在 BitmapPoolAdapter 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);//实例化 Glide 的地方 return new Glide( context, engine, memoryCache, bitmapPool, arrayPool, requestManagerRetriever, connectivityMonitorFactory, logLevel, defaultRequestOptionsFactory, defaultTransitionOptions, defaultRequestListeners, isLoggingRequestOriginsEnabled, isImageDecoderEnabledForBitmaps); }}上面的代码中，builder 主要构建线程池、复用池、缓存策略、执行 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) { //将 Builder 构建的线程池，对象池，缓存池保存到 Glide 中 this.engine = engine; this.bitmapPool = bitmapPool; this.arrayPool = arrayPool; this.memoryCache = memoryCache; this.requestManagerRetriever = requestManagerRetriever; this.connectivityMonitorFactory = connectivityMonitorFactory; this.defaultRequestOptionsFactory = defaultRequestOptionsFactory; // ... //用于显示对应图片的工厂 ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory(); //构建一个 Glide 专属的 上下文 glideContext = new GlideContext( context, arrayPool, registry, imageViewTargetFactory, defaultRequestOptionsFactory, defaultTransitionOptions, defaultRequestListeners, engine, isLoggingRequestOriginsEnabled, logLevel); }上面有一个 GlideContentx 这个是什么鬼？ 其实就是 Context一个级别的上下文而已
public class GlideContext extends ContextWrapper{ }到这里我们已经知道了 缓存策略、Glide、GlideContext 怎么构建出来的了，下面我们看怎么拿到 请求管理类 RequestManager
- getRetriever(activity).get(activity); 最终是返回 RequestManager：
这里的 get 也有很多重载的函数，挑一个 Activity 参数的重载，着重看看：
public class RequestManagerRetriever implements Handler.Callback {// 获取应用级别的 RequestManager，生命周期与应用程序一样@NonNull private RequestManager getApplicationManager(@NonNull Context context) { // Either an application context or we're on a background thread. if (applicationManager == null) { synchronized (this) { if (applicationManager == null) { Glide glide = Glide.get(context.getApplicationContext()); applicationManager =factory.build( glide, new ApplicationLifecycle(), new EmptyRequestManagerTreeNode(), context.getApplicationContext()); } } } return applicationManager; } @NonNull 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)) {//如果在主线程中并且不为 Application 级别的 Context 执行 if (context instanceof FragmentActivity) { return get((FragmentActivity) context); } else if (context instanceof Activity) { return get((Activity) context); } else if (context instanceof ContextWrapper && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) { return get(((ContextWrapper) context).getBaseContext()); } } return getApplicationManager(context); } @NonNull public RequestManager get(@NonNull FragmentActivity activity) { ... } @NonNull public RequestManager get(@NonNull Fragment fragment) { ... } @SuppressWarnings("deprecation") @NonNull public RequestManager get(@NonNull Activity activity) { if (Util.isOnBackgroundThread()) {//判断当前是否在子线程中请求任务 //通过 Application 级别的 Context 加载 return get(activity.getApplicationContext()); } else { //检查 Activity 是否已经销毁 assertNotDestroyed(activity); //拿到当前 Activity 的 FragmentManager android.app.FragmentManager fm = activity.getFragmentManager(); //主要是生成一个 Fragment 然后绑定一个请求管理 RequestManager return fragmentGet(activity, fm, /*parentHint=*/ null, isActivityVisible(activity)); } } @SuppressWarnings("deprecation") @NonNull public RequestManager get(@NonNull View view) { ... }}继续看下面的代码，虽然已经吐血身亡，但是还是需要坚持，看源码 靠的是谁耐得住寂寞，谁就是赢家
fragmentGet方法的实现
@Deprecated @NonNull private 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(); if (requestManager == null) { //如果不存在，则创建一个请求管理者保持在当前管理生命周期的 Fragment 中，相当于 2 者进行绑定，避免内存泄漏 Glide glide = Glide.get(context); requestManager = factory.build(glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context); current.setRequestManager(requestManager); } //返回当前请求的管理者 return requestManager; }通过上面的代码可知，这里用于 Fragment 管理请求的生命周期，那么我们具体来看看 Fragment 怎么添加到 Activity 中的呢
在上面的代码里，fragmentGet（）里面有一行代码：
RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);现在来看一下getRequestManagerFragment（）这个方法是如何获取fragment的
@NonNull private RequestManagerFragment getRequestManagerFragment( @NonNull final android.app.FragmentManager fm, @Nullable android.app.Fragment parentHint, boolean isParentVisible) { //通过 TAG 拿到已经实例化过的 Fragment ,相当于如果同一个 Activity Glide.with..多次，那么就没有必要创建多个 RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG); if (current == null) {//如果在当前 Activity 中没有拿到管理请求生命周期的 Fragment ，那么就从缓存中看有没有 current = pendingRequestManagerFragments.get(fm); if (current == null) {//如果缓存也没有得，就直接实例化一个 Fragment 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; }我们知道，with之后，最终返回RequestManager对象， 我们需要对RequestManager对象的构建，有一个来龙去脉的学习：
// 注意：此工厂就是为了构建出 RequestManager对象 private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() { @NonNull @Override public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle, @NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) { //实例化 return new RequestManager(glide, lifecycle, requestManagerTreeNode, context); } };你只要敢 new RequestManager(…); 就会进入 RequestManager的构造方法：
public RequestManager( @NonNull Glide glide, @NonNull Lifecycle lifecycle, @NonNull RequestManagerTreeNode treeNode, @NonNull Context context) { this( glide, lifecycle, treeNode, new RequestTracker(), glide.getConnectivityMonitorFactory(), context); } 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. // 添加生命周期监听 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); }到这里请求管理类 RequestManager + Fragment 已经绑定成功了，声明周期监听也设置了，那他们相互是怎么保证生命周期的传递勒，我们主要看 Fragment 生命周期方法
public class RequestManagerFragment extends Fragment {// 生命周期的回调private final ActivityFragmentLifecycle lifecycle;... @Override public void onStart() { super.onStart(); lifecycle.onStart(); } @Override public void onStop() { super.onStop(); lifecycle.onStop(); } @Override public void onDestroy() { super.onDestroy(); lifecycle.onDestroy(); unregisterFragmentWithRoot(); }}这里的 lifecycle 是什么，在深入的看一下：
class ActivityFragmentLifecycle implements Lifecycle { private final Set<LifecycleListener> lifecycleListeners = Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>()); private boolean isStarted; private boolean isDestroyed; /** * Adds the given listener to the list of listeners to be notified on each lifecycle event. * * The latest lifecycle event will be called on the given listener synchronously in this * method. If the activity or fragment is stopped, {@link LifecycleListener#onStop()}} will be * called, and same for onStart and onDestroy. * *
Note - {@link com.bumptech.glide.manager.LifecycleListener}s that are added more than once * will have their lifecycle methods called more than once. It is the caller's responsibility to * avoid adding listeners multiple times. */
@Override public void addListener(@NonNull LifecycleListener listener) { lifecycleListeners.add(listener); if (isDestroyed) { listener.onDestroy(); } else if (isStarted) { listener.onStart(); } else { listener.onStop(); } } @Override public 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(); } }}看到这里知道了吧，它实现的是 Glide 中的 Lifecycle 生命周期接口，注册是在刚刚我们讲解 RequestManagerFactory 工厂中实例化的 RequestManager 然后在构造函数中添加了生命周期回调监听，具体来看下
public class RequestManager implements LifecycleListener, ModelTypes<RequestBuilder<Drawable>> { ... @Override public synchronized void onStart() { resumeRequests(); targetTracker.onStart(); } @Override public synchronized void onStop() { pauseRequests(); targetTracker.onStop(); } @Override public 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) 主要做了 线程池 + 缓存 + 请求管理与生命周期绑定+其它配置初始化的构建，内部的代码其实是很庞大的
【后续】
