Glide原理分析(二)：Engine加载流程详解手机开发

上一篇文章《Glide原理解析（一）：加载流程分析》主要大致地分析了Glide加载图片的整体流程，这一篇主要解决的上一篇遗留的一个问题：

Glide Engine 如何加载图片，内部涉及到Glide的缓存模块

上篇文章在SingleRequest中获取到了ViewTarget的宽高之后(假定是ImageView)，onSizeReady()调用了engine的load()方法

loadStatus = engine.load( 
        glideContext, 
        model, 
        requestOptions.getSignature(), 
        this.width, 
        this.height, 
        requestOptions.getResourceClass(), 
        transcodeClass, 
        priority, 
        requestOptions.getDiskCacheStrategy(), 
        requestOptions.getTransformations(), 
        requestOptions.isTransformationRequired(), 
        requestOptions.isScaleOnlyOrNoTransform(), 
        requestOptions.getOptions(), 
        requestOptions.isMemoryCacheable(), 
        requestOptions.getUseUnlimitedSourceGeneratorsPool(), 
        requestOptions.getUseAnimationPool(), 
        requestOptions.getOnlyRetrieveFromCache(), 
        this); 

在看Engine的load()方法之前，先看下Engine主要的数据结构

private final Jobs jobs;
负责缓存EngineJob的管理类

private final EngineKeyFactory keyFactory;
负责创建缓存的key

private final DecodeJobFactory decodeJobFactory;
负责创建DecodeJob, DecodeJob负责从缓存或原始资源解码转换

private final EngineJobFactory engineJobFactory;
负责创建EngineJob，EngineJob负责处理DecodeJob的加载结果

private final ResourceRecycler resourceRecycler;
当资源被移除或者释放时，负责回收资源（可能是被回收到其他的LruCache中去）

private final MemoryCache cache;
内部是LruCache缓存

private final LazyDiskCacheProvider diskCacheProvider;
内部是DiskLruCache缓存

private final ActiveResources activeResources;
内部是弱引用缓存，当前活跃的缓存资源

看完了上面的数据结构，开始load()加载资源

// Engine.java 
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) {
    
	// 根据图像类型、原始宽高、目标宽高、转换等各种因素创建一个Key 
    EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations, 
        resourceClass, transcodeClass, options); 
 
	// 从当前活跃资源里面获取 
    EngineResource<?> active = loadFromActiveResources(key, isMemoryCacheable); 
    if (active != null) {
    
	  // 获取成功，直接回调返回 
      cb.onResourceReady(active, DataSource.MEMORY_CACHE); 
      return null; 
    } 
    // 从LruCache资源获取 
    EngineResource<?> cached = loadFromCache(key, isMemoryCacheable); 
    if (cached != null) {
    
	  // 获取成功，直接回调返回 
      cb.onResourceReady(cached, DataSource.MEMORY_CACHE); 
      return null; 
    } 
 
	// 从DiskLruCache资源获取 
    EngineJob<?> current = jobs.get(key, onlyRetrieveFromCache); 
    if (current != null) {
    
	  // 获取成功，需要进一步转码 
      current.addCallback(cb); 
      return new LoadStatus(cb, current); 
    } 
 
    EngineJob<R> engineJob = 
        engineJobFactory.build( 
            key, 
            isMemoryCacheable, 
            useUnlimitedSourceExecutorPool, 
            useAnimationPool, 
            onlyRetrieveFromCache); 
 
    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); 
 
    engineJob.addCallback(cb); 
	// 开始加载 
    engineJob.start(decodeJob); 
 
    return new LoadStatus(cb, engineJob); 
  } 

在开始看engineJob如何加载之前，先看下一个问题：

一般来说我们都是使用LruCache和DiskLruCache作为缓存，为什么Glide还用上了弱引用缓存？

如果你仔细的看你可以注意到从LruCache加载资源方法，有些奇怪：

private EngineResource<?> loadFromCache(Key key, boolean isMemoryCacheable) {
    
	... 
	// 从LruCache获取资源 
    EngineResource<?> cached = getEngineResourceFromCache(key); 
    if (cached != null) {
    
      cached.acquire(); 
	  // 加入到activeResources弱引用 
      activeResources.activate(key, cached); 
    } 
    return cached; 
  } 
 
  private EngineResource<?> getEngineResourceFromCache(Key key) {
    
    // 从LruCache获取资源,并且移除它 
	Resource<?> cached = cache.remove(key); 
    ... 
    return result; 
  } 

相信你看到了，从LruCache获取资源并将它移除，加入到弱引用缓存中。后面终于想清楚了：

LruCache是有容量限制的，比如说设定10个，那么当前活跃图片如果有8个，那么LruCache其中有8个是当前活跃图片，2个缓存之前使用过的图片。

加入了弱引用缓存以后，LruCache可以缓存10个之前使用过的图片，并且因为弱引用的特性，不会复制副本，占据内存。

在不增加缓存内存容量限制的情况下，弱引用缓存极大地增大了Glide的命中率。

继续看engineJob.start(decodeJob)

// EngineJob.java 
  public void start(DecodeJob<R> decodeJob) {
    
    this.decodeJob = decodeJob; 
	// 根据是否从缓存加载选定不同的线程池 
    GlideExecutor executor = decodeJob.willDecodeFromCache() 
        ? diskCacheExecutor 
        : getActiveSourceExecutor(); 
	// 加入到线程池中，继续到decodeJob.run() 
    executor.execute(decodeJob); 
  } 

注释写得蛮清楚，继续到DecodeJob.run()

// DecodeJob.java 
  public void run() {
    
	... 
      runWrapped(); 
	... 
  } 
 
  private void runWrapped() {
    
    switch (runReason) {
    
      case INITIALIZE: 
	    // 首次获取 
        stage = getNextStage(Stage.INITIALIZE); 
        currentGenerator = getNextGenerator(); 
        runGenerators(); 
        break; 
      case SWITCH_TO_SOURCE_SERVICE: 
	    // 从获取Disk资源失败重新获取 
        runGenerators(); 
        break; 
      case DECODE_DATA: 
	    // 获取资源成功 
        decodeFromRetrievedData(); 
        break; 
      default: 
        throw new IllegalStateException("Unrecognized run reason: " + runReason); 
    } 
  } 
   
  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); 
    } 
  } 

在runWrapped中还使用了状态者模式，对应有三种资源：
Data: 原始的图片缓存数据
Resource： 经过处理的图片缓存数据（例如旋转裁剪转换）
Source：无缓存数据

代码会依次走DataCacheGenerator、ResourceCacheGenerator、SourceGenerator，如果一个无法处理就传递给下一个Generator。

这里假定是首次加载数据，就会走到 SourceGenerator ，并且runGenerators()方法调用SourceGenerator.runNext()

// SourceGenerator.java 
public boolean startNext() {
    
    // dataToCache 表示已经获取到的资源 
    if (dataToCache != null) {
    
      Object data = dataToCache; 
      dataToCache = null; 
	  // 将数据缓存 
      cacheData(data); 
    } 
	 
	// cacheData 会生成sourceCacheGenerator，交由sourceCacheGenerator缓存处理器处理 
    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
    
      // 到这里，说明不需要去获取数据 
	  return true; 
    } 
    sourceCacheGenerator = null; 
 
    loadData = null; 
    boolean started = false; 
	 
	// 以下部分就是根据缓存策略和各个ModelLoader去加载对应的资源 
    while (!started && hasNextModelLoader()) {
    
      loadData = helper.getLoadData().get(loadDataListIndex++); 
      if (loadData != null 
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource()) 
          || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
    
        started = true; 
        loadData.fetcher.loadData(helper.getPriority(), this); 
      } 
    } 
    return started; 
} 

ModelLoader 是一个工厂接口，用于将任意复杂的数据模型转换为具体数据类型，从而能够使用DataFetcher去获取由该模型表示的资源的数据。

LoadData 一系列Key和DataFetcher组合的一个数据结构。

HttpGlideUrlLoader ModelLoader实现类，内部会构建一个HttpUrlFetcher对象。

FileLoader ModelLoader实现类，内部会构建一个FileFetcher对象。

在Glide初始化的时候有注册了各种ModelLoader，包括了HttpGlideUrlLoader

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

HttpGlideUrlLoader 内部构造了 HttpUrlFetcher ，调用了 HttpUrlFetcher 的loadData()加载网络数据

// HttpUrlFetcher 
  public void loadData(@NonNull Priority priority, 
      @NonNull DataCallback<? super InputStream> callback) {
    
    try {
    
      InputStream result = loadDataWithRedirects(glideUrl.toURL(), 0, null, glideUrl.getHeaders()); 
      callback.onDataReady(result); 
    } catch (IOException e) {
    
      callback.onLoadFailed(e); 
    }  
  } 
   
private InputStream loadDataWithRedirects(URL url, int redirects, URL lastUrl, 
      Map<String, String> headers) throws IOException {
    
	... 
	// 利用HttpUrlConnection 
    urlConnection = connectionFactory.build(url); 
    for (Map.Entry<String, String> headerEntry : headers.entrySet()) {
    
      urlConnection.addRequestProperty(headerEntry.getKey(), headerEntry.getValue()); 
    } 
	// 设置 HttpUrlConnection 参数 
    urlConnection.setConnectTimeout(timeout); 
    urlConnection.setReadTimeout(timeout); 
    urlConnection.setUseCaches(false); 
    urlConnection.setDoInput(true); 
 
    urlConnection.setInstanceFollowRedirects(false); 
 
    urlConnection.connect(); 
    stream = urlConnection.getInputStream(); 
    if (isCancelled) {
    // 被取消 
      return null; 
    } 
    final int statusCode = urlConnection.getResponseCode(); 
    if (isHttpOk(statusCode)) {
    // 成功 
      return getStreamForSuccessfulRequest(urlConnection); 
    } else if (isHttpRedirect(statusCode)) {
    // 重定向 
      String redirectUrlString = urlConnection.getHeaderField("Location"); 
      if (TextUtils.isEmpty(redirectUrlString)) {
    
        throw new HttpException("Received empty or null redirect url"); 
      } 
      URL redirectUrl = new URL(url, redirectUrlString); 
      cleanup(); 
      return loadDataWithRedirects(redirectUrl, redirects + 1, url, headers); 
    }  
  } 

千辛万苦终于到最后一步的网络加载，底层是利用HttpUrlConnection加载数据

  public void onDataReady(Object data) {
    
    DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy(); 
	// 如果可以缓存 
    if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
    
      dataToCache = data; // 将网络获取到资源缓存在SourceGenerator中 
      cb.reschedule(); // DecodeJob会再次执行 
    } else {
    
      cb.onDataFetcherReady(loadData.sourceKey, data, loadData.fetcher, 
          loadData.fetcher.getDataSource(), originalKey); 
    } 
  } 

SourceGenerator再次执行到了startNext()，但是dataToCache已经有数据，在cacheData内部生成了 DataCacheGenerator

// SourceGenerator.java 
public boolean startNext() {
    
    // dataToCache 表示已经获取到的资源 
    if (dataToCache != null) {
    
      Object data = dataToCache; 
      dataToCache = null; 
	  // 将数据缓存 
      cacheData(data); 
    } 
	 
	// cacheData 会生成 sourceCacheGenerator，交由 sourceCacheGenerator 缓存处理器处理 
    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
    
      // 到这里，说明不需要去获取数据 
	  return true; 
    } 
    ... 
} 
 
// SourceGenerator.java 
private void cacheData(Object dataToCache) {
    
    long startTime = LogTime.getLogTime(); 
    try {
    
      Encoder<Object> encoder = helper.getSourceEncoder(dataToCache); 
      DataCacheWriter<Object> writer = 
          new DataCacheWriter<>(encoder, dataToCache, helper.getOptions()); 
      // 生成对应的缓存key 
	  originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature()); 
	  // 将写入磁盘缓存 
      helper.getDiskCache().put(originalKey, writer); 
    } finally {
    
      loadData.fetcher.cleanup(); 
    } 
	//生成了 DataCacheGenerator 
    sourceCacheGenerator = 
        new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this); 
  } 
 

可见，SourceGenerator第二次执行的时候将缓存写入，并且生成 DataCacheGenerator，并交给DataCacheGenerator.startNext()。

DataCacheGenerator内部会回调 FetcherReadyCallback.onDataFetcherReady()，其实 FetcherReadyCallback就是 SourceGenerator ，依次SourceGenerator会回调到DecodeJob，依次回到EngineJob，最后到Target中，调用ImageView.setImageBitmap()。

总结

Glide使用了弱引用缓存、LruCache、DiskLruCache，底层默认利用了HttpUrlConnection加载数据资源，中间处理转换细节很复杂。

参考：

云图网

云图网