先来一张整体架构图，版本不详，后面分析基于新版 Glide 4.16.0
with 调用
Glide内部会在 Activity/Fragment生命周期监听，网络变化监听，自动取消加
载或者重新加载，等等
活动图
旧版的Glide，作用域为非Application时，通过一个空白 fragment 监听界面的生命周期，回调到 Glide 内部
新版 Glide 已经废弃了 RequestManagerFragment，不再被视为最佳实践，且存在一些潜在的问题。RequestManagerFragment 主要用于在 Android 生命周期中管理 Glide 请求，以确保在 Activity 或 Fragment 生命周期中正确地加载和清理图像。
然而，随着时间的推移，Google 推出了更好的生命周期管理解决方案，如LifecycleOwner 和 ViewModel。这些组件提供了更灵活和可靠的方式来管理组件的生命周期。
获取 RequestManager 的类变成了 LifecycleRequestManagerRetriever ，在创建 RequestManager 时会传入 lifecycle，并把自己添加为 lifecycle 的 listener
lifecycle.addListener(RequestManager.this);
RequestManager 实现了 LifecycleListener
public interface LifecycleListener {
void onStart();
void onStop();
void onDestroy();
}
Fragment/Activity生命周期： 当我们的Fragment或Activity不可见的时候 暂停请
求， 当我们的Fragment或Activity可见的时候 恢复请求，当销毁时就取消请求
收到 lifecycle onDestroy 时间后就移除自身
public synchronized void onDestroy() {
targetTracker.onDestroy();
clearRequests();
requestTracker.clearRequests();
// 移除自身
lifecycle.removeListener(this);
lifecycle.removeListener(connectivityMonitor);
Util.removeCallbacksOnUiThread(addSelfToLifecycle);
glide.unregisterRequestManager(this);
}
为何去监听Fragment/Activity生命周期
总结：
以确保优先处理前台可见的 Activity / Fragment，提高资源利用率；
在有必要时释放资源以避免在应用在后台时被杀死，提高稳定性
生命周期作用域Application，Activity，Fragment
跟进代码，调用 Glide.with 时，会走到 RequestManagerRetriever 的 get
public static RequestManager with(@NonNull Context context) {
return getRetriever(context).get(context);
}
在 get 方法里面区分要绑定的各个生命周期
public RequestManager get(@NonNull Context context) {
if (Util.isOnMainThread() && !(context instanceof Application)) {
if (context instanceof FragmentActivity) {
return get((FragmentActivity) context);
} else if (context instanceof ContextWrapper
&& ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
return get(((ContextWrapper) context).getBaseContext());
}
}
return getApplicationManager(context);
}
必须是主线程和关联的生命周期 owner 非 Application 才绑定界面更具体的生命周期
子线程或全局生命周期就创建 ApplicationManager 的 RequestManager
生命周期的绑定监听
Glide 的 LifecycleLifecycle 完全 implements Lifecycle, LifecycleObserver
完整接入了 Androidx 的生命周期管理机制
把 RequestManager 添加到 listener 后即可绑定
final class LifecycleLifecycle implements Lifecycle, LifecycleObserver {
// ……
@OnLifecycleEvent(Event.ON_START)
public void onStart(@NonNull LifecycleOwner owner) {
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onStart();
}
}
@OnLifecycleEvent(Event.ON_STOP)
public void onStop(@NonNull LifecycleOwner owner) {
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onStop();
}
}
@OnLifecycleEvent(Event.ON_DESTROY)
public void onDestroy(@NonNull LifecycleOwner owner) {
for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
lifecycleListener.onDestroy();
}
owner.getLifecycle().removeObserver(this);
}
}
Glide 对象
返回第一步，获取 RequestManagerRetriever 方法
可以看到先 Glide.get(context) 获取了一个 Glide 对象，跟进去
private static RequestManagerRetriever getRetriever(@Nullable Context context) {
return Glide.get(context).getRequestManagerRetriever();
}
public static Glide get(@NonNull Context context) {
if (glide == null) {
// ……
synchronized (Glide.class) {
if (glide == null) {
checkAndInitializeGlide(context, annotationGeneratedModule);
}
}
}
static void checkAndInitializeGlide(
@NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
// 跟进
initializeGlide(context, generatedAppGlideModule);
}
private static void initializeGlide(
@NonNull Context context,
@NonNull GlideBuilder builder,
@Nullable GeneratedAppGlideModule annotationGeneratedModule) {
Context applicationContext = context.getApplicationContext();
……
// 这里通过 Builder 建造者模式，构建出 Glide 实例对象
Glide glide = builder.build(applicationContext, manifestModules, annotationGeneratedModule);
Glide.glide = glide;
}
// 再看看 GlideBuilder 内部逻辑
GlideBuilder
public final class GlideBuilder {
// note jin: 管理线程池
private Engine engine;
// 对象池(享元模式)，这样做避免重复创建对象，对内存开销有一定效果
private BitmapPool bitmapPool;
private ArrayPool arrayPool;
// note jin: 内存缓存
private MemoryCache memoryCache;
// note jin: GlideExecutor 线程池
private GlideExecutor sourceExecutor;
private GlideExecutor diskCacheExecutor;
// note jin: 本地磁盘缓存
private DiskCache.Factory diskCacheFactory;
private MemorySizeCalculator memorySizeCalculator;
private ConnectivityMonitorFactory connectivityMonitorFactory;
……
Glide build(
@NonNull Context context,
List<GlideModule> manifestModules,
AppGlideModule annotationGeneratedGlideModule) {
// note jin: 实例化一个网络请求的线程池
if (sourceExecutor == null) {
sourceExecutor = GlideExecutor.newSourceExecutor();
}
// note jin: 实例化一个本地磁盘缓存的线程池
if (diskCacheExecutor == null) {
diskCacheExecutor = GlideExecutor.newDiskCacheExecutor();
}
// note jin: 实例化一个加载图片动画的一个线程池
if (animationExecutor == null) {
animationExecutor = GlideExecutor.newAnimationExecutor();
}
// note jin: 实例化一个对图片加载到内存的一个计算
if (memorySizeCalculator == null) {
memorySizeCalculator = new MemorySizeCalculator.Builder(context).build();
}
// note jin: 实例化一个默认网络连接监控的工厂
if (connectivityMonitorFactory == null) {
connectivityMonitorFactory = new DefaultConnectivityMonitorFactory();
}
if (bitmapPool == null) {
// note jin: 实例化一个 Bitmap 对象池
int size = memorySizeCalculator.getBitmapPoolSize();
if (size > 0) {
// note jin: 如果池子里还有可用的，直接加入 最近最少使用的 LruBitmap 容器里
bitmapPool = new LruBitmapPool(size);
} else {
// note jin: 如果池子已经满了，那么就装在 BitmapPoolAdapter
bitmapPool = new BitmapPoolAdapter();
}
}
if (arrayPool == null) {
arrayPool = new LruArrayPool(memorySizeCalculator.getArrayPoolSizeInBytes());
}
// note jin: 资源内存缓存
if (memoryCache == null) {
memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
}
// note jin: 磁盘缓存的工厂
if (diskCacheFactory == null) {
diskCacheFactory = new InternalCacheDiskCacheFactory(context);
}
// note jin: 构建执行缓存策略跟线程池的引擎
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();
// note jin: 实例化一个 RequestManagerRetriever 请求管理类
RequestManagerRetriever requestManagerRetriever =
new RequestManagerRetriever(requestManagerFactory);
// note jin: 实例化 Glide
return new Glide(
context,
engine,
memoryCache,
bitmapPool,
arrayPool,
requestManagerRetriever,
connectivityMonitorFactory,
logLevel,
defaultRequestOptionsFactory,
defaultTransitionOptions,
defaultRequestListeners,
manifestModules,
annotationGeneratedGlideModule,
experiments);
}
}