Android 开发之Glide《五》缓存

最新推荐文章于 2024-05-05 03:37:05 发布
最新推荐文章于 2024-05-05 03:37:05 发布
阅读量852 收藏
点赞数
分类专栏： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31469589/article/details/117261407
版权

前言

一、简介

缓存设置

     Glide.with(this).load("url").skipMemoryCache(true).diskCacheStrategy(DiskCacheStrategy.ALL)

设置内存缓存开关：true 表示不使用内存缓存

skipMemoryCache()

设置磁盘缓存模式：

diskCacheStrategy（）

可以设置4种模式：

  1. DiskCacheStrategy.NONE：表示不缓存任何内容。
  2. DiskCacheStrategy.DATA：表示只缓存原始图片。
  3. DiskCacheStrategy.RESOURCE：表示只缓存转换过后的图片（默认选项）。
  4. DiskCacheStrategy.ALL ：表示既缓存原始图片，也缓存转换过后的图片。

这里需要主要是RESOURCE，当我们下载下来图片之后可能对图片裁剪，放缩等操作，所有转换之后的图片就是RESOURCE。

二 内存缓存

Engine.java

  @Nullable
  private EngineResource<?> loadFromMemory(
      EngineKey key, boolean isMemoryCacheable, long startTime) {
    if (!isMemoryCacheable) {
      return null;
    }

    EngineResource<?> active = loadFromActiveResources(key);
    if (active != null) {
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from active resources", startTime, key);
      }
      return active;
    }

    EngineResource<?> cached = loadFromCache(key);
    if (cached != null) {
      if (VERBOSE_IS_LOGGABLE) {
        logWithTimeAndKey("Loaded resource from cache", startTime, key);
      }
      return cached;
    }

    return null;
  }

在下载图片之前会现在内存里面查找对应的图片，这个方法在Engine的loadFromMemory，

loadFromMemory 里面有分为两个部分一是ActiveResources，表示当前正在使用的资源，什么是当前正在使用？就是有某一个View 正在显示这个图片，根本上说是这个图片存在一个强引用。ActiveResources 使用的弱引用来缓存图片，弱引用应用的资源在没有强引用的时候会被自动回收。换句话说当页面销毁了图片的强引用就没了，此时系统会自动回收所有的弱引用引用的资源。这样可以更好的避免内存泄露。

loadFromCache 使用的Lru 缓存的图片，简单区分就是loadFromMemory 缓存的图片表示当前一定有一个View 在显示它，loadFromCache 厘米缓存的图片不一定存在View 显示它。

2.1 弱引用缓存

  private final ActiveResources activeResources;

  @Nullable
  private EngineResource<?> loadFromActiveResources(Key key) {
    EngineResource<?> active = activeResources.get(key);
    if (active != null) {
      active.acquire();
    }

    return active;
  }

 final Map<Key, ResourceWeakReference> activeEngineResources = new HashMap<>();

在这里插入图片描述
在这里插入图片描述

如果还有对WeakReference 不理解的同学可以百度一下。

2.2 LruCache

  private EngineResource<?> loadFromCache(Key key) {
    EngineResource<?> cached = getEngineResourceFromCache(key);
    if (cached != null) {
      cached.acquire();
      activeResources.activate(key, cached);
    }
    return cached;
  }

 每次从LruCache 读取的缓存都要添加到ActiveResources里面，因为读取就表示需要显示。

  private final MemoryCache cache;

  private EngineResource<?> getEngineResourceFromCache(Key key) {
    Resource<?> cached = cache.remove(key);

    final EngineResource<?> result;
    if (cached == null) {
      result = null;
    } else if (cached instanceof EngineResource) {
      // Save an object allocation if we've cached an EngineResource (the typical case).
      result = (EngineResource<?>) cached;
    } else {
      result =
          new EngineResource<>(
              cached, /*isMemoryCacheable=*/ true, /*isRecyclable=*/ true, key, /*listener=*/ this);
    }
    return result;
  }

在这里插入图片描述

在这里插入图片描述

这里主要是通过cache.获取缓存的图片。

LruCache

Map<T, Y> cache = new LinkedHashMap<>(100, 0.75f, true);
  @Nullable
  public synchronized Y remove(@NonNull T key) {
    final Y value = cache.remove(key);
    if (value != null) {
      currentSize -= getSize(value);
    }
    return value;
  }

此处的cache 是一个LinkedHashMap，LinkedHashMap 本身实现了Lru算法，有不了解的同学可以自行查询，这里不做介绍。

三 磁盘缓存

在Glide中磁盘缓存默认使用的也是LRU（Least Recently Used）算法。如果你想使用其他的缓存算法，就只能通过实现DiskCache接口来完成了。

在这里插入图片描述

在创建Glide 的时候会使用一个默认的DiskLruCacheFactory 来创建对应的DiskLruCache

InternalCacheDiskCacheFactory

在这里插入图片描述

  public static DiskCache create(File directory, long maxSize) {
    return new DiskLruCacheWrapper(directory, maxSize);
  }

最终创建的对象是DiskLruCacheWrapper

  protected DiskLruCacheWrapper(File directory, long maxSize) {
//缓存的目录
    this.directory = directory;
//缓存的大小
    this.maxSize = maxSize;
    this.safeKeyGenerator = new SafeKeyGenerator();
  }

  private synchronized DiskLruCache getDiskCache() throws IOException {
    if (diskLruCache == null) {
      diskLruCache = DiskLruCache.open(directory, APP_VERSION, 
VALUE_COUNT, maxSize);
    }
    return diskLruCache;
  }

  @Override
  public File get(Key key) {
  //获取文件的名字
    String safeKey = safeKeyGenerator.getSafeKey(key);
    File result = null;
    try {
     
      final DiskLruCache.Value value = getDiskCache().get(safeKey);
      if (value != null) {
      //获取对应的文件
        result = value.getFile(0);
      }
    } catch (IOException e) {
      if (Log.isLoggable(TAG, Log.WARN)) {
        Log.w(TAG, "Unable to get from disk cache", e);
      }
    }
    return result;
  }

  @Override
  public void put(Key key, Writer writer) {
//生成key
    String safeKey = safeKeyGenerator.getSafeKey(key);
//获取锁
    writeLocker.acquire(safeKey);
    try {
      try {

        DiskLruCache diskCache = getDiskCache();
        Value current = diskCache.get(safeKey);
        if (current != null) {
          return;
        }

        DiskLruCache.Editor editor = diskCache.edit(safeKey);
        if (editor == null) {
          throw new IllegalStateException(
"Had two simultaneous puts for: " + safeKey);
        }
        try {
          File file = editor.getFile(0);
          if (writer.write(file)) {
            editor.commit();
          }
        } finally {
          editor.abortUnlessCommitted();
        }
      } catch (IOException e) {
      }
    } finally {
//释放锁
      writeLocker.release(safeKey);
    }
  }

  @Override
  public void delete(Key key) {
    String safeKey = safeKeyGenerator.getSafeKey(key);
    try {
      getDiskCache().remove(safeKey);
    } catch (IOException e) {
      if (Log.isLoggable(TAG, Log.WARN)) {
        Log.w(TAG, "Unable to delete from disk cache", e);
      }
    }
  }

}

这里在参数key的基础上再调用了safeKeyGenerator.getSafeKey()生成safeKey 这个safeKey 就是文件的名字，然后采用了Lock机制，获取锁，进行缓存操作，在finally中释放锁。

这里对文件的缓存使用的也是DiskLruCache，DiskLruCache 是一个有名的磁盘缓存矿建，在OkHttp 里面也使用到了这个框架。有不了解这个框架的可以查阅一下相关资料也可以看我之前写的一篇文章。

获取获取的调用时机我们已经知道，下面我们看看保存缓存文件的时机。

3.1 缓存图片原文件

前面介绍过Glide 通过SourceGenerator下载图片，当图片下载之后会调用cacheData

  @Override
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());
    originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());
    //缓存文件
    helper.getDiskCache().put(originalKey, writer);
  } finally {
    loadData.fetcher.cleanup();
  }

  sourceCacheGenerator =
      new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
}

这里的dataToCache是个InputStream，其中调用helper.getSourceEncoder(dataToCache)获取Encoder对象，

<X> Encoder<X> getSourceEncoder(X data) throws Registry.NoSourceEncoderAvailableException {
  return glideContext.getRegistry().getSourceEncoder(data);
}

获取一个Encoder将 InputStream转换为图片，这里实际对应的是StreamEncoder
在这里插入图片描述

得到Encoder解码器后，包装为一个DataCacheWriter，最后调用put方法进行缓存。

我们看到DiskLruCacheWrapper的put方法

  public void put(Key key, Writer writer) {
   //生成文件名
    String safeKey = safeKeyGenerator.getSafeKey(key);
    writeLocker.acquire(safeKey);
    try {

      try {
        DiskLruCache diskCache = getDiskCache();
        Value current = diskCache.get(safeKey);
        if (current != null) {
          return;
        }

        DiskLruCache.Editor editor = diskCache.edit(safeKey);
        if (editor == null) {
          throw new IllegalStateException("Had two simultaneous puts for: " + safeKey);
        }
        try {
          File file = editor.getFile(0);
          .//保存文件
          if (writer.write(file)) {
            editor.commit();
          }
        } finally {
          editor.abortUnlessCommitted();
        }
      } catch (IOException e) {
      }
    } finally {
      writeLocker.release(safeKey);
    }
  }

这里主要是通过writer.write(file) 来保存对应的文件，writer是DataCacheWriter

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

  @Override
  public boolean write(@NonNull File file) {
    return encoder.encode(data, file, options);
  }
}

encoder 的实际为StreamEncoder。

  @Override
  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 {
      if (os != null) {
        try {
          os.close();
        } catch (IOException e) {
          // Do nothing.
        }
      }
      byteArrayPool.put(buffer);
    }
    return success;
  }
}

很简单，就是文件的读写而已~~

以上介绍的是缓存的图片源文件，下面我们看看对图片转换后的缓存

3.2 缓存转换后的图片

这一部分在DecodeJob 里面，当下载图片并执行完图片转换之后会执行到DecodeJob 的decodeFromRetrievedData 方法
在这里插入图片描述

decodeFromRetrievedData 最终归会调用到DeferredEncodeManager 的encode 方法

在这里插入图片描述

     diskCacheProvider
            .getDiskCache()
            .put(key, new DataCacheWriter<>(encoder, toEncode, options));

通过DiskCache 的put方法缓存图片，put 方法在上面有源码。
这里的encoder 一般是BitmapDrawableDecoder
在这里插入图片描述
在这里插入图片描述

  public boolean encode(
      @NonNull Resource<BitmapDrawable> data, @NonNull File file, @NonNull Options options) {
    return encoder.encode(new BitmapResource(data.get().getBitmap(), bitmapPool), file, options);
  }
``
BitmapDrawableEncoder 调用了BitmapEncoder`的encode

```java
  @Override
  public boolean encode(
      @NonNull Resource<Bitmap> resource, @NonNull File file, @NonNull Options options) {
    final Bitmap bitmap = resource.get();
    Bitmap.CompressFormat format = getFormat(bitmap, options);
    try {
      long start = LogTime.getLogTime();
      int quality = options.get(COMPRESSION_QUALITY);

      boolean success = false;
      OutputStream os = null;
      try {
        os = new FileOutputStream(file);
        if (arrayPool != null) {
          os = new BufferedOutputStream(os, arrayPool);
        }
        //将图片保存的文件里面去
        bitmap.compress(format, quality, os);
        os.close();
        success = true;
      } catch (IOException e) {
 
      } finally {
        if (os != null) {
          try {
            os.close();
          } catch (IOException e) {
            // Do nothing.
          }
        }
      }

      }
      return success;
    } finally {
      GlideTrace.endSection();
    }
  }

可以看到最终通过 bitmap.compress(format, quality, os); 将图片保存到对应的文件里面去

昨夜西风在吹
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Glide】在RecyclerView的Adapter中使用DiskCacheStrategy.DATA优化内存占用
资深全栈开发工程师
06-12 1691
如果 PNG 图片的大小很小，可以考虑使用 VectorDrawable 来显示图片，它不会占用过多的内存，并且可以自动适应不同的分辨率。这里将 PNG 图片加载到 ViewHolder 中，并在 onBindViewHolder() 方法中复用同一个 Bitmap 对象，避免重复加载和创建多个 Bitmap 对象。总之，使用 Glide 加载 XML 的背景时，可以通过控制图片大小、使用缓存机制、复用同一个 PNG 图片和使用 VectorDrawable 等方式来减小内存占用。
Glide3.7使用diskCacheStrategy加载图片失败的问题
每一件自己觉得值得的事都要不留余力的去做
12-11 8369
1.加载代码： Glide.with(mContext) .load(videoThumbUrl) .error(R.drawable.error) .transform(new CenterCrop(mContext),new GlideRoundTransform(mCon...
Glide使用总结(2)
最新发布
2401_84408734的博客
05-05 818
看到这篇文章的人不知道有多少是和我一样的Android程序员。35岁，这是我们这个行业普遍的失业高发阶段，这种情况下如果还不提升自己的技能，进阶发展，我想，很可能就是本行业的职业生涯的终点了。我们要有危机意识，切莫等到一切都成定局时才开始追悔莫及。只要有规划的，有系统地学习，进阶提升自己并不难，给自己多充一点电，你才能走的更远。千里之行始于足下。这是上小学时，那种一元钱一个的日记本上每一页下面都印刷有的一句话，当时只觉得这句话很短，后来渐渐长大才慢慢明白这句话的真正的含义。
深入探究Glide的缓存机制
郭霖
05-23 1770
亲自执笔，带你学习Glide缓存的基本用法，源码实现，以及高级技巧。
Android-图片加载框架-Glide-4-9-0-(二)-切入源码层深入分析-Glide-缓存策略
m0_64603929的博客
12-16 2148
class EngineKey implements Key { … @Override public boolean equals(Object o) { if (o instanceof EngineKey) { EngineKey other = (EngineKey) o; return model.equals(other.model) && signature.equals(other.signature) && height == other.height &a
android Glide 获取磁盘缓存
热门推荐
lbcab的博客
10-13 1万+
Glide是Google推荐的图片加载库, 加载图片一般以下面的形式:Glide.with(context).load(ImgUrl) ..asBitmap() .error(R.drawable.error) .placeholder(R.drawable.loading) .dontAnimate() .diskCacheStrateg
Android中Glide获取缓存大小并清除缓存图片
08-30
Android中Glide获取缓存大小并清除缓存图片是 Android 开发中一个重要的知识点，了解 Glide 获取缓存大小并清除缓存图片可以帮助开发者更好地管理应用程序的缓存，避免缓存过大占用太多的存储空间。下面将详细介绍 ...
Android图片缓存之初识Glide（三）
09-01
在Android开发中，图片缓存是一项重要的技术，用于优化用户界面的性能，减少网络请求，提升用户体验。Glide是一款由Google员工开发并推荐的开源图片加载库，它为Android平台提供了高效、灵活的图片管理解决方案。...
浅谈Glide缓存key的问题
08-27
但是，在实际开发中，我们经常会遇到Glide缓存key的问题，本文将从Glide缓存key的生成机制、缓存key的影响因素、缓存key不一致的问题等方面详细介绍Glide缓存key的问题。 一、Glide缓存key的生成机制 Glide缓存key...
Glide 缓存策略 内存缓存和磁盘缓存
尽此依报身，同生极乐国。
06-17 2141
感恩原创：http://www.cnblogs.com/baiqiantao/p/6808457.htmlGlide 缓存策略 内存缓存和磁盘缓存 官方文档：https://github.com/bumptech/glide/wiki/Caching-and-Cache-Invalidation本文主要介绍了如何配置和管理Glide中的缓存，其中大部分内容都可以直接在官方Wiki中找到，这里只是进
Android 浅析Glide三级缓存
Pumpkin's Blog
05-08 2247
Android 简要分析Glide三级缓存 概括 Glide version is 4.8.0 Glide拥有三级缓存，分别为 当前正在使用得资源缓存（ActiveResources） 内存缓存（LruCache） 磁盘缓存（DiskLruCache） LRU（Lest Resently Used）算法，在内存缓存和磁盘缓存中均有用得到，笔者写过一篇Kotlin版本的LruCache的实现，感兴趣的可以查看。Kotlin LruCache 缓存读取 缓存大致分为两大部分，内存缓存与磁盘缓存，而内存缓
Android Glide图片加载-缓存机制（内存缓存和磁盘缓存）
吕氏春秋i
07-14 5371
前言 glide的缓存机制。Glide的缓存设计是非常的先进的，考虑的场景也很周全。Glide 的缓存分为两种，一是内存缓存，另一个是硬盘缓存。 这两种缓存的作用各不相同，内存缓存的主要作用是防止应用重复将图片数据读取到内存当中，而硬盘缓存的主要作用是防止应用重复从网络或其他地方重复下载和读取数据。 内存缓存 在默认情况下，Glide自动开启内存缓存的，我们也可以通过调用skipMemoryCache(true) 方法，禁用内存缓存 RequestOptions options = new RequestO
Glide缓存配置
weixin_33756418的博客
05-04 1131
Glide依赖 //这里用的是Android Studio3.0 implementation 'com.github.bumptech.glide:glide:4.3.1' annotationProcessor('com.github.bumptech.glide:compiler:4.3.1') imp...
Glide源码解析(3)—缓存加载机制
renzhongrui的博客
12-17 818
前言 在《Glide源码解析(1)—图片加载流程》一文中主要分析了Glide如何从网络下载并设置到ImageView上加载流程。 在《Glide源码解析(2)—Glide实例创建过程》一文中主要分析了Glide的创建流程，包括内存缓存和磁盘缓存的初始化。 其中缓存加载机制并没有过多分析，本文就专门分析一下Glide中缓存的加载流程是如何设计的。 设置缓存 Glide.with(this) .load("https://url") .diskCacheStrategy(DiskCacheStr
Glide源码阅读之策略模式1【DiskCacheStrategy】
lichong951的专栏
01-10 3382
策略模式意图把业务和算法解耦，不同场景下使用不同的算法模型适应更多更广泛的需求场景
Glide入门教程——7. 缓存基础
苏白的专栏
09-13 1021
Glide — 缓存基础 原文：Caching Basics 作者：Norman Peitek 翻译：Dexter0218 我们学习完了加载、显示和处理图片，我们将会向前推进学习优化处理。一个成功的高效的图片加载的基本功能是缓存。这篇文章将学习Glide中的缓存的基础知识。 文／签到钱就到（简书作者） 原文链接：http://www.jianshu.com/p/f5cc
Glide 缓存机制源码解读
number_cmd9的博客
09-12 314
Glide 缓存机制 对于Glide的来说，强大的缓存机制一直是其受欢迎的重要前提，那么Glide缓存机制具体是什么呢，而其实现的原理又是什么呢？这篇文章将在源码层面对Glide缓存机制进行剖析，对Glide有更深层次的了解，那么就直接步入主题吧！ 本文章基于Glide 4.11.0 版本 缓存机制 谈到缓存机制，我们常常会想到在Android中的一个缓存流程，也就是三级缓存： 内存缓存：优先加载，速度最快 本地缓存：次优先加载，速度快 网络缓存：最后加载，速度慢，需要网络 正常情况下，我们都会对于
Android 玩转Glide4---缓存篇
DeMonnnnnn
03-23 8414
前言 系列文章专栏： 玩转Glide4 概述 加载相同的网络资源的时候，为了减少流量开销，优化加载速度，我们一般都会选择使用缓存。 Glide作为最优秀的图片加载库，广受大家认可，必然也有着十分优秀的缓存机制。 Glide缓存基于LRU原理实现了两种缓存： 内存缓存MemoryCache 硬盘缓存DiskCache Glide是默认同时开启这两种缓存的。 内存缓存MemoryCache 基于LRU的缓存驱逐算法实现。 默认开启，也可以调用skipMemoryCache(boolean skip)开启或者
glide如何实现图片去重的
05-18
Glide可以使用DiskCacheStrategy来实现图片去重，DiskCacheStrategy有四种不同的枚举类型： 1. DiskCacheStrategy.ALL：缓存源资源和转换后的资源 2. DiskCacheStrategy.NONE：不在磁盘缓存任何内容 3. DiskCacheStrategy.DATA：只缓存原始图片 4. DiskCacheStrategy.RESOURCE：只缓存转换过后的图片 其中，如果使用DiskCacheStrategy.RESOURCE作为缓存策略，Glide会根据图片的URL地址生成一个唯一的缓存Key，并将这个Key保存到磁盘缓存中。下次请求同一URL的图片时，Glide会先从磁盘缓存中查找是否已经缓存了该图片，如果已经缓存了，则直接读取缓存中的图片数据，否则再去请求网络获取图片。 所以，使用DiskCacheStrategy.RESOURCE可以实现图片去重，避免同一张图片重复加载和缓存。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值