Glide源码基本流程跑通

with

public static RequestManager with(Activity activity) {
    //单例返回RequestManagerRetriever对象，构造中对应主线程
    RequestManagerRetriever retriever = RequestManagerRetriever.get();
    //多个重载方法
    return retriever.get(activity);//[1.1]
}

1.1 RequestManagerRetriever.get()

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public RequestManager get(Activity activity) {
    //低版本或者子线程中无法管理生命周期
    if (Util.isOnBackgroundThread() || Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
        return get(activity.getApplicationContext());
    } else {
        assertNotDestroyed(activity);
        //得到FragmentManager
        android.app.FragmentManager fm = activity.getFragmentManager();
        return fragmentGet(activity, fm);//[1.2]
    }
}

1.2 RequestManagerRetriever.fragmentGet()

由于生命周期在RequestManagerFragment中掌控，所以必须有核心类RequestManager做支持处理

@TargetApi(Build.VERSION_CODES.HONEYCOMB)
RequestManager fragmentGet(Context context, android.app.FragmentManager fm) {
    //得到的RequestManagerFragment是一个继承自Fragment的对象，并且绑定到了Activity中，所以生命周期同步
    //内部可以通过ActivityFragmentLifecycle这个对象进行生命周期方法的处理
    RequestManagerFragment current = getRequestManagerFragment(fm);
    //首次肯定为null
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
        requestManager = new RequestManager(context, current.getLifecycle(), current.getRequestManagerTreeNode());
        //将生成的RequestManager设置到RequestManagerFragment内部
        current.setRequestManager(requestManager);
    }
    return requestManager;
}

具体生命周期做了什么可以看RequestManagerFragment内部实现

现在看RequestManager类

RequestManager.java

public RequestManager(Context context, Lifecycle lifecycle, RequestManagerTreeNode treeNode) {
    this(context, lifecycle, treeNode, new RequestTracker(), new ConnectivityMonitorFactory());
}

RequestManager(Context context, final Lifecycle lifecycle, RequestManagerTreeNode treeNode,
        RequestTracker requestTracker, ConnectivityMonitorFactory factory) {
    this.context = context.getApplicationContext();
    this.lifecycle = lifecycle;//ActivityFragmentLifecycle
    this.treeNode = treeNode;//RequestManagerTreeNode
    this.requestTracker = requestTracker;//RequestTracker
    this.glide = Glide.get(context);
    this.optionsApplier = new OptionsApplier();
    //通过工厂构造一个连接监听器，工厂内部通过权限做判断，有网络情况使用DefaultConnectivityMonitor
    //内部有个广播接收器，如果收到广播则调用requestTracker中的restartRequests重启请求方法
    ConnectivityMonitor connectivityMonitor = factory.build(context,
            new RequestManagerConnectivityListener(requestTracker));
    
    //增加生命周期监听，这样就把生命周期回调的方法移植到RequestManager中
    if (Util.isOnBackgroundThread()) {
        new Handler(Looper.getMainLooper()).post(new Runnable() {
            @Override
            public void run() {
                lifecycle.addListener(RequestManager.this);
            }
        });
    } else {
        lifecycle.addListener(this);
    }
    //同样的，在生命周期的过程中有对链接的处理DefaultConnectivityMonitor
    lifecycle.addListener(connectivityMonitor);
}

由此可以看出RequestManager作为一个大类负责掌控这生命周期回调的大全，所以这里是核心中的核心也是一个掌控者。
当然，但是掌控者具体不做处理，只是作为管理，那么谁才是处理呢？那就是glide对象，下面分析此构造方法。

Glide

自定义model使用

<application
    android:allowBackup="true"
    android:icon="@mipmap/ic_launcher"
    android:label="@string/app_name"
    android:supportsRtl="true"
    android:theme="@style/AppTheme">
    <meta-data
        android:name="com.example.lizejun.repoglidelearn.CustomGlideModule"
        android:value="GlideModule"/>
</application>

public class CustomGlideModule implements GlideModule {

    @Override
    public void applyOptions(Context context, GlideBuilder builder) {
        //通过builder.setXXX进行配置.
    }

    @Override
    public void registerComponents(Context context, Glide glide) {
        //通过glide.register进行配置.
    }
}

public static Glide get(Context context) {
    if (glide == null) {
        synchronized (Glide.class) {
            if (glide == null) {
                Context applicationContext = context.getApplicationContext();
                //根据GlideModule标记进行解析，将反射的GlideModule放入列表中
                List<GlideModule> modules = new ManifestParser(applicationContext).parse();

                GlideBuilder builder = new GlideBuilder(applicationContext);
                for (GlideModule module : modules) {
                    //调用自定义model的实现方法applyOptions
                    module.applyOptions(applicationContext, builder);
                }
                //创造Glide对象
                glide = builder.createGlide();
                for (GlideModule module : modules) {
                    //进行注册
                    module.registerComponents(applicationContext, glide);
                }
            }
        }
    }
    return glide;
}

Glide createGlide() {
    //创建自己的线程池
    if (sourceService == null) {
        final int cores = Math.max(1, Runtime.getRuntime().availableProcessors());
        sourceService = new FifoPriorityThreadPoolExecutor(cores);
    }
    //再来一个线程池
    if (diskCacheService == null) {
        diskCacheService = new FifoPriorityThreadPoolExecutor(1);
    }
    //内存计算类
    MemorySizeCalculator calculator = new MemorySizeCalculator(context);
    //搞一个bitmap池
    if (bitmapPool == null) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
            int size = calculator.getBitmapPoolSize();
            bitmapPool = new LruBitmapPool(size);
        } else {
            bitmapPool = new BitmapPoolAdapter();
        }
    }
    //资源缓存
    if (memoryCache == null) {
        memoryCache = new LruResourceCache(calculator.getMemoryCacheSize());
    }
    //磁盘缓存
    if (diskCacheFactory == null) {
        diskCacheFactory = new InternalCacheDiskCacheFactory(context);
    }
    //处理引擎
    if (engine == null) {
        engine = new Engine(memoryCache, diskCacheFactory, diskCacheService, sourceService);
    }
    //默认编码
    if (decodeFormat == null) {
        decodeFormat = DecodeFormat.DEFAULT;
    }
    //创建这些组合对象完成之后构造Glide
    return new Glide(engine, memoryCache, bitmapPool, context, decodeFormat);
}

• 资源缓存
• 磁盘缓存
• bitmap缓存
• 默认编码格式
• 处理引擎
  • 磁盘线程池
  • 来源线程池

继续来到Glide构造

Glide(Engine engine, MemoryCache memoryCache, BitmapPool bitmapPool, Context context, DecodeFormat decodeFormat) {
    this.engine = engine;
    this.bitmapPool = bitmapPool;
    this.memoryCache = memoryCache;
    this.decodeFormat = decodeFormat;
    //各种加载方案的生成器
    loaderFactory = new GenericLoaderFactory(context);
    mainHandler = new Handler(Looper.getMainLooper());
    //bitmap的过滤器
    bitmapPreFiller = new BitmapPreFiller(memoryCache, bitmapPool, decodeFormat);
    //数据源注册器
    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());



    //注册不同模型
    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());


    //转换器的注册
    transcoderRegistry.register(Bitmap.class, GlideBitmapDrawable.class,
            new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool));
    transcoderRegistry.register(GifBitmapWrapper.class, GlideDrawable.class,
            new GifBitmapWrapperDrawableTranscoder(
                    new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool)));

    //裁剪注册
    bitmapCenterCrop = new CenterCrop(bitmapPool);
    drawableCenterCrop = new GifBitmapWrapperTransformation(bitmapPool, bitmapCenterCrop);

    //位图大小适配器注册
    bitmapFitCenter = new FitCenter(bitmapPool);
    drawableFitCenter = new GifBitmapWrapperTransformation(bitmapPool, bitmapFitCenter);
}

我们这个时候需要分析一下DataLoadProviderRegistry.register和GenericLoaderFactory.register到底是干什么的有什么作用

//DataLoadProviderRegistry
//在StreamBitmapDataLoadProvider中定义了
StreamBitmapDataLoadProvider streamBitmapLoadProvider = new StreamBitmapDataLoadProvider(bitmapPool, decodeFormat);
dataLoadProviderRegistry.register(InputStream.class, Bitmap.class, streamBitmapLoadProvider);

public StreamBitmapDataLoadProvider(BitmapPool bitmapPool, DecodeFormat decodeFormat) {
    sourceEncoder = new StreamEncoder();//流编码器，用于将原始数据写入磁盘
    decoder = new StreamBitmapDecoder(bitmapPool, decodeFormat);//解码器，用于从原始数据解码资源
    encoder = new BitmapEncoder();//位图编码器，用于将已经解码的资源写入磁盘
    cacheDecoder = new FileToStreamDecoder<Bitmap>(decoder);//用于解码磁盘中缓存中的资源
}

然后在分析DataLoadProviderRegistry.register方法

public <T, Z> void register(Class<T> dataClass, Class<Z> resourceClass, DataLoadProvider<T, Z> provider) {
    //MultiClassKey是将两种类型绑定起来当成一种类型进行处理
    providers.put(new MultiClassKey(dataClass, resourceClass), provider);
}

也就是说，dataProvider的处理是将这些数据的写入和读取做封装，用组合作为key，具体的key有：

• InputStream.class, Bitmap.class
• ParcelFileDescriptor.class, Bitmap.class
• ImageVideoWrapper.class, Bitmap.class
• InputStream.class, GifDrawable.class
• ImageVideoWrapper.class, GifBitmapWrapper.class
• InputStream.class, File.class

然后在分析Glide.register

先看内部结构

public <T, Y> void register(Class<T> modelClass, Class<Y> resourceClass, ModelLoaderFactory<T, Y> factory) {
    ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory);
    if (removed != null) {
        removed.teardown();
    }
}

其中用到了loaderFactory，这个是在Glide构造时候产生的，对应类型是GenericLoaderFactory

public <T, Y> void register(Class<T> modelClass, Class<Y> resourceClass, ModelLoaderFactory<T, Y> factory) {
    ModelLoaderFactory<T, Y> removed = loaderFactory.register(modelClass, resourceClass, factory);
    if (removed != null) {
        removed.teardown();
    }
}

public synchronized <T, Y> ModelLoaderFactory<T, Y> register(Class<T> modelClass, Class<Y> resourceClass,
        ModelLoaderFactory<T, Y> factory) {
    cachedModelLoaders.clear();

    Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> resourceToFactories = modelClassToResourceFactories.get(modelClass);
    if (resourceToFactories == null) {
        resourceToFactories = new HashMap<Class/*Y*/, ModelLoaderFactory/*T, Y*/>();
        modelClassToResourceFactories.put(modelClass, resourceToFactories);
    }

    ModelLoaderFactory/*T, Y*/ previous = resourceToFactories.put(resourceClass, factory);

    //下面操作是去掉重复的老值
    if (previous != null) {
        // This factory may be being used by another model. We don't want to say it has been removed unless we
        // know it has been removed for all models.
        for (Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/> factories : modelClassToResourceFactories.values()) {
            if (factories.containsValue(previous)) {
                previous = null;
                break;
            }
        }
    }
    return previous;
}

这里注意hashmap的put方法，如果put成功了则返回null，如果key重复了，就返回原来的值

看下这块数据结构：

private final Map<Class , Map<Class, ModelLoaderFactory>> modelClassToResourceFactories = new HashMap<Class, Map<Class, ModelLoaderFactory>>();

第一个class是modelClass，第二个class是resourceClass，ModelLoaderFactory是factory

那也就是说，主要是用模型来映射资源类和工厂类

然后总结效果图：

- File对应的如下：
    - ParcelFileDescriptor：FileDescriptorFileLoader
    - InputStream：StreamFileLoader
- int：
    - ParcelFileDescriptor：FileDescriptorResourceLoader
    - InputStream：StreamResourceLoader
- Integer：
    - ParcelFileDescriptor：FileDescriptorResourceLoader
    - InputStream：StreamResourceLoader
- String：
    - ParcelFileDescriptor：FileDescriptorStringLoader
    - InputStream：StreamStringLoader
- Uri：
    - ParcelFileDescriptor：FileDescriptorUriLoader
    - InputStream：StreamUriLoader

- URL：
    - InputStream：StreamUrlLoader
- GlideUrl：
    - InputStream：HttpUrlGlideUrlLoader
- byte：
    - InputStream：StreamByteArrayLoader

我们大概看一眼工厂都干啥

public interface ModelLoaderFactory<T, Y> {
    ModelLoader<T, Y> build(Context context, GenericLoaderFactory factories);
    void teardown();
}

public static class Factory implements ModelLoaderFactory<String, InputStream> {
    public Factory() {
    }
    //主要方法是build，进行构造对应类
    public ModelLoader<String, InputStream> build(Context context, GenericLoaderFactory factories) {
        return new StreamStringLoader(factories.buildModelLoader(Uri.class, InputStream.class));
    }

    public void teardown() {
    }
}

所以工厂类就是专门提供创建获取资源的数据的类。

---

小结：

DataLoadProviderRegistry注册器注册了什么：

//注册进了
Map<MultiClassKey, DataLoadProvider<?, ?>> providers;
providers.put(new MultiClassKey(dataClass, resourceClass), provider);

• InputStream
  • Bitmap : StreamBitmapDataLoadProvider
  • GifDrawable : GifDrawableLoadProvider
  • File : StreamFileDataLoadProvider
• ParcelFileDescriptor
  • Bitmap : FileDescriptorBitmapDataLoadProvider
• ImageVideoWrapper
  • Bitmap : ImageVideoDataLoadProvider
  • GifBitmapWrapper : ImageVideoGifDrawableLoadProvider

GenericLoaderFactory.loaderFactory注册器注册了什么：

//注册进了
Map<Class/*T*/, Map<Class/*Y*/, ModelLoaderFactory/*T, Y*/>> modelClassToResourceFactories;

• File
  • ParcelFileDescriptor : FileDescriptorFileLoader
  • InputStream : StreamFileLoader
• int
  • ParcelFileDescriptor : FileDescriptorResourceLoader
  • InputStream : StreamResourceLoader
• Integer
  • ParcelFileDescriptor : FileDescriptorResourceLoader
  • InputStream : StreamResourceLoader
• String
  • ParcelFileDescriptor:FileDescriptorStringLoader
  • InputStream:StreamStringLoader
• Uri
  • ParcelFileDescriptor:FileDescriptorUriLoader
  • InputStream:StreamUriLoader
• URL
  • InputStream:StreamUrlLoader
• GlideUrl
  • InputStream:HttpUrlGlideUrlLoader
• byte
  • InputStream:StreamByteArrayLoader

TranscoderRegistry.transcoderRegistry注册器注册了什么：

//同理这个注册进了
Map<MultiClassKey, ResourceTranscoder<?, ?>> factories;
factories.put(new MultiClassKey(decodedClass, transcodedClass), transcoder);

• Bitmap
  • GlideBitmapDrawable : GlideBitmapDrawableTranscoder
• GifBitmapWrapper
  • GlideDrawable : GifBitmapWrapperDrawableTranscoder

---

load

public DrawableTypeRequest<String> load(String string) {
    return (DrawableTypeRequest<String>) fromString().load(string);
}
public DrawableTypeRequest<Uri> load(Uri uri) {
    return (DrawableTypeRequest<Uri>) fromUri().load(uri);
}
public DrawableTypeRequest<File> load(File file) {
    return (DrawableTypeRequest<File>) fromFile().load(file);
}

从fromString()开始分析

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

private <T> DrawableTypeRequest<T> loadGeneric(Class<T> modelClass) {
    //通过loaderFactory去找
    //拿到了FileDescriptorStringLoader
    ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);
    //拿到了StreamStringLoader
    ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
            Glide.buildFileDescriptorModelLoader(modelClass, context);
    if (modelClass != null && streamModelLoader == null && fileDescriptorModelLoader == null) {
        throw new IllegalArgumentException("xxx");
    }

    //根据String.class和FileDescriptorStringLoader，了StreamStringLoader等构造DrawableTypeRequest
    return optionsApplier.apply(
            new DrawableTypeRequest<T>(modelClass, streamModelLoader, fileDescriptorModelLoader, context,
                    glide, requestTracker, lifecycle, optionsApplier));
}

针对下面这句代码，做如下分析

ModelLoader<T, InputStream> streamModelLoader = Glide.buildStreamModelLoader(modelClass, context);

首先modelClass是String.class

public static <T> ModelLoader<T, InputStream> buildStreamModelLoader(Class<T> modelClass, Context context) {
    return buildModelLoader(modelClass, InputStream.class, context);
}

所以传入和是String.class和InputStream.class

然后通过这两种类型去loader工厂中找。这个时候我们就要看我们当初注册的了。

public ModelLoader<String, InputStream> build(Context context, GenericLoaderFactory factories) {
    return new StreamStringLoader(factories.buildModelLoader(Uri.class, InputStream.class));
}

所以返回的是这样一个ModelLoader。

然后我们分析下一句：

传入的是String.class和

ModelLoader<T, ParcelFileDescriptor> fileDescriptorModelLoader =
        Glide.buildFileDescriptorModelLoader(modelClass, context);

所以还是老套路，通过String.class和ParcelFileDescriptor.class在列表中找。

看上面这一句。

先看DrawableTypeRequest的构造

参数列表：

• String.class
• StreamStringLoader
• FileDescriptorStringLoader
• context
• glide
• RequestTracker
• Lifecycle
• RequestManager.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);
    this.streamModelLoader = streamModelLoader;
    this.fileDescriptorModelLoader = fileDescriptorModelLoader;
    this.optionsApplier = optionsApplier;
}

将这些大杂烩集中起来

DrawableTypeRequest 参数列表：

• String.class
• StreamStringLoader
• FileDescriptorStringLoader
• context
• glide
• RequestTracker
• Lifecycle
• RequestManager.OptionsApplier

DrawableRequestBuilder extends DrawableRequestBuilder

DrawableTypeRequest传入的参数

变量	类型
T	String.class
modelClass	String.class
streamModelLoader	StreamStringLoader
fileDescriptorModelLoader	FileDescriptorStringLoader
context	Context
glide	Glide
requestTracker	RequestTracker
lifecycle	Lifecycle
optionsApplier	OptionsApplier

buildProvider(xxx)

所需参数

变量	类型
glide	Glide
streamModelLoader	StreamStringLoader
fileDescriptorModelLoader	FileDescriptorStringLoader
resourceClass	GifBitmapWrapper.class
transcodedClass	GlideDrawable.class
null	ResourceTranscoder.class

然后看实现部分：

1. transcoder==null，然后根据GifBitmapWrapper.class和GlideDrawable.class进行build出ResourceTranscoder
   在gilde的构造中：

所以第一步可以看出，得到的是

new GifBitmapWrapperDrawableTranscoder(new GlideBitmapDrawableTranscoder(context.getResources(), bitmapPool))

2. 根据ImageVideoWrapper.class和GifBitmapWrapper.class进行build

同样在glide的构造中得到对应的注册表

所以这里得到的是：

new ImageVideoGifDrawableLoadProvider(imageVideoDataLoadProvider, gifDrawableLoadProvider, bitmapPool)

3. 根据StreamStringLoader的对象和FileDescriptorStringLoader对象创建了一个ImageVideoModelLoader

ImageVideoModelLoader<A> modelLoader = new ImageVideoModelLoader<A>(streamModelLoader,fileDescriptorModelLoader);

4. 生成一个FixedLoadProvider进行返回

其中FixedLoadProvider持有：

• ImageVideoModelLoader modelLoader
• GifBitmapWrapperDrawableTranscoder transcoder
• ImageVideoGifDrawableLoadProvider dataLoadProvider
  

然后这个时候回到DrawableTypeRequest中继续super方法进入DrawableRequestBuilder extends GenericRequestBuilder构造

参数传入的是

变量	类型
modelClass	String.class
context	Context
loadProvider	LoadProvider<ModelType, ImageVideoWrapper, GifBitmapWrapper, GlideDrawable> loadProvider
glide	Glide
requestTracker	RequestTracker
lifecycle	Lifecycle

继续GenericRequestBuilder构造

继承关系图如下：

---

into

由于执行load返回的是DrawableTypeRequest对象，所以在其中搜into方法

public Target<GlideDrawable> into(ImageView view) {
    return super.into(view);
}

注意transcodeClass是GlideDrawable.class

先进入：

glide.buildImageViewTarget(view, transcodeClass)

通过一个ImageView和GlideDrawable.classbuildTarget

private final ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
<R> Target<R> buildImageViewTarget(ImageView imageView, Class<R> transcodedClass) {
    return imageViewTargetFactory.buildTarget(imageView, transcodedClass);
}

public <Z> Target<Z> buildTarget(ImageView view, Class<Z> clazz) {
    if (GlideDrawable.class.isAssignableFrom(clazz)) {
        return (Target<Z>) new GlideDrawableImageViewTarget(view);
    } else if (Bitmap.class.equals(clazz)) {
        return (Target<Z>) new BitmapImageViewTarget(view);
    } else if (Drawable.class.isAssignableFrom(clazz)) {
        return (Target<Z>) new DrawableImageViewTarget(view);
    } else {
        throw new IllegalArgumentException("Unhandled class: " + clazz
                + ", try .as*(Class).transcode(ResourceTranscoder)");
    }
}

可见返回的是GlideDrawableImageViewTarget

然后进入into方法

GenericRequestBuilder.into()

//传入的是GlideDrawableImageViewTarget

public <Y extends Target<TranscodeType>> Y into(Y target) {
    Util.assertMainThread();
    if (target == null) {
        throw new IllegalArgumentException("You must pass in a non null Target");
    }
    if (!isModelSet) {
        throw new IllegalArgumentException("You must first set a model (try #load())");
    }

    Request previous = target.getRequest();

    if (previous != null) {
        previous.clear();
        requestTracker.removeRequest(previous);
        previous.recycle();
    }
    //核心在创造一个Request
    Request request = buildRequest(target);
    target.setRequest(request);
    lifecycle.addListener(target);
    //这一波说明RequestTracker添加了该请求&运行
    requestTracker.runRequest(request);

    return target;
}

核心就是构造一个请求，然后设置请求然后运行

target : GlideDrawableImageViewTarget

在buildRequest中最主要是执行了

当请求设置好之后就进行runRequest的操作了

public void runRequest(Request request) {
    requests.add(request);
    if (!isPaused) {
        request.begin();
    } else {
        //如果是暂停状态则放入稍后启动请求列表
        pendingRequests.add(request);
    }
}

GenericRequest.begin()

public void begin() {
    startTime = LogTime.getLogTime();
    if (model == null) {
        onException(null);
        return;
    }

    status = Status.WAITING_FOR_SIZE;
    if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
        onSizeReady(overrideWidth, overrideHeight);//符合大小规范
    } else {
        target.getSize(this);
    }

    if (!isComplete() && !isFailed() && canNotifyStatusChanged()) {
        target.onLoadStarted(getPlaceholderDrawable());
    }
    if (Log.isLoggable(TAG, Log.VERBOSE)) {
        logV("finished run method in " + LogTime.getElapsedMillis(startTime));
    }
}

最后进入onSizeReady()

分析下里面的传参

header 1	header 2
signature	EmptySignature
dataFetcher	DataFetcher有若干中实现

ModelLoader<A, T> modelLoader = loadProvider.getModelLoader();
final DataFetcher<T> dataFetcher = modelLoader.getResourceFetcher(model, width, height);

所以在ImageVideoModelLoader中寻找

总之最后是HttpUrlFetcher对象

@Override
public DataFetcher<ImageVideoWrapper> getResourceFetcher(A model, int width, int height) {
    DataFetcher<InputStream> streamFetcher = null;
    if (streamLoader != null) {
        //StreamStringLoader
        streamFetcher = streamLoader.getResourceFetcher(model, width, height);
    }
    DataFetcher<ParcelFileDescriptor> fileDescriptorFetcher = null;
    if (fileDescriptorLoader != null) {
        //FileDescriptorStringLoader
        fileDescriptorFetcher = fileDescriptorLoader.getResourceFetcher(model, width, height);
    }

    if (streamFetcher != null || fileDescriptorFetcher != null) {
        return new ImageVideoFetcher(streamFetcher, fileDescriptorFetcher);
    } else {
        return null;
    }
}

针对streamFetcher = streamLoader.getResourceFetcher(model, width, height);

所以在glide的参数列表中找到

所以走到load里面

核心方法上图

其中最核心的是：

final A data = fetcher.loadData(priority);

真正的链接

所以A是个InputStream

所以后面就是根据流来获取一个Resource对象。

1. 转换，转化长和宽等
2. 写入缓存
3. 是否将其编码成其他对象
   callback执行这里

找下target，知道当时是GlideDrawableImageViewTarget，所以走到如下

我们看到轮播gif，到这里super.onResourceReady(resource, animation);

最后执行

显示图片。