Glide源码解析四——Engine相关（从数据源获取数据）

锐湃

已于 2023-08-01 13:16:31 修改

阅读量165

点赞数

分类专栏：图形程序设计文章标签： glide spring java

于 2023-08-01 13:15:06 首次发布

原文链接：https://www.jianshu.com/p/65b0a4385d01

版权

程序设计同时被 2 个专栏收录

302 篇文章 4 订阅

订阅专栏

图形

145 篇文章 12 订阅

订阅专栏

Engine

由Glide源码分析二——Request相关可知，SingleRequest#onSizeReady(w,h)可知是通过Engine来加载图片的。

Engine是在GlideBuilder#build(context)构造Glide时，new出来传给Glide的。之后在RequestBuilder创建SingleRequest时通过GlideContext.getEngine()获取Engine并传给SingleRequest.

GlideBuilder.java
Glide build(@NonNull Context context) {
    
    ...
    if (engine == null) {
      engine =
          new Engine(
              memoryCache,  // 内存缓存
              diskCacheFactory, // 磁盘缓存工厂类
              diskCacheExecutor,
              sourceExecutor,
              GlideExecutor.newUnlimitedSourceExecutor(),
              animationExecutor,
              isActiveResourceRetentionAllowed);
    }
    ...
    return new Glide(
        ...
        engine,
        ...);
}

public class Engine
    implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {

    private final Jobs jobs;
    private final EngineKeyFactory keyFactory;
    private final MemoryCache cache;
    private final EngineJobFactory engineJobFactory;
    private final ResourceRecycler resourceRecycler;
    private final LazyDiskCacheProvider diskCacheProvider;
    private final DecodeJobFactory decodeJobFactory;
    private final ActiveResources activeResources;
    
    
    Engine(
      MemoryCache cache,
      DiskCache.Factory diskCacheFactory,
      GlideExecutor diskCacheExecutor,
      GlideExecutor sourceExecutor,
      GlideExecutor sourceUnlimitedExecutor,
      GlideExecutor animationExecutor,
      Jobs jobs,
      EngineKeyFactory keyFactory,
      ActiveResources activeResources,
      EngineJobFactory engineJobFactory,
      DecodeJobFactory decodeJobFactory,
      ResourceRecycler resourceRecycler,
      boolean isActiveResourceRetentionAllowed) {
        
        // 二级内存缓存
        this.cache = cache;
        
        // 三级磁盘缓存的Provider
        this.diskCacheProvider = new LazyDiskCacheProvider(diskCacheFactory);

        // 一级内存缓存
        if (activeResources == null) {
          activeResources = new ActiveResources(isActiveResourceRetentionAllowed);
        }
        this.activeResources = activeResources;
        activeResources.setListener(this);

        // 默认的KeyFactory
        if (keyFactory == null) {
          keyFactory = new EngineKeyFactory();
        }
        this.keyFactory = keyFactory;

        if (jobs == null) {
          jobs = new Jobs();
        }
        this.jobs = jobs;

        if (engineJobFactory == null) {
          engineJobFactory =
              new EngineJobFactory(
                  diskCacheExecutor,
                  sourceExecutor,
                  sourceUnlimitedExecutor,
                  animationExecutor,
                  /*engineJobListener=*/ this,
                  /*resourceListener=*/ this);
        }
        this.engineJobFactory = engineJobFactory;

        if (decodeJobFactory == null) {
          decodeJobFactory = new DecodeJobFactory(diskCacheProvider);
        }
        this.decodeJobFactory = decodeJobFactory;

        if (resourceRecycler == null) {
          resourceRecycler = new ResourceRecycler();
        }
        this.resourceRecycler = resourceRecycler;

        cache.setResourceRemovedListener(this);
    }
    
    
    
    public <R> LoadStatus load(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class<?> resourceClass,
      Class<R> transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map<Class<?>, Transformation<?>> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb,
      Executor callbackExecutor) {
      
        long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;

        EngineKey key =
            keyFactory.buildKey(
                model,
                signature,
                width,
                height,
                transformations,
                resourceClass,
                transcodeClass,
                options);

        EngineResource<?> memoryResource;
        synchronized (this) {
        
          // 尝试从1、2级缓存中取出资源
          memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);

          if (memoryResource == null) {
            
            // 如果没有内存缓存，则创建EngineJob
            return waitForExistingOrStartNewJob(
                glideContext,
                model,
                signature,
                width,
                height,
                resourceClass,
                transcodeClass,
                priority,
                diskCacheStrategy,
                transformations,
                isTransformationRequired,
                isScaleOnlyOrNoTransform,
                options,
                isMemoryCacheable, // 从BaseRequestOptions中取，默认是true，除非调用了skipMemoryCache(true)
                useUnlimitedSourceExecutorPool,
                useAnimationPool,
                onlyRetrieveFromCache, // 从BaseRequestOptions中取，默认是false
                cb,
                callbackExecutor, // RequestBuilder#into(...)不传就是在主线程
                key,
                startTime);
          }
        }

        // 如果有内存缓存则通过回调ResourceCallback#onResourceReady(...)通知SingleRequest资源加载完成，进而通知target加载资源
        cb.onResourceReady(memoryResource, DataSource.MEMORY_CACHE);
        return null;
    }
    
    // 从1、2级缓存中取出资源，关于1、2级缓存可以参考MemoryCache、ActiveResource章节
    private EngineResource<?> loadFromMemory(
      EngineKey key, boolean isMemoryCacheable, long startTime) {
        if (!isMemoryCacheable) {
          return null;
        }

        // 先从一级缓存中取
        EngineResource<?> active = loadFromActiveResources(key);
        if (active != null) {
          return active;
        }
        
        
        // 一级缓存中没有则尝试从二级缓存中取
        EngineResource<?> cached = loadFromCache(key);
        if (cached != null) {
          return cached;
        }

        return null;
    }
    
    // 从一级缓存中取资源
    private EngineResource<?> loadFromActiveResources(Key key) {
        EngineResource<?> active = activeResources.get(key);
        if (active != null) {
          // 将EngineResource的引用计数+1，当引用数为0时释放掉
          active.acquire();
        }

        return active;
    }
    
    // 从二级缓存中取资源
    private EngineResource<?> loadFromCache(Key key) {
        EngineResource<?> cached = getEngineResourceFromCache(key);
        if (cached != null) {
          // 将EngineResource的引用计数+1，当引用数为0时释放掉
          cached.acquire();
          // 从二级缓存中取到资源后放入一级缓存
          activeResources.activate(key, cached);
        }
        return cached;
    }
    
    private EngineResource<?> getEngineResourceFromCache(Key key) {
    
        // 从MemoryCache中取出Resource的同时，也将其从MemoryCache中移除，等到Resource引用数为0时，会再放入MemoryCache
        Resource<?> cached = cache.remove(key);

        final EngineResource<?> result;
        if (cached == null) {
          result = null;
        } else if (cached instanceof EngineResource) {
          // Resource有很多子类，如果是EngineResource则直接返回
          result = (EngineResource<?>) cached;
        } else {
          // 如果不是EngineResource，则包装成EngineResource
          result =
              new EngineResource<>(
                  cached, /*isMemoryCacheable=*/ true, /*isRecyclable=*/ true, key, /*listener=*/ this);
        }
        return result;
    }
    
    
    
    private <R> LoadStatus waitForExistingOrStartNewJob(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      Class<?> resourceClass,
      Class<R> transcodeClass,
      Priority priority,
      DiskCacheStrategy diskCacheStrategy,
      Map<Class<?>, Transformation<?>> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      Options options,
      boolean isMemoryCacheable,
      boolean useUnlimitedSourceExecutorPool,
      boolean useAnimationPool,
      boolean onlyRetrieveFromCache,
      ResourceCallback cb,
      Executor callbackExecutor,
      EngineKey key,
      long startTime) {
        
        // 如果当前key已经有对应EngineJob了，则将ResourceCallback和Executor添加到该EngineJob上
        EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache);
        if (current != null) {
          current.addCallback(cb, callbackExecutor);
          return new LoadStatus(cb, current);
        }

        // 从EngineJobFactory中获取EngineJob，内部有对象池可复用EngineJob
        EngineJob<R> engineJob =
            engineJobFactory.build(
                key,
                isMemoryCacheable,
                useUnlimitedSourceExecutorPool,
                useAnimationPool,
                onlyRetrieveFromCache);
        // 和EngineJobFactory一样，内部有对象池
        DecodeJob<R> decodeJob =
            decodeJobFactory.build(
                glideContext,
                model,
                key,
                signature,
                width,
                height,
                resourceClass,
                transcodeClass,
                priority,
                diskCacheStrategy,
                transformations,
                isTransformationRequired,
                isScaleOnlyOrNoTransform,
                onlyRetrieveFromCache,
                options,
                engineJob);
        
        // 将EngineJob放入Jobs中
        jobs.put(key, engineJob);

        // 将ResourceCallback和Executor添加到该EngineJob上
        engineJob.addCallback(cb, callbackExecutor);
        
        // 启动EngineJob
        engineJob.start(decodeJob);

        return new LoadStatus(cb, engineJob);
    }
}

Resource<Z>包含着真正的资源，例如Bitmap、Drawable、File等，提供了获取资源、资源类class、资源大小、回收资源的方法。
EngineResource是Resource<Z>的包装类，内部包含引用计数acquire，每次被使用acquire()都会+1，每次被释放release()都会-1，当acquire==0时，会回调通知Engine，从ActiveResources中移除，如果可缓存在内存中则放入MemoryCache，否则回收recycle()。
DecodeJob是个Runnable，用于从磁盘(SDCard)获取处理后的资源(ResourceCache)、原始资源(ResourceData)、以及从数据源(Source)获取数据。
EngineJob相当于是管理者，用于管理、监听DecodeJob的执行，当资源加载完成后，会保存资源并通过EngineJobListener#onEngineJobComplete(EngineJob, Key, engineResource)通知Engine。

// EngineResource.java
class EngineResource<Z> implements Resource<Z> {

  // 是否可缓存在内存中
  private final boolean isMemoryCacheable;
  
  // 被包装的资源
  private final Resource<Z> resource;
    
  // 引用计数
  private int acquired;

  // 资源释放回调
  interface ResourceListener {
    void onResourceReleased(Key key, EngineResource<?> resource);
  }
  
  // 回收资源
  @Override
  public synchronized void recycle() {
    // ... 省略部分代码
    resource.recycle();
  }
  
  // 引用资源
  synchronized void acquire() {
    // ... 省略部分代码
    ++acquired;
  }
  
  // 释放资源
  void release() {
    boolean release = false;
    synchronized (this) {
      // ... 省略部分代码
      
      // 如果引用计数为0，则释放资源
      if (--acquired == 0) {
        release = true;
      }
    }
    if (release) {
      // 回调通知Engine，将资源从ActiveResources中移除，如果资源可缓存在内存中，则放入MemoryCache，否则调用resource#recycle()回收资源
      listener.onResourceReleased(key, this);
    }
  }
}

EngineJob

class EngineJob<R> implements DecodeJob.Callback<R>, Poolable {

  public synchronized void start(DecodeJob<R> decodeJob) {
    this.decodeJob = decodeJob;
    GlideExecutor executor =
        decodeJob.willDecodeFromCache() ? diskCacheExecutor : getActiveSourceExecutor();
    // 使用线程池执行Runnable，decodeJob是个Runnable
    executor.execute(decodeJob);
  }
  
  synchronized void addCallback(final ResourceCallback cb, Executor callbackExecutor) {
    
    // 添加ResourceCallback和Executor
    cbs.add(cb, callbackExecutor);
    
    
    if (hasResource) {
      // 如果资源已经加载好了，则直接调用ResourceCallback#onResourceReady(engineResource, dataSource)通知SingleRequest
      incrementPendingCallbacks(1);
      callbackExecutor.execute(new CallResourceReady(cb));
    } else if (hasLoadFailed) {
      // 如果资源已经加载失败了，则通过调用ResourceCallback#onLoadFailed(exception)通知SingleRequest
      incrementPendingCallbacks(1);
      callbackExecutor.execute(new CallLoadFailed(cb));
    } else {
      Preconditions.checkArgument(!isCancelled, "Cannot add callbacks to a cancelled EngineJob");
    }
  }
  
  // 资源加载完成后，EngineJob保存资源，并通过回调通知Engine和SingleRequest
  @Override
  public void onResourceReady(Resource<R> resource, DataSource dataSource) {
    synchronized (this) {
      this.resource = resource;
      this.dataSource = dataSource;
    }
    notifyCallbacksOfResult();
  }
  
  void notifyCallbacksOfResult() {
    ResourceCallbacksAndExecutors copy;
    Key localKey;
    EngineResource<?> localResource;
    synchronized (this) {
      stateVerifier.throwIfRecycled();
      if (isCancelled) {
        // 如果已经取消了，则回收资源并释放EngineJob
        resource.recycle();
        release();
        return;
      } else if (cbs.isEmpty()) {
        throw new IllegalStateException("Received a resource without any callbacks to notify");
      } else if (hasResource) {
        throw new IllegalStateException("Already have resource");
      }
      
      // 通过factory创建EngineResource，包装resource
      engineResource = engineResourceFactory.build(resource, isCacheable, key, resourceListener);
      // 设置标志标识已经加载了资源
      hasResource = true;
      copy = cbs.copy();
      incrementPendingCallbacks(copy.size() + 1);

      localKey = key;
      localResource = engineResource;
    }

    // 通知Engine EngineJob已经执行完毕
    engineJobListener.onEngineJobComplete(this, localKey, localResource);
    
    // 通知SingleRequest资源加载完毕
    for (final ResourceCallbackAndExecutor entry : copy) {
      entry.executor.execute(new CallResourceReady(entry.cb));
    }
    decrementPendingCallbacks();
  }
  
  // onLoadFailed(GlideException e)和onResourceReady(...)类似，省略
  
  @Override
  public void reschedule(DecodeJob<?> job) {
    // 在Glide的线程池中重新执行DecodeJob，原因见DecodeJob#reschedule()和DecodeJob#onDataFetcherReady(...)
    getActiveSourceExecutor().execute(job);
  }

}

DecodeJob

class DecodeJob<R>
    implements DataFetcherGenerator.FetcherReadyCallback,
        Runnable,
        Comparable<DecodeJob<?>>,
        Poolable {
        
  private Callback<R> callback; // EngineJob的实例

  // 延时缓存数据管理类，内含Encoder和待缓存数据
  private final DeferredEncodeManager<?> deferredEncodeManager = new DeferredEncodeManager<>();

    
  public void run() {
    DataFetcher<?> localFetcher = currentFetcher;
    try {
      ...
      // 根据不同的状态获取不同的DataFetcherGenerator，执行不同的数据加载策略
      runWrapped();
    } catch (CallbackException e) {
      throw e;
    } catch (Throwable t) {
      ...
      throw t;
    } finally {
      // 调用上次加载数据的DataFetcher#cleanup()做一些清除资源的工作，例如HttpUrlFetcher会关闭输入流和连接
      if (localFetcher != null) {
        localFetcher.cleanup();
      }
      GlideTrace.endSection();
    }
  }
  
  // 根据不同的状态获取不同的DataFetcherGenerator，执行不同的数据加载策略
  private void runWrapped() {
    // DecodeJob在Engine#load(...)中，使用工厂类DecodeJobFactory.build(...)创建时被赋值为INITIALIZE
    switch (runReason) {
      case INITIALIZE:
        //
        stage = getNextStage(Stage.INITIALIZE);
        currentGenerator = getNextGenerator();
        runGenerators();
        break;
      case SWITCH_TO_SOURCE_SERVICE:
        // 如果是从数据源Source获取数据，例如通过SourceGenerator，则会执行rechedule()，此时runReason会置为SWITCH_TO_SOURCE_SERVICE，且currentGenerator还是上次的Generator，应该是SourceGenerator，调用其startNext()会去保存上次获取到的数据，并通过DataCacheGenerator获取待加载数据，详见DataFetcherGenerator章节
        runGenerators();
        break;
      case DECODE_DATA:
        decodeFromRetrievedData();
        break;
      default:
        throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
  }
  
  // 获取下一个状态
  private Stage getNextStage(Stage current) {
    switch (current) {
      case INITIALIZE:
        // 如果可以取磁盘缓存中存储的Resource资源（原始资源处理后的），则返回State.RESOURCE_CACHE，否则返回State.RESOURCE_CACHE的下个状态
        return diskCacheStrategy.decodeCachedResource()
            ? Stage.RESOURCE_CACHE
            : getNextStage(Stage.RESOURCE_CACHE);
      case RESOURCE_CACHE:
        // 如果可以取磁盘缓存中存储的原始资源的话，则返回State.DATA_CACHE，否则返回State.DATA_CACHE的下个状态
        return diskCacheStrategy.decodeCachedData()
            ? Stage.DATA_CACHE
            : getNextStage(Stage.DATA_CACHE);
      case DATA_CACHE:
        // 是否只能从内存中获取资源，是的话则返回结束状态State.FINISHED，否则返回数据源状态State.SOURCE
        return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
      case SOURCE:
      case FINISHED:
        return Stage.FINISHED;
      default:
        throw new IllegalArgumentException("Unrecognized stage: " + current);
    }
  }
  
  // 根据不同的状态获取对应的DataFetcherGenerator
  private DataFetcherGenerator getNextGenerator() {
    switch (stage) {
      case RESOURCE_CACHE:
        return new ResourceCacheGenerator(decodeHelper, this);
      case DATA_CACHE:
        return new DataCacheGenerator(decodeHelper, this);
      case SOURCE:
        return new SourceGenerator(decodeHelper, this);
      case FINISHED:
        return null;
      default:
        throw new IllegalStateException("Unrecognized stage: " + stage);
  }
  
  // 执行Generator#startNext()加载数据，如果返回false说明获取数据失败，则取下个状态的Generator获取数据
  private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    while (!isCancelled
        && currentGenerator != null
        && !(isStarted = currentGenerator.startNext())) {
        
      // 加载失败的话，切换到下一状态和Generator
      stage = getNextStage(stage);
      currentGenerator = getNextGenerator();

      // 如果下个状态时SOURCE的话，则修改runReason为RunReason.SWITCH_TO_SOURCE_SERVICE，并回调到EngineJob中，在线程池中重新执行DecodeJob来获取数据
      if (stage == Stage.SOURCE) {
        reschedule();
        return;
      }
    }
    
    // 如果所有的状态都尝试了，即所有的Generator都执行了，仍然没有获取到数据，则算作加载失败
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
      notifyFailed();
    }
  }
  
  // 修改runReason为RunReason.SWITCH_TO_SOURCE_SERVICE，回调到EngineJob中，在Glide线程池中重新执行DecodeJob来加载数据。一般是从数据源Source获取数据时，例如通过SourceGenerator，会执行该方法。当DecodeJob重新执行时，currentGengerator还是上次的generator，一般是SourceGenerator，调用其startNext()会去保存上次获取到的数据，并通过DataCacheGenerator获取待加载数据，详见DataFetcherGenerator章节
  public void reschedule() {
    runReason = RunReason.SWITCH_TO_SOURCE_SERVICE;
    
    // 回调到EngineJob中，在Glide线程池中重新执行DecodeJob来加载数据
    callback.reschedule(this);
  }
  
  // Generator请求数据成功回调
  public void onDataFetcherReady(
      Key sourceKey, Object data, DataFetcher<?> fetcher, DataSource dataSource, Key attemptedKey) {
    
    // 保存得到的数据、以及对应的key、DataFetcher等
    this.currentSourceKey = sourceKey;
    this.currentData = data;
    this.currentFetcher = fetcher;
    this.currentDataSource = dataSource;
    this.currentAttemptingKey = attemptedKey;
    
    // 如果当前线程不是请求数据时的线程，则回调到EngineJob中切换到Glide线程池中，之后再执行该DecodeJob来完成Decode Data操作
    if (Thread.currentThread() != currentThread) {
      runReason = RunReason.DECODE_DATA;
      callback.reschedule(this);
    } else {
      // 将请求得到的数据解码成最终结果（transcode类型）并包装成Resource对象
      decodeFromRetrievedData();
    }
  }
  
  // 将请求得到的数据解码成最终结果（transcode类型）并包装成Resource对象
  private void decodeFromRetrievedData() {
    
    // 解码，这里得到的是最终结果（transcode类型）的包装类Resource
    Resource<R> resource = decodeFromData(currentFetcher, currentData, currentDataSource);
    
    if (resource != null) {
      
      // 解码成功则准备缓存数据
      notifyEncodeAndRelease(resource, currentDataSource);
    } else {
    
      // 如果解码得到的Resource为null，则重新执行Generator，获取下一个ModelLoader来尝试获取数据（ps：Generator中可能会有多个能够处理model的ModelLoader）
      runGenerators();
    }
  }
  
  // 通知EngineJob数据请求完成、如果有待缓存的数据（已解码完成）则执行缓存，并尝试释放资源
  private void notifyEncodeAndRelease(Resource<R> resource, DataSource dataSource) {
    ...

    Resource<R> result = resource;
    LockedResource<R> lockedResource = null;
    
    if (deferredEncodeManager.hasResourceToEncode()) {
      lockedResource = LockedResource.obtain(resource);
      result = lockedResource;
    }

    // 通知EngineJob数据请求完成
    callback.onResourceReady(result, dataSource);

    stage = Stage.ENCODE;
    try {
      
      // 如果Decoder解码成功，会在onResourceDecoded(DataSource, Resource<Z>)中调用deferredEncodeManager#init(...)保存解码和变换后的数据以及对应的Key和ResourceEncoder，然后在这里进行缓存
      if (deferredEncodeManager.hasResourceToEncode()) {
        deferredEncodeManager.encode(diskCacheProvider, options);
      }
    } finally {
      if (lockedResource != null) {
        lockedResource.unlock();
      }
    }
    
    // 尝试释放资源
    onEncodeComplete();
  }
  
  // 解码，这里返回的是最终结果（transcode类型）的包装类Resource
  private <Data> Resource<R> decodeFromData(
      DataFetcher<?> fetcher, Data data, DataSource dataSource) throws GlideException {
    try {
      if (data == null) {
        // fetcher没有请求到数据
        return null;
      }
      
      // 获取dataClass的LoadPath，使用其中的Decoder和Transcoder进行解码操作
      Resource<R> result = decodeFromFetcher(data, dataSource);
      return result;
    } finally {
      // 执行fetcher的清理工作
      fetcher.cleanup();
    }
  }
  
  // 获取dataClass的LoadPath，使用其中的Decoder和Transcoder进行解码操作
  private <Data> Resource<R> decodeFromFetcher(Data data, DataSource dataSource) {
  
    // 获取dataClass的LoadPath
    LoadPath<Data, ?, R> path = decodeHelper.getLoadPath((Class<Data>) data.getClass());
    
    // 使用LoadPath的Decoder和Transcoder进行解码操作
    return runLoadPath(data, dataSource, path);
  }
  
  // 使用LoadPath的Decoder和Transcoder进行解码操作
  private <Data, ResourceType> Resource<R> runLoadPath(
      Data data, DataSource dataSource, LoadPath<Data, ResourceType, R> path) {
    ...
    // 获取Registry中注册的DataRewinder，负责将DataClass是Stream类型的数据重置到起始位置
    DataRewinder<Data> rewinder = glideContext.getRegistry().getRewinder(data);
    try {
      
      // 使用其中的DecodePath的Decoder和Transcoder进行解码操作，Decoder解码成功后会回调DecodeCallback#onResourceDecoded( Resource<Z> decoded)，在该回调中会使用Transformation#transform(...)进行变换操作，之后会调用DeferredEncodeManager.init(...)将变换后的数据保存起来。最后在Transcoder解码完成后会在notifyEncodeAndRelease(...)中调用DeferredEncodeManager#encode(...)缓存变换后的数据TransformedClass。
      return path.load(
          rewinder, options, width, height, new DecodeCallback<ResourceType>(dataSource));
    } finally {
      rewinder.cleanup();
    }
  }
  
  
  // DecodePath的解码回调
  private final class DecodeCallback<Z> implements DecodePath.DecodeCallback<Z> {

    private final DataSource dataSource;

    @Synthetic
    DecodeCallback(DataSource dataSource) {
      this.dataSource = dataSource;
    }
    
    /**
     * @params decoded 是Decoder解码得到的数据
     * @return 变换后的数据
     */
    @Override
    public Resource<Z> onResourceDecoded(@NonNull Resource<Z> decoded) {
      return DecodeJob.this.onResourceDecoded(dataSource, decoded);
    }
  }
  
  /**
   * Decoder解码完成后触发该方法
   * @params decoded 是ResourceDecoder解码得到的数据DecodedClass
   * @return 变换后的数据TransformedClass
   */
  <Z> Resource<Z> onResourceDecoded(DataSource dataSource, Resource<Z> decoded) {
    
    Class<Z> resourceSubClass = (Class<Z>) decoded.get().getClass();
    Transformation<Z> appliedTransformation = null;
    Resource<Z> transformed = decoded;
    
    // 如果数据源不是处理后的数据，则利用Transformation#tranform(...)进行变换操作
    // 因为数据源可能是通过ResourceCacheGenerator获取的之前缓存的处理（变换）过的数据，这个数据是经过transform的，所以不需要再transform
    if (dataSource != DataSource.RESOURCE_DISK_CACHE) {
      appliedTransformation = decodeHelper.getTransformation(resourceSubClass);
      transformed = appliedTransformation.transform(glideContext, decoded, width, height);
    }
    
    ...

    // 如果Registry中有能够处理tranformed类型的ResourceEncoder，则获取ResourceEncoder和对应的EncodeStrategy，省略该部分代码...

    Resource<Z> result = transformed;
    
    // ... 省略根据encodeStrategy生成key的代码

    // 将key, encoder, 变换后的数据TransformedClass保存在DeferredEncodeManager中
    LockedResource<Z> lockedResult = LockedResource.obtain(transformed);
    deferredEncodeManager.init(key, encoder, lockedResult);
    result = lockedResult;
    return result;
  }
}

DocodeJob主要是根据不同的Stage获取不同的DataFetcherGenerator，不同的DataFetcherGenerator可以得到不同的DataFetcher，DataFetcher是用来请求数据的。

获取数据成功之后，会使用DecodePath中保存的Decoder、Transcoder进行解码操作，得到最终数据。

其中Decoder解码成功后会回调DecodeCallback#onResourceDecoded(Resource<Z> decoded)，在该回调中会使用Transformation#transform(...)进行变换操作，之后会调用DeferredEncodeManager#init(...)将变换后的数据保存起来。最后在Transcoder解码完成后会在notifyEncodeAndRelease(...)中调用DeferredEncodeManager#encode(...)缓存变换后的数据。

DataFetcherGenerator

DataFetcherGenerator有3个子类，逐级尝试获取数据：

ResourceCacheGenerator，从磁盘缓存中获取原始资源处理后的Resource资源
DataCacheGenerator，从磁盘缓存中获取原始资源
SourceGenerator，从数据源（例如网络）中获取资源

这里分析下ResourceCacheGenerator吧：

// ResourceCacheGenerator.java

private Object model;

// 实例是LazyDiskCacheProvider，在Engine中设置给DecodeJobFactory，之后的传递路径是DecodeJobFactory -> DecodeJob -> DecodeHelper。实例是LazyDiskCacheProvider，内部包含一个DiskCache.Factory，实例是InternalCacheDiskCacheFactory，它的build()方法会创建DiskLruCacheWrapper，是一个DiskLruCache的包装类。
private DecodeJob.DiskCacheProvider diskCacheProvider;

// 当前缓存资源对应的key
private Key sourceKey;

// 资源请求回调
private final FetcherReadyCallback cb;

private final DecodeHelper<?> helper;

ResourceCacheGenerator(DecodeHelper<?> helper, FetcherReadyCallback cb) {
    this.helper = helper;
    this.cb = cb;
}

// 开始获取缓存，获取成功返回true，失败返回false
public boolean startNext() {
    // Registry在Engine中初始化后，添加了很多输入类型(ModelClass)，输出类型(DataClass)，以及对应的ModelLoaderFactory，并封装成Entry放入MultiModelLoaderFactory中。
    // 这里通过DecodeHelper获取能够处理model的Entry，并用Entry中的ModelLoaderFactory创建对应的ModelLoader，然后用ModelLoader创建LoadData，之后返回LoadData的sourceKey和alternateKeys
    List<Key> sourceIds = helper.getCacheKeys();
    if (sourceIds.isEmpty()) {
      return false;
    }
    
    // ...
    
    while (modelLoaders == null || !hasNextModelLoader()) {
      resourceClassIndex++;
      if (resourceClassIndex >= resourceClasses.size()) {
        sourceIdIndex++;
        if (sourceIdIndex >= sourceIds.size()) {
          return false;
        }
        resourceClassIndex = 0;
      }

      Key sourceId = sourceIds.get(sourceIdIndex);
      
      // ...
      
      // DiskLruCache的key
      currentKey =
          new ResourceCacheKey( // NOPMD AvoidInstantiatingObjectsInLoops
              helper.getArrayPool(),
              sourceId,
              helper.getSignature(),
              helper.getWidth(),
              helper.getHeight(),
              transformation,
              resourceClass,
              helper.getOptions());
              
      // 利用DecodeHelper获取DiskLruCacheWrapper，它是diskLruCache的包装类，之后根据key获取缓存文件
      cacheFile = helper.getDiskCache().get(currentKey);
      if (cacheFile != null) {
        sourceKey = sourceId;
        
        // 以缓存文件为输入model获取ModelLoader
        modelLoaders = helper.getModelLoaders(cacheFile);
        modelLoaderIndex = 0;
      }
    }

    loadData = null;
    boolean started = false;
    while (!started && hasNextModelLoader()) {
      ModelLoader<File, ?> modelLoader = modelLoaders.get(modelLoaderIndex++);
      
      // 利用ModelLoader构建LoadData
      loadData =
          modelLoader.buildLoadData(
              cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
              
      // 如果loadData对应的dataClass有加载路径LoadPath，说明可以从数据源解码得到最终数据，则利用DataFetcher请求数据
      if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
        started = true;
        
        // 利用DataFetcher请求数据
        loadData.fetcher.loadData(helper.getPriority(), this);
      }
    }

    return started;
}

private boolean hasNextModelLoader() {
    return modelLoaderIndex < modelLoaders.size();
}

@Override
public void onDataReady(Object data) {
    // 当数据加载完成后，会回调通知DecodeJob，onLoadFailed()类似。
    cb.onDataFetcherReady(
        sourceKey, data, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE, currentKey);
}

DataCacheGenerator和SourceCacheGenerator也差不多，只是SourceCacheGenerator获取到数据之后会根据Engine#load(...)中设置的diskCacheStrategy来缓存数据。

// SourceCacheGenerator.java

// 待存储的数据（上次获取的数据）
private Object dataToCache;

private volatile ModelLoader.LoadData<?> loadData;


public boolean startNext() {

    // 如果有待存储的数据，则先存储数据
    if (dataToCache != null) {
      Object data = dataToCache;
      dataToCache = null;
      
      // 存储数据，存储完成后会创建DataCacheGenerator，之后就是通过DataCacheGenerator获取待加载数据
      cacheData(data); 
    }

    // 如果不为null则说明之前存储了数据，存储完成后通过DataCacheGenerator来获取待加载数据，获取成功则return，后面会在onDataFetcherReady(...)通知DecodeJob
    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
      return true;
    }
    
    // 如果之前没有存储数据，或者有存储数据，但是DataCacheGenerator获取待加载数据失败，则通过DataFetcher获取数据
    sourceCacheGenerator = null;

    loadData = null;
    boolean started = false;
    while (!started && hasNextModelLoader()) {
      // 获取能够处理model的ModelLoader，从而buildLoadData，返回能够根据model获取数据的LoadDatas
      loadData = helper.getLoadData().get(loadDataListIndex++);
      
      // 1.如果根据磁盘缓存策略DiskCacheStrategy和LoadData的Fetcher对应的DataSource，表明获取的数据是可以缓存的，或者2.如果获取的数据有对应的加载路径LoadPath，则通过该LoadData的Fetcher获取数据
      if (loadData != null
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
              || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
        started = true;
        
        // 使用Fetcher获取数据
        startNextLoad(loadData);
      }
    }
    return started;
}

private void startNextLoad(final LoadData<?> toStart) {
    loadData.fetcher.loadData(
        helper.getPriority(),
        new DataCallback<Object>() {
          @Override
          public void onDataReady(@Nullable Object data) {
            // 如果Generator请求数据用的LoadData就是当前请求所使用的LoadData，说明是同一个请求
            if (isCurrentRequest(toStart)) {
              onDataReadyInternal(toStart, data);
            }
          }

          @Override
          public void onLoadFailed(@NonNull Exception e) {
            if (isCurrentRequest(toStart)) {
              onLoadFailedInternal(toStart, e);
            }
          }
        });
}


void onDataReadyInternal(LoadData<?> loadData, Object data) {
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
    
    // 如果根据磁盘缓存策略DiskCacheStrategy和LoadData的Fetcher对应的DataSource，表明获取的数据是可以缓存的，则在Glide的线程池中重新执行DecodeJob，之后会重新执行该Generator，可以查看DecodeJob章节进行验证该逻辑
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
      
      // 暂存数据，reschedule()之后会重新执行SourceGenerator#startNext()，数据会在其中进行保存
      dataToCache = data;
      
      cb.reschedule();
    } else {
      cb.onDataFetcherReady(
          loadData.sourceKey,
          data,
          loadData.fetcher,
          loadData.fetcher.getDataSource(),
          originalKey);
    }
}

// 缓存数据
private void cacheData(Object dataToCache) {
    long startTime = LogTime.getLogTime();
    try {
    
      // 根据待缓存数据的Class，获取Registry在Glide中添加的Encoder
      Encoder<Object> encoder = helper.getSourceEncoder(dataToCache);
      
      // 这是一个包装类，包含待缓存数据、Encoder和Options，之后在DiskLruCacheWrapper中拿到缓存文件后，调用DataCacheWriter#write(file)，其实就是调用Encoder#encode(data, file, options)通过输出流将数据写入缓存文件
      DataCacheWriter<Object> writer =
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
      originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
      
      // 利用DecodeHelper获取DiskLruCacheWrapper，它是DiskLruCache的包装类，然后将数据放入originalKey对应的缓存文件中
      helper.getDiskCache().put(originalKey, writer);
    } finally {
      // 释放DataFetcher中的资源
      loadData.fetcher.cleanup();
    }

    // 创建DataCacheGenerator，一会会通过DataCacheGenerator获取待加载的数据
    sourceCacheGenerator =
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
}

DataCacheWriter是个包装类，实际还是通过Encoder在缓存数据的：

// DataCacheWriter.java

class DataCacheWriter<DataType> implements DiskCache.Writer {
  private final Encoder<DataType> encoder;
  private final DataType data;
  private final Options options;

  DataCacheWriter(Encoder<DataType> encoder, DataType data, Options options) {
    this.encoder = encoder;
    this.data = data;
    this.options = options;
  }

  // 在在DiskLruCacheWrapper中拿到缓存文件后，调用该方法
  @Override
  public boolean write(@NonNull File file) {
    return encoder.encode(data, file, options);
  }
}

随便看一个Encoder的实现吧：

public class StreamEncoder implements Encoder<InputStream> {
    
  public boolean encode(@NonNull InputStream data, @NonNull File file, @NonNull Options options) {
    byte[] buffer = byteArrayPool.get(ArrayPool.STANDARD_BUFFER_SIZE_BYTES, byte[].class);
    boolean success = false;
    OutputStream os = null;
    try {
      // 将输入流写入到缓存文件
      os = new FileOutputStream(file);
      int read;
      while ((read = data.read(buffer)) != -1) {
        os.write(buffer, 0, read);
      }
      os.close();
      success = true;
    } catch (IOException e) {
    } finally {
      // ... close stream
    }
    return success;
  }

}

LoadPath、DecodePath

由DecodeJob章节可以知道，通过Generator获取数据成功后，会通过LoadPath/DecodePath进行解码。

几个类的理解：

LoadPath，可以这么理解：顾名思义，加载路径，从dataClass得到resourceClass，从而得到transcodeClass，内部包含dataClass、resourceClass、transcodeClass以及decodePath
DecodePath，可以这么理解：顾名思义，解码路径，内部包含ResourceDecoder和ResourceTranscoder，以及DataClass、ResourceClass、TranscodeClass，利用ResourceDecoder可以将DataClass转化为ResourceClass，利用TranscodeClass可以将ResrouceClass转化为TranscodeClass

// LoadPath.java
public class LoadPath<Data, ResourceType, Transcode> {

  // 该LoadPath对应的dataClass
  private final Class<Data> dataClass;
  
  // 实际进行解码操作的是DecodePath
  private final List<? extends DecodePath<Data, ResourceType, Transcode>> decodePaths;
  
  
  public Resource<Transcode> load(
      DataRewinder<Data> rewinder,
      Options options,
      int width,
      int height,
      DecodePath.DecodeCallback<ResourceType> decodeCallback) {
    List<Throwable> throwables = Preconditions.checkNotNull(listPool.acquire());
    ...
    
    // 利用DecodePath中的Decoder、Transcoder进行解码
    return loadWithExceptionList(rewinder, options, width, height, decodeCallback, throwables);
    
    ...
  }
  
  
  // 利用DecodePath中的Decoder、Transcoder进行解码
  private Resource<Transcode> loadWithExceptionList(
      DataRewinder<Data> rewinder,
      Options options,
      int width,
      int height,
      DecodePath.DecodeCallback<ResourceType> decodeCallback,
      List<Throwable> exceptions) {
    Resource<Transcode> result = null;
    for (int i = 0, size = decodePaths.size(); i < size; i++) {
      DecodePath<Data, ResourceType, Transcode> path = decodePaths.get(i);
      
      // 使用DecodePath进行解码
      result = path.decode(rewinder, width, height, options, decodeCallback);
      if (result != null) {
        break;
      }
    }
    
    return result;
  }

}

LoadPath相当于代理类，内部使用DecodePath来完成解码操作。

// DecodePath.java
public class DecodePath<DataType, ResourceType, Transcode> {
    
    // DecodePath对应的dataClass
    private final Class<DataType> dataClass;
    
    // 能够将dataClass转换为ResourceClass的ResourceDecoder
    private final List<? extends ResourceDecoder<DataType, ResourceType>> decoders;
    
    // 能够将ResourceClass转换为TranscodeClass的ResourceTranscoder
    private final ResourceTranscoder<ResourceType, Transcode> transcoder;
    
// 解码操作    
public Resource<Transcode> decode(
      DataRewinder<DataType> rewinder,
      int width,
      int height,
      Options options,
      DecodeCallback<ResourceType> callback)
      throws GlideException {
      
    // 使用ResourceDecoder将DataClass转换为ResourceClass
    Resource<ResourceType> decoded = decodeResource(rewinder, width, height, options);
    
    // 回调到DecodeJob中，利用Trasformation对ResourceClass进行变换操作
    Resource<ResourceType> transformed = callback.onResourceDecoded(decoded);
    
    // 使用ResourceTranscoder将变换后的资源转换为最终结果
    return transcoder.transcode(transformed, options);
  }
  

private Resource<ResourceType> decodeResource(
      DataRewinder<DataType> rewinder, int width, int height, @NonNull Options options)
      throws GlideException {
    ...
    return decodeResourceWithList(rewinder, width, height, options, exceptions);
    ...
  }
  
  
private Resource<ResourceType> decodeResourceWithList(
      DataRewinder<DataType> rewinder,
      int width,
      int height,
      @NonNull Options options,
      List<Throwable> exceptions) {
      
    Resource<ResourceType> result = null;
    
    for (int i = 0, size = decoders.size(); i < size; i++) {
      ResourceDecoder<DataType, ResourceType> decoder = decoders.get(i);
      
      // 使用DataRewinder将数据类型为Stream类型的数据重置到起始位置，并返回数据
      DataType data = rewinder.rewindAndGet();
      
      // 如果该decoder能够处理data，则使用decoder进行解码
      if (decoder.handles(data, options)) {
        data = rewinder.rewindAndGet();
        result = decoder.decode(data, width, height, options);
      }

      if (result != null) {
        break;
      }
    }
    return result;
  }
}

DeferredEncodeManager<Z>

由DecodeJob章节可以知道，数据解码成功后，会通过DeferredEncodeManager进行缓存，它是DecodeJob的内部类。

它其实是个辅助类，实际的缓存工作是由ResourceEncoder完成的。

private static class DeferredEncodeManager<Z> {
    private Key key;
    
    // 缓存数据的ResourceEncoder
    private ResourceEncoder<Z> encoder;
    
    // 待缓存的数据
    private LockedResource<Z> toEncode;
    
    // ResourceDecoder解码原始数据后，在DecodeJob#onResourceDecoded(DataSource dataSource, Resource<Z> decoded)方法中调用，保存待缓存数据（处理（变换）后的数据DecodedClass/TransformedClass，不是最终数据TranscodedClass）和对应的key以及ResourceEncoder
    <X> void init(Key key, ResourceEncoder<X> encoder, LockedResource<X> toEncode) {
      this.key = key;
      this.encoder = (ResourceEncoder<Z>) encoder;
      this.toEncode = (LockedResource<Z>) toEncode;
    }
    
    
    // ResourceTranscoder解码DecodedClass/TransformedClass后，在DecodeJob#notifyEncodeAndRelease(...)中调用，进行缓存DecodedClass/TransformedClass
    void encode(DiskCacheProvider diskCacheProvider, Options options) {
      GlideTrace.beginSection("DecodeJob.encode");
      try {
        // 获取DiskLruCacheWrapper，并构建DataCacheWriter用于缓存文件，具体参考DataFetcherGenerator章节Encoder缓存数据相关内容
        diskCacheProvider
            .getDiskCache()
            .put(key, new DataCacheWriter<>(encoder, toEncode, options));
      } finally {
        toEncode.unlock();
        GlideTrace.endSection();
      }
    }
    
    boolean hasResourceToEncode() {
      return toEncode != null;
    }
}

DecodeHelper

DecodeHelper是一个辅助类，每个DecodeJob对应一个DecodeHelper，在DecodeJob#init(...)中进行初始化，为DecodeJob提供能够处理Model的ModelLoader、LoadData和对应的Key、DiskCache、DiskCacheStrategy、LoadPath、Transformation、以及缓存数据用的Encoder等。

final class DecodeHelper<Transcode> {
  private final List<LoadData<?>> loadData = new ArrayList<>();
  private final List<Key> cacheKeys = new ArrayList<>();

  private GlideContext glideContext;
  private Object model;
  private int width;
  private int height;
  private Class<?> resourceClass;
  private DecodeJob.DiskCacheProvider diskCacheProvider;    // Engine中初始化了LazyDiskCacheProvider，传给DecodeJobFactory->DecodeJob->DecodeHelper
  private Options options;
  private Map<Class<?>, Transformation<?>> transformations;
  private Class<Transcode> transcodeClass;
  private DiskCacheStrategy diskCacheStrategy;
  
  
  // 在DecodeJob#init(...)中调用进行初始化
  <R> void init(
      GlideContext glideContext,
      Object model,
      Key signature,
      int width,
      int height,
      DiskCacheStrategy diskCacheStrategy,
      Class<?> resourceClass,
      Class<R> transcodeClass,
      Priority priority,
      Options options,
      Map<Class<?>, Transformation<?>> transformations,
      boolean isTransformationRequired,
      boolean isScaleOnlyOrNoTransform,
      DiskCacheProvider diskCacheProvider) {
    this.glideContext = glideContext;
    this.model = model;
    this.signature = signature;
    this.width = width;
    this.height = height;
    this.diskCacheStrategy = diskCacheStrategy;
    this.resourceClass = resourceClass;
    
    this.diskCacheProvider = diskCacheProvider; // 实例是LazyDiskCacheProvider，在Engine中设置给DecodeJobFactory，之后的传递路径是DecodeJobFactory -> DecodeJob -> DecodeHelper。
    
    this.transcodeClass = (Class<Transcode>) transcodeClass;
    this.priority = priority;
    this.options = options;
    this.transformations = transformations;
    this.isTransformationRequired = isTransformationRequired;
    this.isScaleOnlyOrNoTransform = isScaleOnlyOrNoTransform;
  }
  
  // 获取DiskCache，它有两个子类，一个是DiskCacheAdapter（空实现），一个是DiskLruCacheWrapper（DiskLruCache的包装类）
  DiskCache getDiskCache() {
    return diskCacheProvider.getDiskCache();
  }

  // 获取磁盘缓存策略，用于判断请求结果（包括原始数据和处理后的数据）是否可以缓存，详见DiskCacheStrategy章节
  DiskCacheStrategy getDiskCacheStrategy() {
    return diskCacheStrategy;
  }
  
  // 获取返回结果的Class，例如BitmapDrawable
  Class<?> getTranscodeClass() {
    return transcodeClass;
  }

  // 获取请求参数的Class，例如RequestManager#load(String url)，ModelClass就是Strin.class
  Class<?> getModelClass() {
    return model.getClass();
  }
    
  // 中间类型，从数据源返回的类型Data编码成的类型，例如Bitmap、Drawable、GifDrawable、BitmapDrawable、File等。举个例子：例如由InputStream编码成Bitmap。可以参考Engine的构造函数中，Registry#append(...)添加的类型。
  List<Class<?>> getRegisteredResourceClasses() {
    return glideContext
        .getRegistry()
        .getRegisteredResourceClasses(model.getClass(), resourceClass, transcodeClass);
  }

  // 是否有符合从DataClass->ResourceClass->TranscodeClass的LoadPath
  boolean hasLoadPath(Class<?> dataClass) {
    return getLoadPath(dataClass) != null;
  }

  // 获取从DataClass->ResourceClass->TranscodeClass的LoadPath
  <Data> LoadPath<Data, ?, Transcode> getLoadPath(Class<Data> dataClass) {
    return glideContext.getRegistry().getLoadPath(dataClass, resourceClass, transcodeClass);
  }
  
  // 获取能够以缓存文件file为输入得到数据的ModelLoader
  List<ModelLoader<File, ?>> getModelLoaders(File file)
      throws Registry.NoModelLoaderAvailableException {
    return glideContext.getRegistry().getModelLoaders(file);
  }
  
  // 获取能够以Model为输入得到数据的LoadData
  List<LoadData<?>> getLoadData() {
    if (!isLoadDataSet) {
      isLoadDataSet = true;
      loadData.clear();
      List<ModelLoader<Object, ?>> modelLoaders = glideContext.getRegistry().getModelLoaders(model);
      //noinspection ForLoopReplaceableByForEach to improve perf
      for (int i = 0, size = modelLoaders.size(); i < size; i++) {
        ModelLoader<Object, ?> modelLoader = modelLoaders.get(i);
        LoadData<?> current = modelLoader.buildLoadData(model, width, height, options);
        if (current != null) {
          loadData.add(current);
        }
      }
    }
    return loadData;
  }
  
  // 获取能够以Model为输入得到数据的LoadData对应的Key
  List<Key> getCacheKeys() {
    if (!isCacheKeysSet) {
      isCacheKeysSet = true;
      cacheKeys.clear();
      List<LoadData<?>> loadData = getLoadData();
      //noinspection ForLoopReplaceableByForEach to improve perf
      for (int i = 0, size = loadData.size(); i < size; i++) {
        LoadData<?> data = loadData.get(i);
        if (!cacheKeys.contains(data.sourceKey)) {
          cacheKeys.add(data.sourceKey);
        }
        for (int j = 0; j < data.alternateKeys.size(); j++) {
          if (!cacheKeys.contains(data.alternateKeys.get(j))) {
            cacheKeys.add(data.alternateKeys.get(j));
          }
        }
      }
    }
    return cacheKeys;
  }

  // 获取能够缓存data的Encoder
  <X> Encoder<X> getSourceEncoder(X data) throws Registry.NoSourceEncoderAvailableException {
    return glideContext.getRegistry().getSourceEncoder(data);
  }
  
}

ModelLoader、LoadData、DataFetcher

这三个类主要是用于根据model请求数据的。

三者的UML图如下：

在Glide章节中，我们知道Registry注册了很多Entry，其中包括注册了ModelLoaderFactory，而这个ModelLoaderFactory最终会被包装成Entry，保存在MultiModelLoaderFactory中：

// Glide.java
registry.append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())

// Registry.java
public <Model, Data> Registry append(
      @NonNull Class<Model> modelClass,
      @NonNull Class<Data> dataClass,
      @NonNull ModelLoaderFactory<Model, Data> factory) {
    modelLoaderRegistry.append(modelClass, dataClass, factory);
    return this;
}

// ModelLoaderRegistry.java
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); // 1
    cache.clear();
}

// MultiModelLoaderFactory.java

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);  // 2
}

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); // 3
}

之后在DecodedJob中，我们知道，请求数据是由DataFetcherGenerator完成的，具体可以参考DecodeJob和DataFetcherGenerator章节。

而DataFetcherGenerator则是通过DecodeHelper获取Registry中注册的能够处理model的Entry的ModelLoaderFactory，从而build出ModelLoader，进而得到LoadData。

例如SourceGenerator，这里只展示部分代码，具体灿开DataFetcherGenerator章节。

// SourceGenerator.java

public boolean startNext() {
    ...
    
    // 1. 通过DecodeHelper获取LoadData
    loadData = helper.getLoadData().get(loadDataListIndex++); 
    ...
}

// DecodeHelper.java

List<LoadData<?>> getLoadData() {
    ...
    
    // 2. 获取Registry中注册的能够处理model的Entry，并用其中的ModelLoaderFactory创建ModelLoader
    List<ModelLoader<Object, ?>> modelLoaders = glideContext.getRegistry().getModelLoaders(model); 
    
    ...
    
    // 3. 通过ModelLoader创建LoadData
    ModelLoader<Object, ?> modelLoader = modelLoaders.get(i);
    LoadData<?> current = modelLoader.buildLoadData(model, width, height, options); 
    
    ...
}

得到LoadData之后，就会用其中的DataFetcher请求数据，具体可以参考DataFetcherGenerator章节。

这里简单看下HttpGlideUrlLoader，以及对应的Factory和Fetcher吧：

// HttpGlideUrlLoader.java
public class HttpGlideUrlLoader implements ModelLoader<GlideUrl, InputStream> {

    // 返回LoadData，内部包含实际进行请求的Fetcher
    @Override
    public LoadData<InputStream> buildLoadData(GlideUrl model, int width, int height, Options options) {
        return new LoadData<>(url, new HttpUrlFetcher(url, timeout));
    }
    
    // 用于判断当前ModelLoader是否可以处理model。
    // 例如UrlUriModelLoader判断是否可以处理model的条件是uri的schema是否是http或https
    @Override
    public boolean handles(GlideUrl model) {
         return true;
    }
    
    // 创建该ModelLoader的ModelLoaderFactory
    public static class Factory implements ModelLoaderFactory<GlideUrl, InputStream> {
        
        // 创建ModelLoader
        public ModelLoader<GlideUrl, InputStream> build(MultiModelLoaderFactory multiFactory) {
              return new HttpGlideUrlLoader(modelCache);
        }
        
    }
}

真正实现请求的是DataFetcher：

// HttpUrlFetcher.java

// HttpUrlFetcher的model是GlideUrl，data是InputStream
public class HttpUrlFetcher implements DataFetcher<InputStream> {

  private final GlideUrl glideUrl;
  
  // 工厂类，用于创建HttpURLConnection
  private final HttpUrlConnectionFactory connectionFactory;
  
  private HttpURLConnection urlConnection;
  
  // 请求得到的数据
  private InputStream stream;
  
public void loadData(Priority priority, DataCallback<? super InputStream> callback) {
    
    try {
      // 执行请求，得到数据数据流
      InputStream result = loadDataWithRedirects(glideUrl.toURL(), 0, null, glideUrl.getHeaders());
      
      // 回调通知DataFetcherGenerator或MultiModelLoader
      callback.onDataReady(result);
    } catch (IOException e) {
    
      callback.onLoadFailed(e);
    }
  }
  
  // 执行请求，得到数据数据流
  private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl, Map<String, String> headers) {

    // ... 省略一些抛异常的代码
    
    // 通过工厂类创建HttpURLConnection，例如url.openConnection()
    urlConnection = connectionFactory.build(url);
    
    // ... 省略一些给urlConnection设置header、timeout等参数的代码

    // 请求服务器
    urlConnection.connect();
    
    // 获取输入流，以便在cleanup()中关闭，避免（ResponseBody）资源泄漏？
    stream = urlConnection.getInputStream();
    
    if (isCancelled) {
      return null;
    }
    
    // 响应码
    final int statusCode = urlConnection.getResponseCode();
    
    if (isHttpOk(statusCode)) {
    
      // 请求成功，则从连接获取输入流
      return getStreamForSuccessfulRequest(urlConnection);
    } else if (isHttpRedirect(statusCode)) {
      
      // ... 省略重定向相关代码
    } else if (statusCode == INVALID_STATUS_CODE) {
      // 无法识别的错误码，请求失败
      throw new HttpException(statusCode);
    } else {
      // 请求失败
      throw new HttpException(urlConnection.getResponseMessage(), statusCode);
    }
  }
 
 
  private static boolean isHttpOk(int statusCode) {
    return statusCode / 100 == 2;
  }
  
  private static boolean isHttpRedirect(int statusCode) {
    return statusCode / 100 == 3;
  }
  
  // 从连接获取输入流
  private InputStream getStreamForSuccessfulRequest(HttpURLConnection urlConnection) {
    if (TextUtils.isEmpty(urlConnection.getContentEncoding())) {
      // ContentEncoding为空，说明返回的是未压缩的响应正文，则Response中的响应头包含ContentLength!=-1
      int contentLength = urlConnection.getContentLength();
      stream = ContentLengthInputStream.obtain(urlConnection.getInputStream(), contentLength);
    } else {
      // ContentEncoding不为空，说明返回的是压缩过的响应正文，ContentLength==-1，则直接获取数据流，之后需要用ContentEncoding的编码格式进行解码，例如gzip
      stream = urlConnection.getInputStream();
    }
    return stream;
  }
  
  // 执行资源清理工作
  @Override
  public void cleanup() {
    if (stream != null) {
        stream.close();
    }
    if (urlConnection != null) {
      urlConnection.disconnect();
    }
    urlConnection = null;
  }
  
  
  // 取消请求数据操作
  @Override
  public void cancel() {
    isCancelled = true;
  }

}

得到DataFetcher后，会包装成LoadData，它是一个包装类，其实啥也没干，位于ModelLoader的内部类：

// ModelLoader.java
public interface ModelLoader<Model, Data> {
  
  class LoadData<Data> {
    public final Key sourceKey;
    public final List<Key> alternateKeys;
    public final DataFetcher<Data> fetcher;

    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);
    }
  }
}

作者：GIndoc
链接：https://www.jianshu.com/p/65b0a4385d01
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

锐湃

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Glide源码解析四——Engine相关（从数据源获取数据）

DecodeHelper是一个辅助类，每个DecodeJob对应一个DecodeHelper，在DecodeJob#init(...)中进行初始化，为DecodeJob提供能够处理Model的ModelLoader、LoadData和对应的Key、DiskCache、DiskCacheStrategy、LoadPath、Transformation、以及缓存数据用的Encoder等。获取数据成功之后，会使用DecodePath中保存的Decoder、Transcoder进行解码操作，得到最终数据。
复制链接

扫一扫

专栏目录