写作背景
Glide 作为著名的图片加载框架，几乎每一个项目都使用到。笔者尝试通过别人的博客来了解 Glide 原理，但是每次都是看着看着就懵逼了，不是因为别人写的不好，而是 Glide 实在是太复杂了，于是决定自己撸一遍，加深印象。纸上得来终觉浅，绝知此事要躬行。
因为 Glide 太庞大了，做不到面面俱到，所以笔者主要先梳理主干核心原理，后续持续整理。本文源码分析基于4.15.0，就从最基础的调用 Glide.with(context).load(url).into(imageView) 来入手，把主流程最核心的源码整理并且标注、总结。
该篇是Glide.with
Glide.with 源码分析
|-------------------------------|--------------------|
| 类 | 作用 |
| Glide | 负责线程池、缓存的构建 |
| RequestManagerRetriever | 负责获取RequestManager |
| SupportRequestManagerFragment | 用户接收和转发生命周期 |
| RequestManager | 用于请求管理 |
第1步，从 Glide.with 出发，可以看到Glide.with 有很多重载方法，目的是返回一个RequestManager。（Glide.java)
java
//传递Context
public static RequestManager with(@NonNull Context context) {
return getRetriever(context).get(context);
}
// 传递FragmentActivity
public static RequestManager with(@NonNull FragmentActivity activity) {
return getRetriever(activity).get(activity);
}
// 传递Fragment
public static RequestManager with(@NonNull Fragment fragment) {
return getRetriever(fragment.getContext()).get(fragment);
}
//传递View
public static RequestManager with(@NonNull View view) {
return getRetriever(view.getContext()).get(view);
}
......第2步 Glide.with 里面会调用 getRetriever方法，getRetriever() 先会调用 Glide.get()，Glide.get 会调用checkAndInitializeGlide 方法，注意会传递一个APT生成的 GeneratedAppGlideModuleImpl（Glide.java)
java
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
// 省略...
return Glide.get(context).getRequestManagerRetriever();
}
//双层检测单例模式
public static Glide get(@NonNull Context context) {
if (glide == null) {
//getAnnotationGeneratedGlideModules 内部通过。
//Class.forName("com.bumptech.glide.GeneratedAppGlideModuleImpl")
//拿到GeneratedAppGlideModuleImpl 并且作为参数传递
GeneratedAppGlideModule annotationGeneratedModule =
getAnnotationGeneratedGlideModules(context.getApplicationContext());
synchronized (Glide.class) {
if (glide == null) {
checkAndInitializeGlide(context, annotationGeneratedModule);
}
}
}
return glide;
}
最终来到Glide.initializeGlide，GeneratedAppGlideModuleImpl 的作用先记录，后续再慢慢了解，因为 Glide 内容实在太庞大了，每一个细节都要掌握无法梳理主流程（Glide.java)
java
private static void initializeGlide(
@NonNull Context context,
@NonNull GlideBuilder builder,
@Nullable GeneratedAppGlideModule annotationGeneratedModule) {
//1. 获取应用AppContext,最终是用来构建Glide的
Context applicationContext = context.getApplicationContext();
//2.这里通过传递进来的 GeneratedAppGlideModuleImpl 调用 getExcludedModuleClasses
List<GlideModule> manifestModules = Collections.emptyList();
if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
manifestModules = new ManifestParser(applicationContext).parse();
}
if (annotationGeneratedModule != null
&& !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
Set<Class<?>> excludedModuleClasses = annotationGeneratedModule.getExcludedModuleClasses();
Iterator<GlideModule> iterator = manifestModules.iterator();
while (iterator.hasNext()) {
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 (GlideModule glideModule : manifestModules) {
Log.d(TAG, "Discovered GlideModule from manifest: " + glideModule.getClass());
}
}
//3.这里通过传递进来的 GeneratedAppGlideModuleImpl 获取 RequestManagerRetriever.RequestManagerFactory
RequestManagerRetriever.RequestManagerFactory factory =
annotationGeneratedModule != null
? annotationGeneratedModule.getRequestManagerFactory()
: null;
//4.将拿到的工厂添加到GlideBuilder
builder.setRequestManagerFactory(factory);
for (GlideModule module : manifestModules) {
module.applyOptions(applicationContext, builder);
}
//5.这里通过传递进来的 GeneratedAppGlideModuleImpl 调用 applyOptions
if (annotationGeneratedModule != null) {
annotationGeneratedModule.applyOptions(applicationContext, builder);
}
//6.通过GlideBuilder 建造者模式生成 Glide
Glide glide = builder.build(applicationContext, manifestModules, annotationGeneratedModule);
applicationContext.registerComponentCallbacks(glide);
//7. 将构建出来的glide 赋值给 Glide 的静态变量
Glide.glide = glide;
}第3步，我们看到了有一个GlideBuilder 来生成Glide，这里有一个地方非常关键：GliderBuilder 来构建Glide，传递的Context 是applicationContext！！！, 你外部使用activity, 这里都会getApplicationContext 传入！！！
java
Glide build(
@NonNull Context context,
List<GlideModule> manifestModules,
AppGlideModule annotationGeneratedGlideModule) {
//实例化网络请求线程池
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();
if (size > 0) {
bitmapPool = new LruBitmapPool(size);
} else {
bitmapPool = new BitmapPoolAdapter();
}
}
//实例化数组对象池
if (arrayPool == null) {
arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
}
//实例化内存缓存 LruCache
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);
}
GlideExperiments experiments = glideExperimentsBuilder.build();
//实例化RequestManagerRetriever 请求管理类
RequestManagerRetriever requestManagerRetriever =
new RequestManagerRetriever(requestManagerFactory);
//实例化Glide
return new Glide(
context,
engine,
memoryCache,
bitmapPool,
arrayPool,
requestManagerRetriever,
connectivityMonitorFactory,
logLevel,
defaultRequestOptionsFactory,
defaultTransitionOptions,
defaultRequestListeners,
manifestModules,
annotationGeneratedGlideModule,
experiments);
}第4步，所以首次调用 Glide.get() 会把 Glide 构建完成，那么调用 Glide 的 getRequestManagerRetriver()就能拿到 RequestManagerRetriver对象。下面看看RequestManagerRetriver.get() 方法，也是有很多重载方法。
先看下RequestManagerRetriver.get(Context context), 可以看到如果不在主线程或者Context为AppContext，那么调用的是getApplicationManager
java
@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)) {//1.主线程并且context不为Application
if (context instanceof FragmentActivity) {
//2.如果是FragmentActivity
return get((FragmentActivity) context);
} else if (context instanceof Activity) {
//3.如果是Activity
return get((Activity) context);
} else if (context instanceof ContextWrapper
&& ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
//4.如果是ContextWrapper，并且baseContext的AppContext 不为空
return get(((ContextWrapper) context).getBaseContext());
}
}
//5.不在主线程或者context为AppContext 调用getApplicationManager
return getApplicationManager(context);
}第5步，先看getApplicationManager(context) 构建applicationManager的对象, 这个是App层级的RequestManager。 (RequestManagerReceiver.java)
java
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) {
//使用AppContext 作为参数拿Glide
Glide glide = Glide.get(context.getApplicationContext());
applicationManager =
factory.build(
glide,
new ApplicationLifecycle(),//注意：这里是ApplicationLifecycle
new EmptyRequestManagerTreeNode(),
context.getApplicationContext());
}
}
}
return applicationManager;//返回RequestManager
}第6步，再看看传递Activity 的情况, 最终会调用FragmentGet 生成一个Fragment 来监听生命周期。这里是最重要的一个方法
java
public RequestManager get(@NonNull Activity activity) {
if (Util.isOnBackgroundThread()) {
return get(activity.getApplicationContext());
} else if (activity instanceof FragmentActivity) {
return get((FragmentActivity) activity);
} else {
assertNotDestroyed(activity);
frameWaiter.registerSelf(activity);
android.app.FragmentManager fm = activity.getFragmentManager();
//注意：调用FragmentGet，这里会生成一个Fragment 用来监听生命周期
return fragmentGet(activity, fm, /* parentHint= */ null, isActivityVisible(activity));
}
}第7步 , fragmentGet 方法生成空白的Fragment，该Fragment 是用来管理请求的生命周期的，并且会和RequestManagerFactory工厂生成的RequestManager 绑定。
java
private RequestManager fragmentGet(
@NonNull Context context,
@NonNull android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
//1. 通过getRequestManagerFragment生成一个空白的Fragment，用来管理请求的生命周期，核心方法！！
RequestManagerFragment current = getRequestManagerFragment(fm, parentHint);
RequestManager requestManager = current.getRequestManager();
//2. 如果FragmentManager，为空，就用RequestManagerFactory工厂生成一个并且设给RequestManagerFragment
if (requestManager == null) {
Glide glide = Glide.get(context);
requestManager =
factory.build(
glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
if (isParentVisible) {
requestManager.onStart();
}
current.setRequestManager(requestManager);
}
//3. 返回RequestManager
return requestManager;
}第8步 在看工厂如何生成FragmentManager 之前，先看看如何生成空白的Fragment------RequestManagerFragment，因为这个RequestManagerFragment最终要和RequestManager 绑定的。
java
private RequestManagerFragment getRequestManagerFragment(
@NonNull final android.app.FragmentManager fm, @Nullable android.app.Fragment parentHint) {
//1. 先缓存中取
RequestManagerFragment current = pendingRequestManagerFragments.get(fm);
//2.缓存里面没有，再通过 TAG 从FragmentManager 里拿
if (current == null) {
current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
//3. 缓存没有，通过TAG 也拿不到，就初始化一个新的
if (current == null) {
current = new RequestManagerFragment();
current.setParentFragmentHint(parentHint);
//4. 先放入缓存，以免下一次Glide请求会再生成一个空白的Fragment
pendingRequestManagerFragments.put(fm, current);
//5. 通过当前 Activity的 FragmentManager 开始提交添加一个 Fragment容器
fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
//6. 这个空白的Fragment 添加到 FragmentManager 成功，通过 Handler 发送一个消息，清理缓存
handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
}
}
return current;
}上面的 getRequestManagerFragment 有一个很重要的点：采用了双重检测保证宿主、空白Fragment、RequestManager 一一对应
第一重保障：使用Map<android.app.FragmentManager, RequestManagerFragment>保存记录集合，解决多个请求只有一个空白Fragment
第二重保障：通过Handler 发送消息让空白的Fragment 马上添加到FragmentManager
FragmentManager 的事务本来就是通过Handler 发送消息来实现，通过Handler 发送消息有可能不会被马上执行，倘若空白的Fragment的消息一直在等待，那么下一次Glide请求就会再生成一个空白的Fragment。而通过Handler 发送删除消息，可以让空白的Fragment添加到FragmentManager马上执行并且清空缓存，这样下一次Glide 请求到来的时候，从FragmentManager的TAG 就能拿到Fragment, 不会再创建。
第9步，我们再回过头来看看怎样通过工厂RequestManagerFactory 来生成RequestManager的
java
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) {
//工厂里也是new 一个 RequestManager
return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
}
};第10步，RequestManager 初始化，监听lifecycle的生命周期。而这个lifecycl就是空白Fragment里的ActivityFragmentLifecycle
java
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));
glide.registerRequestManager(this);
if (Util.isOnBackgroundThread()) {
Util.postOnUiThread(addSelfToLifecycle);
} else {
lifecycle.addListener(this);//this 就是RequestManager 因此RequestManager就会监听Lifecycle生命周期
}
lifecycle.addListener(connectivityMonitor);
defaultRequestListeners =
new CopyOnWriteArrayList<>(glide.getGlideContext().getDefaultRequestListeners());
setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());
}
//Requestmanager 已经监听了空白Fragment的lifecycle
@Override
public synchronized void onStart() {
resumeRequests();//恢复请求
targetTracker.onStart();
}
@Override
public synchronized void onStop() {
pauseRequests();//暂停请求
targetTracker.onStop();
}
java
public class RequestManagerFragment extends Fragment {
private static final String TAG = "RMFragment";
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();//转发生命周期
}
}到此，可以看到 RequestManager 通过监听空白Fragment 的 lifecycle 的生命周期来管理请求的生命周期的。
Glide.with 原理总结
Glide 初始化并且生成RequestManager，RequestManager 与 空白Fragment 的 lifecycle 生命周期绑定来管理后续的请求。
- 空白Fragment 持有ActivityFragmentLifecycle，当空白Fragment生命周期改变的时候，调用onStart()、onStop()、onDestroy()------>
2)ActivityFragmentLifecycle 持有LifecycleListener集合，其中RequestManager是其中的一个LifecycleListener，ActivityFragmentLifecycle遍历集合，调用LifecycleListener的onStart()、onStop()、onDestroy()------>
- RequestManager 实现了LifecycleListener， 在onStart()、onStop()、onDestroy()方法中进行请求的生命周期管理。