Glide是google推薦的圖片加載框架，很受開發者追捧，它提高了我們開發效率，減少了很多問題。優秀的框架就值得我們去學習，我們來看一下具體它是怎么實現的

我們使用glide的方式很簡單，就這一行代碼Glide.with(this).load(imageUrl).into(imageView)，看似簡單，但里面的實現特別復雜，我們就來一步步揭開它的面紗
本篇以glide 4.6.0版本來講解

Glide.with(this)

先看一下Glide初始化

  private static void initializeGlide(@NonNull Context context, @NonNull GlideBuilder builder) {
    Context applicationContext = context.getApplicationContext();
    RequestManagerRetriever.RequestManagerFactory factory =
        annotationGeneratedModule != null
            ? annotationGeneratedModule.getRequestManagerFactory() : null;
    builder.setRequestManagerFactory(factory);
     //通過builder來創建
    Glide glide = builder.build(applicationContext);
    applicationContext.registerComponentCallbacks(glide);
    Glide.glide = glide;
  }

利用GlideBuilder進行創建

  public Glide build(@NonNull Context context) {
    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();
    }
    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());
    }
    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(),
              GlideExecutor.newAnimationExecutor(),
              isActiveResourceRetentionAllowed);
    }
    RequestManagerRetriever requestManagerRetriever =
        new RequestManagerRetriever(requestManagerFactory);
    return new Glide(
        context,
        engine,
        memoryCache,
        bitmapPool,
        arrayPool,
        requestManagerRetriever,
        connectivityMonitorFactory,
        logLevel,
        defaultRequestOptions.lock(),
        defaultTransitionOptions);
  }

Glide的真正初始化

  Glide(
      @NonNull Context context,
      @NonNull Engine engine,
      @NonNull MemoryCache memoryCache,
      @NonNull BitmapPool bitmapPool,
      @NonNull ArrayPool arrayPool,
      @NonNull RequestManagerRetriever requestManagerRetriever,
      @NonNull ConnectivityMonitorFactory connectivityMonitorFactory,
      int logLevel,
      @NonNull RequestOptions defaultRequestOptions,
      @NonNull Map<Class<?>, TransitionOptions<?, ?>> defaultTransitionOptions) {
    //請求管理器，在Glide.get(context).getRequestManagerRetriever()時候返回
    this.requestManagerRetriever = requestManagerRetriever;

    //這是注冊表，數據的請求和解析都靠它，這里面有資源解碼注冊表，轉碼注冊表，模型加載注冊表，編碼器
    //加載網路圖片用到了前面三個，這個很關鍵
    registry = new Registry();
    registry.register(new DefaultImageHeaderParser());

    Downsampler downsampler = new Downsampler(registry.getImageHeaderParsers(),
        resources.getDisplayMetrics(), bitmapPool, arrayPool);
    ByteBufferBitmapDecoder byteBufferBitmapDecoder = new ByteBufferBitmapDecoder(downsampler);
    StreamBitmapDecoder streamBitmapDecoder = new StreamBitmapDecoder(downsampler, arrayPool);
    ResourceDrawableDecoder resourceDrawableDecoder =
        new ResourceDrawableDecoder(context);
    ResourceLoader.StreamFactory resourceLoaderStreamFactory =
        new ResourceLoader.StreamFactory(resources);
    BitmapEncoder bitmapEncoder = new BitmapEncoder();

    BitmapBytesTranscoder bitmapBytesTranscoder = new BitmapBytesTranscoder();

    ContentResolver contentResolver = context.getContentResolver();

    //開始注冊
    registry
        .append(ByteBuffer.class, new ByteBufferEncoder())
        /* Bitmaps */
          //注冊資源解碼器
        .append(Registry.BUCKET_BITMAP, ByteBuffer.class, Bitmap.class, byteBufferBitmapDecoder)
        /* Drawables */
        .append(Uri.class, Drawable.class, resourceDrawableDecoder)
        /* Models */
        .register(new InputStreamRewinder.Factory(arrayPool))
        //注冊模塊加載器
        .append(String.class, InputStream.class, new StringLoader.StreamFactory())
        .append(String.class, InputStream.class, new StringLoader.StreamFactory())
        .append(Uri.class, InputStream.class, new HttpUriLoader.Factory())
        .append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())
        /* Transcoders */
          //注冊轉碼器
        .register(
            Bitmap.class,
            BitmapDrawable.class,
            new BitmapDrawableTranscoder(resources))

    ImageViewTargetFactory imageViewTargetFactory = new ImageViewTargetFactory();
    glideContext =
        new GlideContext(
            context,
            arrayPool,
            registry,
            imageViewTargetFactory,
            defaultRequestOptions,
            defaultTransitionOptions,
            engine,
            logLevel);
  }

模型加載注冊表 ModelLoaderRegistry

它的作用是將數據源解碼成對于目標數據

/**
  通過multiModelLoaderFactory來管理
*/
public class ModelLoaderRegistry {
  private final MultiModelLoaderFactory multiModelLoaderFactory;
  public ModelLoaderRegistry(@NonNull Pool<List<Throwable>> throwableListPool) {
    this(new MultiModelLoaderFactory(throwableListPool));
  }

  private ModelLoaderRegistry(@NonNull MultiModelLoaderFactory multiModelLoaderFactory) {
    this.multiModelLoaderFactory = multiModelLoaderFactory;
  }
  
  //將解碼器加進來
  public synchronized <Model, Data> void append(
      @NonNull Class<Model> modelClass,
      @NonNull Class<Data> dataClass,
      @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
    multiModelLoaderFactory.append(modelClass, dataClass, factory);
    cache.clear();
  }

  //獲取能夠處理該model的loader
  public synchronized <A> List<ModelLoader<A, ?>> getModelLoaders(@NonNull A model) {
    //通過判斷是否是model類型來初步獲取loader
    List<ModelLoader<A, ?>> modelLoaders = getModelLoadersForClass(getClass(model));
    int size = modelLoaders.size();
    List<ModelLoader<A, ?>> filteredLoaders = new ArrayList<>(size);
    for (int i = 0; i < size; i++) {
      ModelLoader<A, ?> loader = modelLoaders.get(i);
      //再通過loader是能能夠處理該model再過濾loader
      if (loader.handles(model)) {
        filteredLoaders.add(loader);
      }
    }
    return filteredLoaders;
  }

  private <A> List<ModelLoader<A, ?>> getModelLoadersForClass(@NonNull Class<A> modelClass) {
    List<ModelLoader<A, ?>> loaders = cache.get(modelClass);
    if (loaders == null) {
      //下面是multiModelLoaderFactory的build方法
      loaders = Collections.unmodifiableList(multiModelLoaderFactory.build(modelClass));
      cache.put(modelClass, loaders);
    }
    return loaders;
  }
}

/**
  1.存放解碼器
  2.根據數據源獲取解碼器 getModelLoaders
*/
public class MultiModelLoaderFactory {
  //存放解碼器
  private final List<Entry<?, ?>> entries = new ArrayList<>();
  synchronized <Model, Data> void append(
      @NonNull Class<Model> modelClass,
      @NonNull Class<Data> dataClass,
      @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
    add(modelClass, dataClass, factory, /*append=*/ true);
  }
  private <Model, Data> void add(
      @NonNull Class<Model> modelClass,
      @NonNull Class<Data> dataClass,
      @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory,
      boolean append) {
    Entry<Model, Data> entry = new Entry<>(modelClass, dataClass, factory);
    entries.add(append ? entries.size() : 0, entry);
  }

  //根據數據源類型返回loader的集合
  synchronized <Model> List<ModelLoader<Model, ?>> build(@NonNull Class<Model> modelClass) {
    try {
      List<ModelLoader<Model, ?>> loaders = new ArrayList<>();
      for (Entry<?, ?> entry : entries) {
        if (alreadyUsedEntries.contains(entry)) {
          continue;
        }
        if (entry.handles(modelClass)) {
          alreadyUsedEntries.add(entry);
          //通過factory生成loader
          loaders.add(this.<Model, Object>build(entry));
          alreadyUsedEntries.remove(entry);
        }
      }
      return loaders;
    } catch (Throwable t) {
      alreadyUsedEntries.clear();
      throw t;
    }
  }

  private static class Entry<Model, Data> {
    private final Class<Model> modelClass;
    @Synthetic final Class<Data> dataClass;
    @Synthetic final ModelLoaderFactory<? extends Model, ? extends Data> factory;

    public Entry(
        @NonNull Class<Model> modelClass,
        @NonNull Class<Data> dataClass,
        @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) {
      this.modelClass = modelClass;
      this.dataClass = dataClass;
      this.factory = factory;
    }

    public boolean handles(@NonNull Class<?> modelClass, @NonNull Class<?> dataClass) {
      return handles(modelClass) && this.dataClass.isAssignableFrom(dataClass);
    }

    //這里判斷待轉換的類型是否一致
    public boolean handles(@NonNull Class<?> modelClass) {
      return this.modelClass.isAssignableFrom(modelClass);
    }
  }
}

以ByteBufferFileLoader為例

public class ByteBufferFileLoader implements ModelLoader<File, ByteBuffer> {
  @Override
  public LoadData<ByteBuffer> buildLoadData(@NonNull File file, int width, int height,
      @NonNull Options options) {
    return new LoadData<>(new ObjectKey(file), new ByteBufferFetcher(file));
  }

  @Override
  public boolean handles(@NonNull File file) {
    return true;
  }

  //工廠類，生成ModelLoader
  public static class Factory implements ModelLoaderFactory<File, ByteBuffer> {
    public ModelLoader<File, ByteBuffer> build(@NonNull MultiModelLoaderFactory multiFactory) {
      return new ByteBufferFileLoader();
    }
    @Override
    public void teardown() {
      // Do nothing.
    }
  }

  private static final class ByteBufferFetcher implements DataFetcher<ByteBuffer> {
    private final File file;
    ByteBufferFetcher(File file) {
      this.file = file;
    }

    @Override
    public void loadData(@NonNull Priority priority,
        @NonNull DataCallback<? super ByteBuffer> callback) {
      ByteBuffer result;
      try {
        result = ByteBufferUtil.fromFile(file);
      } catch (IOException e) {
        if (Log.isLoggable(TAG, Log.DEBUG)) {
          Log.d(TAG, "Failed to obtain ByteBuffer for file", e);
        }
        callback.onLoadFailed(e);
        return;
      }
      callback.onDataReady(result);
    }
}

看一下LoadData的實現

 /**
  加載數據的實體類，sourceKey是數據源，fetcher是數據獲取器
*/
class LoadData<Data> {
    public LoadData(@NonNull Key sourceKey, @NonNull List<Key> alternateKeys,
        @NonNull DataFetcher<Data> fetcher) {
      this.sourceKey = Preconditions.checkNotNull(sourceKey);
      this.alternateKeys = Preconditions.checkNotNull(alternateKeys);
      this.fetcher = Preconditions.checkNotNull(fetcher);
    }
  }
  LoadData<Data> buildLoadData(@NonNull Model model, int width, int height,
      @NonNull Options options);
  boolean handles(@NonNull Model model);
}

可以看到，ByteBufferFileLoader的作用就是將file轉換為ByteBuffer

我們再看一下append(String.class, InputStream.class, new StringLoader.StreamFactory())，它跟上面介紹的ByteBufferFileLoader有點不一樣

public class StringLoader<Data> implements ModelLoader<String, Data> {
  //看見沒，StringLoader里面還包了一個uriLoader
  private final ModelLoader<Uri, Data> uriLoader;
  public StringLoader(ModelLoader<Uri, Data> uriLoader) {
    this.uriLoader = uriLoader;
  }
   //實際在創建的時候，調用的是uriLoader.buildLoadData，它只是一個殼
  public LoadData<Data> buildLoadData(@NonNull String model, int width, int height,
      @NonNull Options options) {
    Uri uri = parseUri(model);
    return uri == null ? null : uriLoader.buildLoadData(uri, width, height, options);
  }

  @Override
  public boolean handles(@NonNull String model) {
    return true;
  }

  public static class StreamFactory implements ModelLoaderFactory<String, InputStream> {
    public ModelLoader<String, InputStream> build(MultiModelLoaderFactory multiFactory) {
      //調用multiFactory創建了另外一個loader，表示(String, InputStream)類型的，將會通過(Uri, InputStream)這個類型的loader處理
      return new StringLoader<>(multiFactory.build(Uri.class, InputStream.class));
    }

    @Override
    public void teardown() {
    }
  }
}

模型加載注冊表就介紹完了。
總結一下，ModelLoaderRegistry有一個multiModelLoaderFactory，里面有一個entries的集合，里面放的是數據源對象和模型加載器工廠，通過build方法，能生成能處理該數據的模型加載器

資源解碼注冊表

將指定的數據解碼成另一種類型
看一下ResourceDecoderRegistry的代碼，以append(Registry.BUCKET_BITMAP, InputStream.class, Bitmap.class, streamBitmapDecoder)為例

public class ResourceDecoderRegistry {
  //能解碼的名稱別名集合，這里是BUCKET_BITMAP
  private final List<String> bucketPriorityList = new ArrayList<>();
  //將別名作為key存放，一個BUCKET_BITMAP可以有多個的解碼器
  private final Map<String, List<Entry<?, ?>>> decoders = new HashMap<>();
  //bucket：數據名稱，dataClass 數據類型，resourceClass 轉換后的類型，decoder 解碼器
  public synchronized <T, R> void append(@NonNull String bucket,
      @NonNull ResourceDecoder<T, R> decoder,
      @NonNull Class<T> dataClass, @NonNull Class<R> resourceClass) {
    getOrAddEntryList(bucket).add(new Entry<>(dataClass, resourceClass, decoder));
  }

  private synchronized List<Entry<?, ?>> getOrAddEntryList(@NonNull String bucket) {
    if (!bucketPriorityList.contains(bucket)) {
      // Add this unspecified bucket as a low priority bucket.
      bucketPriorityList.add(bucket);
    }
    List<Entry<?, ?>> entries = decoders.get(bucket);
    if (entries == null) {
      entries = new ArrayList<>();
      decoders.put(bucket, entries);
    }
    return entries;
  }

  private static class Entry<T, R> {
    private final Class<T> dataClass;
    @Synthetic final Class<R> resourceClass;
    @Synthetic final ResourceDecoder<T, R> decoder;

    public Entry(@NonNull Class<T> dataClass, @NonNull Class<R> resourceClass,
        ResourceDecoder<T, R> decoder) {
      this.dataClass = dataClass;
      this.resourceClass = resourceClass;
      this.decoder = decoder;
    }

    public boolean handles(@NonNull Class<?> dataClass, @NonNull Class<?> resourceClass) {
      return this.dataClass.isAssignableFrom(dataClass) && resourceClass
          .isAssignableFrom(this.resourceClass);
    }
  }
}

看一下StreamBitmapDecoder streamBitmapDecoder = new StreamBitmapDecoder(downsampler, arrayPool)

public class StreamBitmapDecoder implements ResourceDecoder<InputStream, Bitmap> {
    //能否處理
  public boolean handles(@NonNull InputStream source, @NonNull Options options) {
    return downsampler.handles(source);
  }

  public Resource<Bitmap> decode(@NonNull InputStream source, int width, int height,
      @NonNull Options options)
      throws IOException {
    try {
      return downsampler.decode(invalidatingStream, width, height, options, callbacks);
    } finally {
      exceptionStream.release();
      if (ownsBufferedStream) {
        bufferedStream.release();
      }
    }
  }
}

它就是將InputStream轉換成Bitmap

轉碼注冊表

也是將一種類型轉換成另外一種類型，
以register(
Bitmap.class,
BitmapDrawable.class,
new BitmapDrawableTranscoder(resources))為例

public class TranscoderRegistry {
  private final List<Entry<?, ?>> transcoders = new ArrayList<>();
  public synchronized <Z, R> void register(
      @NonNull Class<Z> decodedClass, @NonNull Class<R> transcodedClass,
      @NonNull ResourceTranscoder<Z, R> transcoder) {
    transcoders.add(new Entry<>(decodedClass, transcodedClass, transcoder));
  }
  private static final class Entry<Z, R> {
    private final Class<Z> fromClass;
    private final Class<R> toClass;
    @Synthetic final ResourceTranscoder<Z, R> transcoder;

    Entry(@NonNull Class<Z> fromClass, @NonNull Class<R> toClass,
        @NonNull ResourceTranscoder<Z, R> transcoder) {
      this.fromClass = fromClass;
      this.toClass = toClass;
      this.transcoder = transcoder;
    }

    /**
     * If we convert from a specific Drawable, we must get that specific Drawable class or a
     * subclass of that Drawable. In contrast, if we we convert <em>to</em> a specific Drawable,
     * we can fulfill requests for a more generic parent class (like Drawable). As a result, we
     * check fromClass and toClass in different orders.
     */
    public boolean handles(@NonNull Class<?> fromClass, @NonNull Class<?> toClass) {
      return this.fromClass.isAssignableFrom(fromClass) && toClass.isAssignableFrom(this.toClass);
    }
  }

public class BitmapDrawableTranscoder implements ResourceTranscoder<Bitmap, BitmapDrawable> {
  private final Resources resources;

  @SuppressWarnings("unused")
  public BitmapDrawableTranscoder(@NonNull Context context) {
    this(context.getResources());
  }

  public BitmapDrawableTranscoder(
      @NonNull Resources resources, @SuppressWarnings("unused") BitmapPool bitmapPool) {
    this(resources);
  }

  public BitmapDrawableTranscoder(@NonNull Resources resources) {
    this.resources = Preconditions.checkNotNull(resources);
  }
  @Override
  public Resource<BitmapDrawable> transcode(Resource<Bitmap> toTranscode, Options options) {
    return LazyBitmapDrawableResource.obtain(resources, toTranscode);
  }
}

這個更簡單，就是將Bitmap轉換成BitmapDrawable

注冊表就介紹完了，上面介紹了三個注冊表(ModelLoaderRegistry, ResourceDecoderRegistry,TranscoderRegistry)，這個三個都是跟加載網絡圖片相關的。
注冊表是glide的一個核心部分，理解了這個才能理解整個流程

初始化完成后，再回過頭來看

  public static RequestManager with(@NonNull Activity activity) {
    return getRetriever(activity).get(activity);
  }

  @NonNull
  public RequestManager get(@NonNull Activity activity) {
    if (Util.isOnBackgroundThread()) {
      return get(activity.getApplicationContext());
    } else {
      assertNotDestroyed(activity);
      android.app.FragmentManager fm = activity.getFragmentManager();
      return fragmentGet(activity, fm, null /*parentHint*/);
    }
  }

  private RequestManager fragmentGet(@NonNull Context context,
      @NonNull android.app.FragmentManager fm,
      @Nullable android.app.Fragment parentHint) {
    //這里會添加一個fragment到當前activity里面，用于管理當前頁面的生命周期
    RequestManagerFragment current = getRequestManagerFragment(fm, parentHint);
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
      Glide glide = Glide.get(context);
      //創建requestManager，并將它設置到fragment中
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);
    }
    return requestManager;
  }

好了，我們現在來看一下glide是如何管理生命周期的
在RequestManagerFragment的構造方法里面

public class RequestManagerFragment extends Fragment {
    public RequestManagerFragment() {
    this(new ActivityFragmentLifecycle());
  }
  //保存生命周期監聽器
  RequestManagerFragment(ActivityFragmentLifecycle lifecycle) {
    this.lifecycle = lifecycle;
  }
}

看一下ActivityFragmentLifecycle的實現

class ActivityFragmentLifecycle implements Lifecycle {
  private final Set<LifecycleListener> lifecycleListeners =
      Collections.newSetFromMap(new WeakHashMap<LifecycleListener, Boolean>());
  @Override
  public void addListener(LifecycleListener listener) {
    lifecycleListeners.add(listener);
    if (isDestroyed) {
      listener.onDestroy();
    } else if (isStarted) {
      listener.onStart();
    } else {
      listener.onStop();
    }
  }
  void onStart() {
    isStarted = true;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStart();
    }
  }

  void onStop() {
    isStarted = false;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onStop();
    }
  }

  void onDestroy() {
    isDestroyed = true;
    for (LifecycleListener lifecycleListener : Util.getSnapshot(lifecycleListeners)) {
      lifecycleListener.onDestroy();
    }
  }
}

這里可以添加監聽器，fragment生命周期的變化，會依次回調這里的監聽器
在看看創建RequestManager的方法

      Glide glide = Glide.get(context);
      requestManager =
          factory.build(
              glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
      current.setRequestManager(requestManager);

factory是下面的DEFAULT_FACTORY

  private static final RequestManagerFactory DEFAULT_FACTORY = new RequestManagerFactory() {
    public RequestManager build(@NonNull Glide glide, @NonNull Lifecycle lifecycle,
        @NonNull RequestManagerTreeNode requestManagerTreeNode, @NonNull Context context) {
      return new RequestManager(glide, lifecycle, requestManagerTreeNode, context);
    }
  };

再看一下RequestManager就很清楚了

public class RequestManager implements LifecycleListener,
  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));
    //添加生命周期監聽器
    if (Util.isOnBackgroundThread()) {
      mainHandler.post(addSelfToLifecycle);
    } else {
      lifecycle.addListener(this);
    }
    lifecycle.addListener(connectivityMonitor);
    setRequestOptions(glide.getGlideContext().getDefaultRequestOptions());
    glide.registerRequestManager(this);
  }

    @Override
  public void onStart() {
    resumeRequests();
    targetTracker.onStart();
  }

  @Override
  public void onStop() {
    pauseRequests();
    targetTracker.onStop();
  }

  @Override
  public void onDestroy() {
    targetTracker.onDestroy();
    for (Target<?> target : targetTracker.getAll()) {
      clear(target);
    }
    targetTracker.clear();
    requestTracker.clearRequests();
    lifecycle.removeListener(this);
    lifecycle.removeListener(connectivityMonitor);
    mainHandler.removeCallbacks(addSelfToLifecycle);
    glide.unregisterRequestManager(this);
  }
}

總結一下，fragment是一個被觀察者，有生命周期回調的接口集合，RequestManager將自己加到了觀察者的集合里面，實現了加載跟隨生命周期的功能

說了這么多，這就是Glide.with(this).load(imageUrl).into(imageView);里面的Glide.with(this)方法，該方法最后獲得RequestManager。

load(imageUrl)

public class RequestManager implements LifecycleListener,
    ModelTypes<RequestBuilder<Drawable>> {
  public RequestBuilder<Drawable> load(@Nullable String string) {
    return asDrawable().load(string);
  }

  public RequestBuilder<Drawable> asDrawable() {
    return as(Drawable.class);
  }

  public <ResourceType> RequestBuilder<ResourceType> as(
      @NonNull Class<ResourceType> resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
  }
}

最后創建的是RequestBuilder

public class RequestBuilder<TranscodeType> implements Cloneable,
    ModelTypes<RequestBuilder<TranscodeType>> {
  protected RequestBuilder(Glide glide, RequestManager requestManager,
      Class<TranscodeType> transcodeClass, Context context) {
    this.glide = glide;
    this.requestManager = requestManager;
    //要轉換的目標類型
    this.transcodeClass = transcodeClass;
    this.defaultRequestOptions = requestManager.getDefaultRequestOptions();
    this.context = context;
    this.transitionOptions = requestManager.getDefaultTransitionOptions(transcodeClass);
    this.requestOptions = defaultRequestOptions;
    this.glideContext = glide.getGlideContext();
  }
}

  //執行完asDrawable()后，得到該RequestBuilder，然后執行該類中的load(string)方法
  public RequestBuilder<TranscodeType> load(@Nullable String string) {
    return loadGeneric(string);
  }

  //到此結束，總結一下，執行Glide.with(this).load(imageUrl)中的load(imageUrl)方法，生成了RequestBuilder.
  //在該類里面，保存了最終要轉換的類型transcodeClass(drawable),數據源model
  private RequestBuilder<TranscodeType> loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
  }

總結一下，這里生成了RequestBuilder，里面有目標數據類型transcodeClass(drawable)，有數據源model(string)

into(imageView)

Glide.with(this).load(imageUrl).into(imageView);中的into(imageView)方法。還是在RequestBuilder里面

public class RequestBuilder<TranscodeType> implements Cloneable,
    ModelTypes<RequestBuilder<TranscodeType>> {
  public ViewTarget<ImageView, TranscodeType> into(@NonNull ImageView view) {
    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions);
  }

我們看一下glideContext.buildImageViewTarget(view, transcodeClass)里面具體干了什么事情
最后會執行到下面的方法

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

因為我們傳的值是drawable，所以最后到了DrawableImageViewTarget里面

public class DrawableImageViewTarget extends ImageViewTarget<Drawable> {
  public DrawableImageViewTarget(ImageView view) {
    super(view);
  }
  public DrawableImageViewTarget(ImageView view, boolean waitForLayout) {
    super(view, waitForLayout);
  }
  
  protected void setResource(@Nullable Drawable resource) {
    view.setImageDrawable(resource);
  }
}

該類的作用是更新imageview內容
再回到 into()方法

public class RequestBuilder<TranscodeType> implements Cloneable,
    ModelTypes<RequestBuilder<TranscodeType>> {

   //Y是DrawableImageViewTarget，TranscodeType是目標類型，drawable
  private <Y extends Target<TranscodeType>> Y into(
      @NonNull Y target,
      @Nullable RequestListener<TranscodeType> targetListener,
      @NonNull RequestOptions options) {

    Request request = buildRequest(target, targetListener, options);
    Request previous = target.getRequest();
    requestManager.clear(target);
    target.setRequest(request);
    requestManager.track(target, request);

    return target;
  }

  private Request buildRequest(
      Target<TranscodeType> target,
      @Nullable RequestListener<TranscodeType> targetListener,
      RequestOptions requestOptions) {
    return buildRequestRecursive(
        target,
        targetListener,
        /*parentCoordinator=*/ null,
        transitionOptions,
        requestOptions.getPriority(),
        requestOptions.getOverrideWidth(),
        requestOptions.getOverrideHeight(),
        requestOptions);
  }
  private Request buildRequestRecursive(
      Target<TranscodeType> target,
      @Nullable RequestListener<TranscodeType> targetListener,
      @Nullable RequestCoordinator parentCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight,
      RequestOptions requestOptions) {

    // Build the ErrorRequestCoordinator first if necessary so we can update parentCoordinator.
    ErrorRequestCoordinator errorRequestCoordinator = null;
    if (errorBuilder != null) {
      errorRequestCoordinator = new ErrorRequestCoordinator(parentCoordinator);
      parentCoordinator = errorRequestCoordinator;
    }

    Request mainRequest =
        buildThumbnailRequestRecursive(
            target,
            targetListener,
            parentCoordinator,
            transitionOptions,
            priority,
            overrideWidth,
            overrideHeight,
            requestOptions);

    if (errorRequestCoordinator == null) {
      return mainRequest;
    }
    return errorRequestCoordinator;
  }
  private Request obtainRequest(
      Target<TranscodeType> target,
      RequestListener<TranscodeType> targetListener,
      RequestOptions requestOptions,
      RequestCoordinator requestCoordinator,
      TransitionOptions<?, ? super TranscodeType> transitionOptions,
      Priority priority,
      int overrideWidth,
      int overrideHeight) {
    return SingleRequest.obtain(
        context,
        glideContext,
        model,
        transcodeClass,
        requestOptions,
        overrideWidth,
        overrideHeight,
        priority,
        target,
        targetListener,
        requestListener,
        requestCoordinator,
        glideContext.getEngine(),
        transitionOptions.getTransitionFactory());
  }
}

現在看一下SingleRequest

public final class SingleRequest<R> implements Request,
    SizeReadyCallback,
    ResourceCallback,
    FactoryPools.Poolable {
  private void init(
      Context context,
      GlideContext glideContext,
      Object model,
      Class<R> transcodeClass,
      RequestOptions requestOptions,
      int overrideWidth,
      int overrideHeight,
      Priority priority,
      Target<R> target,
      RequestListener<R> targetListener,
      RequestListener<R> requestListener,
      RequestCoordinator requestCoordinator,
      Engine engine,
      TransitionFactory<? super R> animationFactory) {
    this.context = context;
    this.glideContext = glideContext;
    //數據源 url
    this.model = model;
    //目標數據類型
    this.transcodeClass = transcodeClass;
    status = Status.PENDING;
  }
}

回到剛剛的into方法

public class RequestBuilder<TranscodeType> implements Cloneable,
    ModelTypes<RequestBuilder<TranscodeType>> {
  private <Y extends Target<TranscodeType>> Y into(
      @NonNull Y target,
      @Nullable RequestListener<TranscodeType> targetListener,
      @NonNull RequestOptions options) {
    options = options.autoClone();
    Request request = buildRequest(target, targetListener, options);
    requestManager.clear(target);
    //將request設置給DrawableImageViewTarget，該類里面有imageview，現在有了request，齊了
    target.setRequest(request)；
    requestManager.track(target, request);

    return target;
  }
}

看一下requestManager.track(target, request);

public class RequestManager implements LifecycleListener,
    ModelTypes<RequestBuilder<Drawable>> {
  private final RequestTracker requestTracker;
  private final TargetTracker targetTracker = new TargetTracker();
  void track(Target<?> target, Request request) {
    targetTracker.track(target);
    requestTracker.runRequest(request);
  }
}

看一下TargetTracker的類

public final class TargetTracker implements LifecycleListener {
  private final Set<Target<?>> targets =
      Collections.newSetFromMap(new WeakHashMap<Target<?>, Boolean>());

  public void track(Target<?> target) {
    targets.add(target);
  }

  public void onStart() {
    for (Target<?> target : Util.getSnapshot(targets)) {
      target.onStart();
    }
  }
  public void onStop() {
    for (Target<?> target : Util.getSnapshot(targets)) {
      target.onStop();
    }
  }
  public void onDestroy() {
    for (Target<?> target : Util.getSnapshot(targets)) {
      target.onDestroy();
    }
  }
}

再看一下RequestManager里面對TargetTracker的調用

public class RequestManager implements LifecycleListener,
    ModelTypes<RequestBuilder<Drawable>> {
   //fragment的生命周期會調用這里，會觸發到這里，然后觸發到DrawableImageViewTarget
  public void onStart() {
    resumeRequests();
    targetTracker.onStart();
  }

  public void onStop() {
    pauseRequests();
    targetTracker.onStop();
  }

  public void onDestroy() {
    targetTracker.onDestroy();
    for (Target<?> target : targetTracker.getAll()) {
      clear(target);
    }
    targetTracker.clear();
    requestTracker.clearRequests();
    lifecycle.removeListener(this);
    lifecycle.removeListener(connectivityMonitor);
    mainHandler.removeCallbacks(addSelfToLifecycle);
    glide.unregisterRequestManager(this);
  }

  public void resumeRequests() {
    Util.assertMainThread();
    requestTracker.resumeRequests();
  }

  public void pauseRequests() {
    Util.assertMainThread();
    requestTracker.pauseRequests();
  }
}

看一下RequestTracker

public class RequestTracker {
  private final Set<Request> requests =
      Collections.newSetFromMap(new WeakHashMap<Request, Boolean>());
  //等待加載到request list
  private final List<Request> pendingRequests = new ArrayList<>();
  public void runRequest(Request request) {
    requests.add(request);
    if (!isPaused) {
      //開始請求
      request.begin();
    } else {
      //緩存起來
      pendingRequests.add(request);
    }
  }
}

總結一下，先在activity中添加了一個空的fragment，這樣就有了生命周期，fragment里面有個ActivityFragmentLifecycle類，該類是生命周期回調的集合，fragment生命周期變化會調用該類，RequestManager實現了生命周期的接口，然后將它加到了ActivityFragmentLifecycle里面。

RequestManager里面有targetTracker，targetTracker是Target(里面有imageview)的集合，在頁面開始加載，調用onstart方法時會調用Target里面的onstart方法，這樣可以做一下圖片加載的預處理，比如設置占位圖等。

RequestManager里面還有requestTracker，調用RequestManager調用requestTracker的track時，會直接加載圖片。同時在生命周期回調onstart方法時，resumeRequests方法，將沒有加載的request重新開始

由于篇幅的限制，網路加載圖片的內容請看第二篇文章