Glide.with(context).load("url").thumbnail().into(imageView);

Glide.java

GenericLoaderFactory loaderFactory;   // 工厂管理类，负责 ModelLoader 的注册和缓存实现
TranscoderRegistry transcoderRegistry = new TranscoderRegistry(); // ResourceTranscoder 工厂管理类
DataLoadProviderRegistry dataLoadProviderRegistry; // DataLoadProvider 注册管理

Engine engine; // 负责从内存缓存、文件缓存、数据源中获取资源
BitmapPool bitmapPool; // 用来控制复用 Bitmap 的内存空间
MemoryCache memoryCache; // Lru 内存缓存

// 生命周期方法
onAttach()
onDetach()
onStart()
onStop()
onDestroy()

// 内存不足回调
onTrimMemory(int level)
onLowMemory()

// RequestManagerRetriever.java

// 从 Activity 开始
public RequestManager get(Activity activity) {
    return fragmentGet(activity, fm);
}

// 从 Fragment 开始
public RequestManager get(Fragment fragment) {
    FragmentManager fm = fragment.getChildFragmentManager();
    return supportFragmentGet(fragment.getActivity(), fm);
}

// 从 Fragment 中取得 RequestManager
RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
    RequestManagerFragment current = getRequestManagerFragment(fm);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
        requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
        current.setRequestManager(requestManager);
    }
    return requestManager;
}

// 从 android.app.FragmentManager 获取 Fragment，没有的话会添加新的
RequestManagerFragment getRequestManagerFragment(final android.app.FragmentManager fm) {
    RequestManagerFragment current = (RequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
        current = pendingRequestManagerFragments.get(fm);
        if (current == null) {
            current = new RequestManagerFragment();
            pendingRequestManagerFragments.put(fm, current);
            fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
            handler.obtainMessage(ID_REMOVE_FRAGMENT_MANAGER, fm).sendToTarget();
        }
    }
    return current;
}

public static RequestManager with(Context context) {
    RequestManagerRetriever retriever = RequestManagerRetriever.get();
    return retriever.get(context);
}

ConnectivityMonitor connectivityMonitor = factory.build(context,
        new RequestManagerConnectivityListener(requestTracker));

private final Set<Request> requests = Collections.newSetFromMap(new WeakHashMap<Request, Boolean>());
private final List<Request> pendingRequests = new ArrayList<Request>();

RequestManager.java

public DrawableTypeRequest<String> load(String string) {
    return (DrawableTypeRequest<String>) fromString().load(string);
}
public DrawableTypeRequest<String> fromString() {
    return loadGeneric(String.class);
}

public DrawableTypeRequest<File> load(File file){...}
public DrawableTypeRequest<File> fromFile(){...}

public DrawableTypeRequest<Uri> load(Uri uri){...}
public DrawableTypeRequest<Uri> fromUri(){...}

public DrawableTypeRequest<Integer> load(Integer resourceId){...}
public DrawableTypeRequest<Integer> fromResource(){...}

public DrawableTypeRequest<byte[]> load(byte[] model){...}
public DrawableTypeRequest<byte[]> fromBytes(){...}

RequestManager.java

private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {
    ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
    ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
            Glide.buildFileDescriptorModelLoader(modelClass, context);
    return optionsApplier.apply(
            new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                    glide, requestTracker, lifecycle, optionsApplier));
}

DrawableTypeRequest(Class<ModelType> modelClass, ModelLoader<ModelType, InputStream> streamModelLoader,
        ModelLoader<ModelType, ParcelFileDescriptor> fileDescriptorModelLoader, Context context, Glide glide,
        RequestTracker requestTracker, Lifecycle lifecycle, RequestManager.OptionsApplier optionsApplier) {
    super(context, modelClass,
            buildProvider(glide, streamModelLoader, fileDescriptorModelLoader, GifBitmapWrapper.class,
                    GlideDrawable.class, null),glide, requestTracker, lifecycle);
}

DrawableRequestBuilder(Context context, Class<ModelType> modelClass,
        LoadProvider<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable> loadProvider, Glide glide,
        RequestTracker requestTracker, Lifecycle lifecycle) {
}

// 控制图片尺寸
thumbnail(float size) // 0-1,先加载缩略图，内部实现是创建一个新的 thumbnailRequest
sizeMultiplier(float size) // 0-1，控制加载图片的大小，和缩略图有本质区别
override() // 加载指定大小图片

// 编解码器
encoder()
cacheDecoder()
decoder()
sourceEncoder()

// 缓存策略和优先级
diskCacheStrategy() // 磁盘缓存策略
priority() // 请求的优先级别，缩略图的优先级总会比原图高一些
skipMemoryCache() // 跳过内存缓存

// 变换和动画
transform() // 对图片进行变化，比如圆形裁剪
dontTransform() // 去掉变换效果
transcoder()
animate() // 加载动画
dontAnimate() // 去掉加载动画

// 占位图
placeholder() // 加载时占位图
fallback() // 资源为null时的占位图，没有将会使用 error
error() // 加载失败占位图

// 其他
listener() // 加载监听
signature() // 唯一标记

// 加载
preload() // 提前加载准备资源到内存中，下次使用时速度会快
into() // 加载到指定 target

private Key signature = EmptySignature.obtain(); // 对应 signature()
private RequestListener<? super ModelType, TranscodeType> requestListener; // 对应 listener()
private Float thumbSizeMultiplier; // 对应 thumbnail()
private GenericRequestBuilder<?, ?, ?, TranscodeType> thumbnailRequestBuilder; // 对应 thumbnail()
private Float sizeMultiplier = 1f; // 对应 sizeMultiplier()
private Priority priority = null; // 对应 priority()
private boolean isCacheable = true; // 对应 skipMemoryCache()
private GlideAnimationFactory<TranscodeType> animationFactory = NoAnimation.getFactory(); // 对应 animate()
private int overrideHeight = -1; // 对应 overide()
private int overrideWidth = -1; // 对应 overide()
private DiskCacheStrategy diskCacheStrategy = DiskCacheStrategy.RESULT; // 对应 diskCacheStrategy()
private Transformation<ResourceType> transformation = UnitTransformation.get(); // 对应 transform()
// 缩略图
private int placeholderId;
private Drawable placeholderDrawable;
private int errorId;
private Drawable errorPlaceholder;
private Drawable fallbackDrawable;
private int fallbackResource;

public <Y extends Target<TranscodeType>> Y into(Y target) {
    Util.assertMainThread();
    Request previous = target.getRequest();
    if (previous != null) {
        previous.clear();
        requestTracker.removeRequest(previous);
        previous.recycle();
    }
    Request request = buildRequest(target);
    target.setRequest(request);
    lifecycle.addListener(target);
    requestTracker.runRequest(request);
    return target;
}

private Request buildRequestRecursive(Target<TranscodeType> target, ThumbnailRequestCoordinator parentCoordinator) {
    if (thumbnailRequestBuilder != null) {
        if (thumbnailRequestBuilder.animationFactory.equals(NoAnimation.getFactory())) {
            thumbnailRequestBuilder.animationFactory = animationFactory;
        }
        if (thumbnailRequestBuilder.priority == null) {
            thumbnailRequestBuilder.priority = getThumbnailPriority();
        }
        if (Util.isValidDimensions(overrideWidth, overrideHeight)
                && !Util.isValidDimensions(thumbnailRequestBuilder.overrideWidth,
                        thumbnailRequestBuilder.overrideHeight)) {
          thumbnailRequestBuilder.override(overrideWidth, overrideHeight);
        }
        ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
        Request fullRequest = obtainRequest(target, sizeMultiplier, priority, coordinator);
        // Guard against infinite recursion.
        isThumbnailBuilt = true;
        // Recursively generate thumbnail requests.
        Request thumbRequest = thumbnailRequestBuilder.buildRequestRecursive(target, coordinator);
        isThumbnailBuilt = false;
        coordinator.setRequests(fullRequest, thumbRequest);
        return coordinator;
    } else if (thumbSizeMultiplier != null) {
        ThumbnailRequestCoordinator coordinator = new ThumbnailRequestCoordinator(parentCoordinator);
        Request fullRequest = obtainRequest(target, sizeMultiplier, priority, coordinator);
        Request thumbnailRequest = obtainRequest(target, thumbSizeMultiplier, getThumbnailPriority(), coordinator);
        coordinator.setRequests(fullRequest, thumbnailRequest);
        return coordinator;
    } else {
        return obtainRequest(target, sizeMultiplier, priority, parentCoordinator);
    }
}

GenericRequest.java

public void onSizeReady(int width, int height) {
    status = Status.RUNNING;
    width = Math.round(sizeMultiplier * width);
    height = Math.round(sizeMultiplier * height);
    ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
    final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);
    ResourceTranscoder<Z, R> transcoder = loadProvider.getTranscoder();
    loadedFromMemoryCache = true;
    loadStatus = engine.load(signature, width, height, dataFetcher, loadProvider, transformation, transcoder,
            priority, isMemoryCacheable, diskCacheStrategy, this);
    loadedFromMemoryCache = resource != null;
}

Engine.java

public <T, Z, R> LoadStatus load(...) {
    EngineKey key = ...
    // 内存中获取
    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable);
    if (cached != null) {
        cb.onResourceReady(cached);
        return null;
    }
    // 内存中获取
    EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable);
    if (active != null) {
        cb.onResourceReady(active);
        return null;
    }
    // 该任务是不是正在执行
    EngineJob current = jobs.get(key);
    if (current != null) {
        current.addCallback(cb);
        return new LoadStatus(cb, current);
    }
    // 从文件缓存和数据源获取、包含资源的编解码等
    EngineJob engineJob = ...
    EngineRunnable runnable = new EngineRunnable(engineJob, decodeJob, priority);
    jobs.put(key, engineJob);
    engineJob.addCallback(cb);
    engineJob.start(runnable);
    return new LoadStatus(cb, engineJob);
}

Engine.java

private final MemoryCache cache;  // Lru 缓存
private final Map<Key, WeakReference<EngineResource<?>>> activeResources; //  虚引用缓存
private final LazyDiskCacheProvider diskCacheProvider; // 文件 Lru 缓存

EngineRunnable.java

public void run() {
    resource = decode();
}

private Resource<?> decode() throws Exception {
    if (isDecodingFromCache()) {
        return decodeFromCache();
    } else {
        return decodeFromSource();
    }
}

private void onLoadFailed(Exception e) {
    if (isDecodingFromCache()) {
        stage = Stage.SOURCE;
        manager.submitForSource(this);
    } else {
        manager.onException(e);
    }
}

public interface ModelLoader<T, Y> {
    DataFetcher<Y> getResourceFetcher(T model, int width, int height);
}

Map<Class/*T*/, Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/>>

Map<String,Map<InputStream, ModelLoaderFactory<String,InputStream>>>

Map<String,Map<ParcelFileDescriptor, ModelLoaderFactory<String, ParcelFileDescriptor>>>

GenericLoaderFactory.java

private <T, Y> ModelLoaderFactory<T, Y> getFactory(Class<T> modelClass, Class<Y> resourceClass) {
    Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClas
    ModelLoaderFactory/*T, Y*/ result = null;
    if (resourceToFactories != null) {
        result = resourceToFactories.get(resourceClass);
    }
    if (result == null) {
        for (Class<? super T> registeredModelClass : modelClassToResourceFactories.keySet()) {
            if (registeredModelClass.isAssignableFrom(modelClass)) {
                Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> currentResourceToFactories =
                        modelClassToResourceFactories.get(registeredModelClass);
                if (currentResourceToFactories != null) {
                    result = currentResourceToFactories.get(resourceClass);
                    if (result != null) {
                        break;
                    }
                }
            }
        }
    }
    return result;
}

GenericLoaderFactory.java

public class GenericLoaderFactory {
    // 注册表
    private final Map<Class/*T*/, Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/>> modelClassToResourceFactories =
            new HashMap<Class, Map<Class, ModelLoaderFactory>>();
    // 缓存实现
    private final Map<Class/*T*/, Map<Class/*Y*/, ModelLoader/*T, Y*/>> cachedModelLoaders =
            new HashMap<Class, Map<Class, ModelLoader>>();
}

register(File.class, ParcelFileDescriptor.class, new FileDescriptorFileLoader.Factory());
register(File.class, InputStream.class, new StreamFileLoader.Factory());
register(int.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory());
register(int.class, InputStream.class, new StreamResourceLoader.Factory());
register(Integer.class, ParcelFileDescriptor.class, new FileDescriptorResourceLoader.Factory()
register(Integer.class, InputStream.class, new StreamResourceLoader.Factory());
register(String.class, ParcelFileDescriptor.class, new FileDescriptorStringLoader.Factory());
register(String.class, InputStream.class, new StreamStringLoader.Factory());
register(Uri.class, ParcelFileDescriptor.class, new FileDescriptorUriLoader.Factory());
register(Uri.class, InputStream.class, new StreamUriLoader.Factory());
register(URL.class, InputStream.class, new StreamUrlLoader.Factory());
register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());
register(byte[].class, InputStream.class, new StreamByteArrayLoader.Factory());

register(GlideUrl.class, InputStream.class, new HttpUrlGlideUrlLoader.Factory());

public class HttpUrlGlideUrlLoader implements ModelLoader<GlideUrl, InputStream> {

    private final ModelCache<GlideUrl, GlideUrl> modelCache;

    public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> {
        private final ModelCache<GlideUrl, GlideUrl> modelCache = new ModelCache<GlideUrl, GlideUrl>(500);
        @Override
        public ModelLoader<GlideUrl, InputStream> build(Context context, GenericLoaderFactory factories) {
            return new HttpUrlGlideUrlLoader(modelCache);
        }
    }

    @Override
    public DataFetcher<InputStream> getResourceFetcher(GlideUrl model, int width, int height) {
        return new HttpUrlFetcher(url);
    }
}

public interface DataLoadProvider<T, Z> {
    ResourceDecoder<File, Z> getCacheDecoder(); // 缓存解码器，从文件缓存中解码出目标资源
    ResourceDecoder<T, Z> getSourceDecoder(); // 数据源解码器，从数据源中解码出目标资源
    Encoder<T> getSourceEncoder(); // 数据源编码器，将数据源编码到 OutputStream
    ResourceEncoder<Z> getEncoder(); // 资源解码器，将资源编码到 OutputStream
}

public class StreamBitmapDataLoadProvider implements DataLoadProvider<InputStream, Bitmap> {
    private final StreamBitmapDecoder decoder;
    private final BitmapEncoder encoder;
    private final StreamEncoder sourceEncoder;
    private final FileToStreamDecoder<Bitmap> cacheDecoder;

    public StreamBitmapDataLoadProvider(BitmapPool bitmapPool, DecodeFormat decodeFormat) {
        sourceEncoder = new StreamEncoder();
        decoder = new StreamBitmapDecoder(bitmapPool, decodeFormat);
        encoder = new BitmapEncoder();
        cacheDecoder = new FileToStreamDecoder<Bitmap>(decoder);
    }

    @Override
    public ResourceDecoder<File, Bitmap> getCacheDecoder() {
        // 缓存解码器，从文件缓存中解码出目标资源
        // 这里就是将 File 解码成 Bitmap
        return cacheDecoder;
    }

    @Override
    public ResourceDecoder<InputStream, Bitmap> getSourceDecoder() {
        // 数据源解码器，从数据源中解码出目标资源
        // 这里是将请求回来的 InputStream 解码成 Bitmap
        return decoder;
    }

    @Override
    public Encoder<InputStream> getSourceEncoder() {
        // 数据源编码器，将数据源编码到 OutputStream
        // 这里是将请求回来的 InputStream 转换成 OutputStream 用来存文件什么的
        return sourceEncoder;
    }

    @Override
    public ResourceEncoder<Bitmap> getEncoder() {
        // 资源解码器，将资源编码到 OutputStream
        // 将已经转换好的 Bitmap 转成 OutputStream 用来存文件什么的
        return encoder;
    }
}

public class DataLoadProviderRegistry {
    private static final MultiClassKey GET_KEY = new MultiClassKey();
    private final Map<MultiClassKey, DataLoadProvider<?, ?>> providers =
            new HashMap<MultiClassKey, DataLoadProvider<?, ?>>();
}

Glide.java

dataLoadProviderRegistry = new DataLoadProviderRegistry();
StreamBitmapDataLoadProvider streamBitmapLoadProvider =
        new StreamBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(InputStream.class, Bitmap.class, streamBitmapLoadProvider);
FileDescriptorBitmapDataLoadProvider fileDescriptorLoadProvider =
        new FileDescriptorBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(ParcelFileDescriptor.class, Bitmap.class, fileDescriptorLoadProvider);
ImageVideoDataLoadProvider imageVideoDataLoadProvider =
        new ImageVideoDataLoadProvider(streamBitmapLoadProvider, fileDescriptorLoadProvider);
dataLoadProviderRegistry.register(ImageVideoWrapper.class, Bitmap.class, imageVideoDataLoadProvider);
GifDrawableLoadProvider gifDrawableLoadProvider =
        new GifDrawableLoadProvider(context, bitmapPool);
dataLoadProviderRegistry.register(InputStream.class, GifDrawable.class, gifDrawableLoadProvider);
dataLoadProviderRegistry.register(ImageVideoWrapper.class, GifBitmapWrapper.class,
        new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool));
dataLoadProviderRegistry.register(InputStream.class, File.class, new StreamFileDataLoadProvider());

public interface ResourceTranscoder<Z, R> {
    Resource<R> transcode(Resource<Z> toTranscode);
}

public class TranscoderRegistry {
    private static final MultiClassKey GET_KEY = new MultiClassKey();

    private final Map<MultiClassKey, ResourceTranscoder<?, ?>> factories =
            new HashMap<MultiClassKey, ResourceTranscoder<?, ?>>();
}

Glide.java

transcoderRegistry.register(Bitmap.class, GlideBitmapDrawable.class,
        new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool));
transcoderRegistry.register(GifBitmapWrapper.class, GlideDrawable.class,
        new GifBitmapWrapperDrawableTranscoder(
                new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool)));

public class GenericRequestBuilder<ModelType, DataType, ResourceType, TranscodeType> {}
public class GenericRequestBuilder<File, InputStream, Bitmap, GlideDrawable> {}