结合实例一步步讲解Glide关键源码文件的重要知识点

public class Glide {
    private static volatile Glide glide; // 单例模式

    // 初始化入口
    public static Glide get(Context context) {
        if (glide == null) {
            synchronized (Glide.class) {
                if (glide == null) {
                    Context applicationContext = context.getApplicationContext();
                    // 通过 GeneratedAppGlideModule 初始化（如应用自定义的 GlideModule）
                    glide = new GlideBuilder().build(applicationContext);
                }
            }
        }
        return glide;
    }

    // 构建 Glide 实例
    Glide build(Context context) {
        // 初始化线程池、注册默认组件（如 BitmapDecoder）
        Engine engine = new Engine(
            memoryCache, 
            diskCacheFactory, 
            diskCacheExecutor, 
            sourceExecutor
        );
        registry = new Registry();
        // 注册默认组件：例如 ImageViewTarget 用于绑定到 ImageView
        registry.register(ImageViewTarget.class, new ImageViewTargetFactory());
        // 加载 GlideModule 配置（通过注解处理器生成）
        GeneratedAppGlideModule module = getAnnotationGeneratedAppGlideModule();
        if (module != null) {
            module.applyOptions(context, new GlideBuilder());
        }
        return new Glide(context, engine, registry);
    }
}

public class RequestManager implements LifecycleListener {
    private final RequestTracker requestTracker = new RequestTracker();
    private final Lifecycle lifecycle;

    // 绑定生命周期
    public void onStart() {
        resumeRequests(); // 恢复请求
    }

    public void onStop() {
        pauseRequests(); // 暂停请求
    }

    public void onDestroy() {
        requestTracker.clearRequests(); // 销毁所有请求
    }

    // 发起请求的入口
    public RequestBuilder<Drawable> load(String url) {
        return asDrawable().load(url);
    }
}

public class Engine implements EngineJobListener {
    // 核心方法：触发资源加载
    public <R> LoadStatus load(...) {
        // 1. 生成缓存 Key（基于 URL、尺寸、签名等参数）
        EngineKey key = keyFactory.buildKey(model, width, height, transformations);

        // 2. 检查活动缓存（Active Resources）
        EngineResource<?> active = loadFromActiveResources(key);
        if (active != null) {
            return new LoadStatus(cb, active);
        }

        // 3. 检查内存缓存（Memory Cache）
        EngineResource<?> cached = loadFromCache(key);
        if (cached != null) {
            return new LoadStatus(cb, cached);
        }

        // 4. 未命中缓存，创建 EngineJob 和 DecodeJob
        EngineJob<R> engineJob = engineJobFactory.build(...);
        DecodeJob<R> decodeJob = decodeJobFactory.build(...);
        jobs.put(key, engineJob);
        engineJob.addCallback(cb);
        engineJob.start(decodeJob);
    }
}

class DecodeJob<R> implements Runnable {
    private DataFetcher<?> fetcher;
    private ResourceDecoder<?, ?> decoder;

    public void run() {
        try {
            // 状态机驱动流程
            runWrapped();
        } catch (Exception e) {
            onLoadFailed(e);
        }
    }

    private void runWrapped() {
        switch (runReason) {
            case INITIALIZE:
                // 确定数据来源：缓存（RESOURCE_CACHE/DATA_CACHE）或原始数据（SOURCE）
                stage = getNextStage(Stage.INITIALIZE);
                currentGenerator = getNextGenerator();
                runGenerators();
                break;
            case SWITCH_TO_SOURCE_SERVICE:
                runGenerators(); // 切换到 SourceExecutor 执行网络请求
                break;
        }
    }

    // 实际加载数据的方法
    private void runGenerators() {
        while (!isCancelled && currentGenerator.startNext()) {
            // 通过 DataFetcher 获取数据（例如 OkHttp 请求）
            // 获取到数据后，通过 ResourceDecoder 解码
        }
    }
}

public class LruResourceCache extends LruCache<Key, Resource<?>> implements MemoryCache {
    @Override
    protected int getSize(Resource<?> item) {
        // 计算 Bitmap 占用的内存大小
        return item.getSize();
    }

    @Override
    public void trimMemory(int level) {
        // 根据系统内存压力调整缓存大小
        if (level >= android.content.ComponentCallbacks2.TRIM_MEMORY_MODERATE) {
            clearMemory();
        }
    }
}

public class DiskLruCacheWrapper implements DiskCache {
    private final DiskLruCache diskLruCache;

    @Override
    public File get(Key key) {
        String safeKey = safeKeyGenerator.getSafeKey(key);
        // 生成缓存文件名（例如 "image_url_1234_0"）
        File file = new File(directory, safeKey + ".0");
        return file.exists() ? file : null;
    }

    @Override
    public void put(Key key, Writer writer) {
        // 写入磁盘（通过 FileLocks 防止并发冲突）
        DiskLruCache.Editor editor = diskLruCache.edit(safeKey);
        OutputStream os = editor.newOutputStream(0);
        writer.write(os); // 写入数据（如 Bitmap 压缩后的字节流）
        editor.commit();
    }
}