Glide源码学习笔记六：磁盘缓存实现

最新推荐文章于 2024-03-14 17:21:25 发布
最新推荐文章于 2024-03-14 17:21:25 发布
阅读量351 收藏
点赞数
分类专栏： Glide学习笔记 文章标签： 缓存 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuyuzhou_/article/details/125701744
版权

Glide源码学习笔记六：磁盘缓存实现

文章目录

前言

上一章Glide源码学习笔记五：磁盘缓存分析获取磁盘缓存的一些逻辑。在DecodeJob.getNextGenerator()方法中，构建了三种磁盘资源获取方式，这三种方法的实现类都实现了DataFetcherGenerator（资源获取生成器）接口，触发资源获取的方法为DataFetcherGenerator.startNext(),接下来通过分析ResourceCacheGenerator，DataCacheGenerator，SourceGenerator这三个类是实现startNext方法来学习磁盘资源的实现。

在这里帮大家回忆一下这三个类的构建条件：

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

以上三个加载器是顺序遍历的，为了便于理解，我们从最后一个开始倒叙分析，因为一开始肯定是没有缓存的。

SourceGenerator.startNext()

 @Override
  public boolean startNext() {
    //如果有缓存，就直接返回缓存
    if (dataToCache != null) {
      Object data = dataToCache;
      dataToCache = null;
      try {
        boolean isDataInCache = cacheData(data);
        if (!isDataInCache) {
          return true;
        }
      }
      }
    }

    if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
      return true;
    }
    sourceCacheGenerator = null;

    loadData = null;
    boolean started = false;
    //没有缓存，开始下载
    while (!started && hasNextModelLoader()) {
      loadData = helper.getLoadData().get(loadDataListIndex++);
      //loadData不为空并且支持缓存或者有loadpath，就开始下载
      if (loadData != null
          && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
              || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {
        started = true;
        startNextLoad(loadData);
      }
    }
    return started;
  }

代码中有几个类很眼生，先简单介绍一下：
1.ModelLoader:模块加载器
2.SourceGenerator:实现了DataFetcherGenerator接口，资源生成器
3.DataFetcher：数据抓取
4.LoadData：数据加载
5.LoadPath：加载器可能会有多个LoadPath
6.DecodePath：解码
简单来说，SourceGenerator是一个DataFetcher的生成器，ResourceCacheGenerator和DataCacheGenerator也是。
DataFetcher是一个数据抓取器，存放在LoadData中，而LoadData是在ModelLoader中构造的，以上2 ~ 4构成了Glide数据的转换与获取，5 ~ 6构成Glide的解码过程。

先来分析LoadData是怎么来的。

getLoadData()

  List<LoadData<?>> getLoadData() {
    //标志位判断，loadData是否设置过
    if (!isLoadDataSet) {
      isLoadDataSet = true;
      loadData.clear();
      //获取modelLoaders 
      List<ModelLoader<Object, ?>> modelLoaders = glideContext.getRegistry().getModelLoaders(model);
      //从modelLoaders中获取数据构造loadData
      for (int i = 0, size = modelLoaders.size(); i < size; i++) {
        ModelLoader<Object, ?> modelLoader = modelLoaders.get(i);
        //构造LoadData
        LoadData<?> current = modelLoader.buildLoadData(model, width, height, options);
        if (current != null) {
          loadData.add(current);
        }
      }
    }
    return loadData;
  }

这里有一个modelLoaders比较关键，这个地方也是之前遗漏没有说过的Glide初始化步骤，
在这里打一个补丁：
glideContext.getRegistry()返回的是一个Registry类，注册。在Glide的构造方法中，除了给Engine，MemoryCache等等一些变量赋值，代码最多的就是这个Registry相关的方法，在这里就把源码po上来了，大家感受一下。

 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 RequestOptionsFactory defaultRequestOptionsFactory,
      @NonNull Map<Class<?>, TransitionOptions<?, ?>> defaultTransitionOptions,
      @NonNull List<RequestListener<Object>> defaultRequestListeners,
      GlideExperiments experiments) {
    this.engine = engine;
    this.bitmapPool = bitmapPool;
    this.arrayPool = arrayPool;
    this.memoryCache = memoryCache;
    this.requestManagerRetriever = requestManagerRetriever;
    this.connectivityMonitorFactory = connectivityMonitorFactory;
    this.defaultRequestOptionsFactory = defaultRequestOptionsFactory;

    final Resources resources = context.getResources();

    registry = new Registry();
    registry.register(new DefaultImageHeaderParser());
    // Right now we're only using this parser for HEIF images, which are only supported on OMR1+.
    // If we need this for other file types, we should consider removing this restriction.
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
      registry.register(new ExifInterfaceImageHeaderParser());
    }

    List<ImageHeaderParser> imageHeaderParsers = registry.getImageHeaderParsers();

    ByteBufferGifDecoder byteBufferGifDecoder =
        new ByteBufferGifDecoder(context, imageHeaderParsers, bitmapPool, arrayPool);
    ResourceDecoder<ParcelFileDescriptor, Bitmap> parcelFileDescriptorVideoDecoder =
        VideoDecoder.parcel(bitmapPool);

    // TODO(judds): Make ParcelFileDescriptorBitmapDecoder work with ImageDecoder.
    Downsampler downsampler =
        new Downsampler(
            registry.getImageHeaderParsers(), resources.getDisplayMetrics(), bitmapPool, arrayPool);

    ResourceDecoder<ByteBuffer, Bitmap> byteBufferBitmapDecoder;
    ResourceDecoder<InputStream, Bitmap> streamBitmapDecoder;
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
        && experiments.isEnabled(EnableImageDecoderForBitmaps.class)) {
      streamBitmapDecoder = new InputStreamBitmapImageDecoderResourceDecoder();
      byteBufferBitmapDecoder = new ByteBufferBitmapImageDecoderResourceDecoder();
    } else {
      byteBufferBitmapDecoder = new ByteBufferBitmapDecoder(downsampler);
      streamBitmapDecoder = new StreamBitmapDecoder(downsampler, arrayPool);
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
        && experiments.isEnabled(EnableImageDecoderForAnimatedWebp.class)) {
      registry.append(
          Registry.BUCKET_ANIMATION,
          InputStream.class,
          Drawable.class,
          AnimatedWebpDecoder.streamDecoder(imageHeaderParsers, arrayPool));
      registry.append(
          Registry.BUCKET_ANIMATION,
          ByteBuffer.class,
          Drawable.class,
          AnimatedWebpDecoder.byteBufferDecoder(imageHeaderParsers, arrayPool));
    }

    ResourceDrawableDecoder resourceDrawableDecoder = new ResourceDrawableDecoder(context);
    ResourceLoader.StreamFactory resourceLoaderStreamFactory =
        new ResourceLoader.StreamFactory(resources);
    ResourceLoader.UriFactory resourceLoaderUriFactory = new ResourceLoader.UriFactory(resources);
    ResourceLoader.FileDescriptorFactory resourceLoaderFileDescriptorFactory =
        new ResourceLoader.FileDescriptorFactory(resources);
    ResourceLoader.AssetFileDescriptorFactory resourceLoaderAssetFileDescriptorFactory =
        new ResourceLoader.AssetFileDescriptorFactory(resources);
    BitmapEncoder bitmapEncoder = new BitmapEncoder(arrayPool);

    BitmapBytesTranscoder bitmapBytesTranscoder = new BitmapBytesTranscoder();
    GifDrawableBytesTranscoder gifDrawableBytesTranscoder = new GifDrawableBytesTranscoder();

    ContentResolver contentResolver = context.getContentResolver();

    registry
        .append(ByteBuffer.class, new ByteBufferEncoder())
        .append(InputStream.class, new StreamEncoder(arrayPool))
        /* Bitmaps */
        .append(Registry.BUCKET_BITMAP, ByteBuffer.class, Bitmap.class, byteBufferBitmapDecoder)
        .append(Registry.BUCKET_BITMAP, InputStream.class, Bitmap.class, streamBitmapDecoder);

    if (ParcelFileDescriptorRewinder.isSupported()) {
      registry.append(
          Registry.BUCKET_BITMAP,
          ParcelFileDescriptor.class,
          Bitmap.class,
          new ParcelFileDescriptorBitmapDecoder(downsampler));
    }

    registry
        .append(
            Registry.BUCKET_BITMAP,
            ParcelFileDescriptor.class,
            Bitmap.class,
            parcelFileDescriptorVideoDecoder)
        .append(
            Registry.BUCKET_BITMAP,
            AssetFileDescriptor.class,
            Bitmap.class,
            VideoDecoder.asset(bitmapPool))
        .append(Bitmap.class, Bitmap.class, UnitModelLoader.Factory.<Bitmap>getInstance())
        .append(Registry.BUCKET_BITMAP, Bitmap.class, Bitmap.class, new UnitBitmapDecoder())
        .append(Bitmap.class, bitmapEncoder)
        /* BitmapDrawables */
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            ByteBuffer.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, byteBufferBitmapDecoder))
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            InputStream.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, streamBitmapDecoder))
        .append(
            Registry.BUCKET_BITMAP_DRAWABLE,
            ParcelFileDescriptor.class,
            BitmapDrawable.class,
            new BitmapDrawableDecoder<>(resources, parcelFileDescriptorVideoDecoder))
        .append(BitmapDrawable.class, new BitmapDrawableEncoder(bitmapPool, bitmapEncoder))
        /* GIFs */
        .append(
            Registry.BUCKET_ANIMATION,
            InputStream.class,
            GifDrawable.class,
            new StreamGifDecoder(imageHeaderParsers, byteBufferGifDecoder, arrayPool))
        .append(
            Registry.BUCKET_ANIMATION, ByteBuffer.class, GifDrawable.class, byteBufferGifDecoder)
        .append(GifDrawable.class, new GifDrawableEncoder())
        /* GIF Frames */
        // Compilation with Gradle requires the type to be specified for UnitModelLoader here.
        .append(
            GifDecoder.class, GifDecoder.class, UnitModelLoader.Factory.<GifDecoder>getInstance())
        .append(
            Registry.BUCKET_BITMAP,
            GifDecoder.class,
            Bitmap.class,
            new GifFrameResourceDecoder(bitmapPool))
        /* Drawables */
        .append(Uri.class, Drawable.class, resourceDrawableDecoder)
        .append(
            Uri.class, Bitmap.class, new ResourceBitmapDecoder(resourceDrawableDecoder, bitmapPool))
        /* Files */
        .register(new ByteBufferRewinder.Factory())
        .append(File.class, ByteBuffer.class, new ByteBufferFileLoader.Factory())
        .append(File.class, InputStream.class, new FileLoader.StreamFactory())
        .append(File.class, File.class, new FileDecoder())
        .append(File.class, ParcelFileDescriptor.class, new FileLoader.FileDescriptorFactory())
        // Compilation with Gradle requires the type to be specified for UnitModelLoader here.
        .append(File.class, File.class, UnitModelLoader.Factory.<File>getInstance())
        /* Models */
        .register(new InputStreamRewinder.Factory(arrayPool));

    if (ParcelFileDescriptorRewinder.isSupported()) {
      registry.register(new ParcelFileDescriptorRewinder.Factory());
    }

    registry
        .append(int.class, InputStream.class, resourceLoaderStreamFactory)
        .append(int.class, ParcelFileDescriptor.class, resourceLoaderFileDescriptorFactory)
        .append(Integer.class, InputStream.class, resourceLoaderStreamFactory)
        .append(Integer.class, ParcelFileDescriptor.class, resourceLoaderFileDescriptorFactory)
        .append(Integer.class, Uri.class, resourceLoaderUriFactory)
        .append(int.class, AssetFileDescriptor.class, resourceLoaderAssetFileDescriptorFactory)
        .append(Integer.class, AssetFileDescriptor.class, resourceLoaderAssetFileDescriptorFactory)
        .append(int.class, Uri.class, resourceLoaderUriFactory)
        .append(String.class, InputStream.class, new DataUrlLoader.StreamFactory<String>())
        .append(Uri.class, InputStream.class, new DataUrlLoader.StreamFactory<Uri>())
        .append(String.class, InputStream.class, new StringLoader.StreamFactory())
        .append(String.class, ParcelFileDescriptor.class, new StringLoader.FileDescriptorFactory())
        .append(
            String.class, AssetFileDescriptor.class, new StringLoader.AssetFileDescriptorFactory())
        .append(Uri.class, InputStream.class, new AssetUriLoader.StreamFactory(context.getAssets()))
        .append(
            Uri.class,
            AssetFileDescriptor.class,
            new AssetUriLoader.FileDescriptorFactory(context.getAssets()))
        .append(Uri.class, InputStream.class, new MediaStoreImageThumbLoader.Factory(context))
        .append(Uri.class, InputStream.class, new MediaStoreVideoThumbLoader.Factory(context));
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
      registry.append(
          Uri.class, InputStream.class, new QMediaStoreUriLoader.InputStreamFactory(context));
      registry.append(
          Uri.class,
          ParcelFileDescriptor.class,
          new QMediaStoreUriLoader.FileDescriptorFactory(context));
    }
    registry
        .append(Uri.class, InputStream.class, new UriLoader.StreamFactory(contentResolver))
        .append(
            Uri.class,
            ParcelFileDescriptor.class,
            new UriLoader.FileDescriptorFactory(contentResolver))
        .append(
            Uri.class,
            AssetFileDescriptor.class,
            new UriLoader.AssetFileDescriptorFactory(contentResolver))
        .append(Uri.class, InputStream.class, new UrlUriLoader.StreamFactory())
        .append(URL.class, InputStream.class, new UrlLoader.StreamFactory())
        .append(Uri.class, File.class, new MediaStoreFileLoader.Factory(context))
        .append(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory())
        .append(byte[].class, ByteBuffer.class, new ByteArrayLoader.ByteBufferFactory())
        .append(byte[].class, InputStream.class, new ByteArrayLoader.StreamFactory())
        .append(Uri.class, Uri.class, UnitModelLoader.Factory.<Uri>getInstance())
        .append(Drawable.class, Drawable.class, UnitModelLoader.Factory.<Drawable>getInstance())
        .append(Drawable.class, Drawable.class, new UnitDrawableDecoder())
        /* Transcoders */
        .register(Bitmap.class, BitmapDrawable.class, new BitmapDrawableTranscoder(resources))
        .register(Bitmap.class, byte[].class, bitmapBytesTranscoder)
        .register(
            Drawable.class,
            byte[].class,
            new DrawableBytesTranscoder(
                bitmapPool, bitmapBytesTranscoder, gifDrawableBytesTranscoder))
        .register(GifDrawable.class, byte[].class, gifDrawableBytesTranscoder);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
      ResourceDecoder<ByteBuffer, Bitmap> byteBufferVideoDecoder =
          VideoDecoder.byteBuffer(bitmapPool);
      registry.append(ByteBuffer.class, Bitmap.class, byteBufferVideoDecoder);
      registry.append(
          ByteBuffer.class,
          BitmapDrawable.class,
          new BitmapDrawableDecoder<>(resources, byteBufferVideoDecoder));
    }

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

在这里，registry的append方法虽然很多，但是都是有迹可循的。一句话总结就是，首先构建了不同的编码器和解码器，将各种类型对应的编码器和解码器。
Glide的加载，可以归纳为如下几个阶段：
model(数据源)–>data(转换数据)–>decode(解码)–>transformed(缩放)–>transcoded(转码)–>encoded(编码保存到本地)。
看完上面的代码，就可以理解为什么获取的LoadData是一个List了，举例传入的是一个String类型的Url，上面代码中就有针对这种情况的好几种解码器：

.append(String.class, InputStream.class, new DataUrlLoader.StreamFactory<String>())
.append(String.class, InputStream.class, new StringLoader.StreamFactory())
.......
.......

而这个append方法，就是添加到ModelLoaders中去。
再看看modelLoader.buildLoadData是如何构建LoadData的。

modelLoader.buildLoadData(还是以Model是String类型的Url举例)

  //StringLoader
  @Override
  public LoadData<Data> buildLoadData(
      @NonNull String model, int width, int height, @NonNull Options options) {
    //将String转成Uri
    Uri uri = parseUri(model);
    if (uri == null || !uriLoader.handles(uri)) {
      return null;
    }
    return uriLoader.buildLoadData(uri, width, height, options);
  }

  //HttpGlideUrlLoader
  @Override
  public LoadData<InputStream> buildLoadData(
      @NonNull GlideUrl model, int width, int height, @NonNull Options options) {
    // GlideUrls memoize parsed URLs so caching them saves a few object instantiations and time
    // spent parsing urls.
    GlideUrl url = model;
    if (modelCache != null) {
      url = modelCache.get(model, 0, 0);
      if (url == null) {
        modelCache.put(model, 0, 0, model);
        url = model;
      }
    }
    int timeout = options.get(TIMEOUT);
    //新建一个HttpUrlFetcher类型的DataFetcher
    return new LoadData<>(url, new HttpUrlFetcher(url, timeout));
  }

buildLoadData就是根据各种情况，在这里Model是String，对应的DataFetcher就是HttpUrlFetcher。
在这里，就已经构造出LoadData了，现在就可以开始下载新资源。再回到SourceGenerator的startNextLoad方法中，开始下载！

startNextLoad()

 private void startNextLoad(final LoadData<?> toStart) {
    loadData.fetcher.loadData(
        helper.getPriority(),
        new DataCallback<Object>() {
          @Override
          public void onDataReady(@Nullable Object data) {
            if (isCurrentRequest(toStart)) {
              onDataReadyInternal(toStart, data);
            }
          }

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

这里的代码很简单，DataFetch调用loadData方法之后，在回调中处理成功或失败的情况。如果下载成功，回通过一个很长的回调，将资源缓存到内存缓存的activeResources中。、

DataCacheGenerator和ResourceCacheGenerator的原理与SourceGenerator基本是一致的，只不过一个用来加载原始的本地缓存图，另一个用来加载处理过的本地缓存。在这里就不分析了。

总结

这是Glide系列的最后一篇文章，解码和下载过程就省略了。
这是我第一次写博客，肯定有许多不足，希望大家帮我提一点意见，多交流交流，感谢！
这个是我总结的整个Glide加载流程，请点击大图查看。
请添加图片描述

Lyzhouxxx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Glide 4.12图片框架之多级缓存源码设计分析
HYM BLOG
12-28 928
一、Glide缓存初识 在上两篇文章中，我们从源码角度分析Glide框架加载图片的流程、以及Glide图片通过巧妙的空view的Fragment的设计实现的Glide的图片加载的三大生命周期函数onStart、onStop、onDestroy。Glide的框架的源码量确实比较大，今天我们再详细分析一下，Glide的框架的缓存模块的设计。 默认情况下，Glide 会在开始一个新的图片请求之前检查以下多级的缓存： 活动资源 (Active Resources) - 现在是否有另一个 View 正在展示这张图片
android Glide 获取磁盘缓存
lbcab的博客
10-13 1万+
Glide是Google推荐的图片加载库, 加载图片一般以下面的形式:Glide.with(context).load(ImgUrl) ..asBitmap() .error(R.drawable.error) .placeholder(R.drawable.loading) .dontAnimate() .diskCacheStrateg
关于Glide磁盘缓存问题
最新发布
Ai_wen_的博客
03-14 1025
了解 Glide 的缓存分层结构，及与 Request 是如何关联的。了解缓存的查询流程，特别是要注意优先查询第二层内存缓存。了解缓存的保存逻辑。第二层内存缓存 -> 第一次内存缓存第五层数据源缓存 -> 第四层磁盘缓存 -> 第一次内存缓存第四层磁盘缓存 -> 第三层磁盘缓存 -> 第一次内存缓存了解缓存查询相关类的关联关系，及其作用。了解缓存的数据变换操作 (ResourceTranscoder)。
Glide系列(一) — Glide 框架结构浅析
Elson的博客
06-08 2万+
Glide 是一个图片加载库，跟它同类型的库还有 Picasso、Fresco、Universal-Image-Loader 等。 Glide 框架的优点如下： 1. 加载类型多样化：Glide 支持 Gif、WebP 等格式的图片。 2. 生命周期的绑定：图片请求与页面生命周期绑定，避免内存泄漏。 3. 高效的缓存策略： 1. 支持多种缓存策略 (Memory 和 Disk 图片缓存)。 2. 根据 ImageView 的大小来加载相应大小的图片尺寸。 3. 内存开销小。
Glide缓存机制
xingyu19911016的博客
06-24 5384
当使用加载图片时，会默认根据视图对图片进行压缩和转换，而不显示原始图。（这也是加载速度高于的原因）的缓存功能设计成二级缓存：内存缓存和硬盘缓存。（从网络加载不属于缓存）在中，缓存的读取顺序为：，内存缓存和磁盘缓存相互不影响，独立配置，内存缓存是默认开启的。的缓存机制使得具备非常好的图片缓存效果，从而使得具备较高的图片加载效率。以下是的相关代码： 2.3 缓存类型 活动缓存（）：存储正在使用的图片； 内存缓存（）：图片解析完成后并最近被加载过会放到内存中； 磁盘缓存-资源类型（）：被解码后的图片写入磁盘文件
Glide4.9.0 ResourceCacheGenerator 源码解析
DemoKiller的博客
03-19 486
一、作用 /** * Generates {@link com.bumptech.glide.load.data.DataFetcher DataFetchers} from cache files * containing downsampled/transformed resource data. */ 根据官方注释，关键词downsampled/transformed，就是我们获取到...
Android中Glide加载图片并实现图片缓存
08-31
Android 中 Glide 加载图片并实现图片缓存 Android 中 Glide 加载图片并实现图片缓存是 Android 开发中非常重要的一部分，今天我们将详细介绍 Glide 的使用方法以及缓存机制。 首先，Glide 是 Github 上开源的一个...
Android中Glide获取缓存大小并清除缓存图片
08-30
Android中Glide获取缓存大小并清除缓存图片是 Android 开发中一个重要的知识点，了解 Glide 获取缓存大小并清除缓存图片可以帮助开发者更好地管理应用程序的缓存，避免缓存过大占用太多的存储空间。下面将详细介绍 ...
浅谈Glide缓存key的问题
08-27
但是，在实际开发中，我们经常会遇到Glide缓存key的问题，本文将从Glide缓存key的生成机制、缓存key的影响因素、缓存key不一致的问题等方面详细介绍Glide缓存key的问题。 一、Glide缓存key的生成机制 Glide缓存key...
Glide 缓存策略 内存缓存和磁盘缓存
尽此依报身，同生极乐国。
06-17 2155
感恩原创：http://www.cnblogs.com/baiqiantao/p/6808457.htmlGlide 缓存策略 内存缓存和磁盘缓存 官方文档：https://github.com/bumptech/glide/wiki/Caching-and-Cache-Invalidation本文主要介绍了如何配置和管理Glide中的缓存，其中大部分内容都可以直接在官方Wiki中找到，这里只是进
Glide-内存缓存与磁盘缓存
热门推荐
夏雨
02-14 3万+
前言:这一节我们将讲到Glide的内存缓存和磁盘缓存(网上流传的比较广的几篇文章都是直接从是一篇译文中拷贝过去的,那篇译文在许多地方都翻译错误了,其中很大的一个错误就是关于缓存一块的问题)Glide 系列目录 1.Glide-入门教程 2.Glide-占位图以及加载动画 3.Glide-加载本地图片 1.缓存的资源Glide的缓存资源分为两种: 1.原图(SOURCE) :原始图片 2.处理图(RE
Glide之DiskLruCache（三级磁盘缓存）
“点点”专栏
02-05 1537
阅读别人优秀的源码，才知道自己之前写的代码都是垃圾呀 在Glide里面好多对象都是通过工厂类生成的，DiskCache也是 先看GlideBuilder的build方法： @NonNull Glide build(@NonNull Context context) { if (sourceExecutor == null) { sourceExecutor =...
Android Glide获取缓存路径
yijiaodingqiankun的博客
07-02 3424
Glide 缓存工具例子，缓存大小获取，磁盘缓存清除(2 种方法)，内存缓存清除
未来很长，但我会努力的走下去。
08-25 976
Glide 缓存工具例子，缓存大小获取，磁盘缓存清除(2 种方法)，内存缓存清除
Glide之旅 —— DecodeJob
KZax1l的博客
02-28 1315
前言glide是谷歌推荐的Android图片加载框架，其优秀的缓存策略、Activity的生命周期的继承、GIF图片的支持等都是为人所称道的地方。下面是用glide加载一张图片的调用。private void loadImage() { Glide.with(this) .load("http://pic2.orsoon.com/2017/0118/201701180110
android glide 获取缓存图片
u012737144的专栏
03-08 1万+
Glide是Google推荐用的图片加载框架，很简单就可以加载出图片了，如下： Glide.with(context).load(ImgUrl).into(ImageView); 也可以加一些常用的功能，如placeHolder图片等等，如下： Glide.with(context).load(ImgUrl) .asBitmap() .error(R.drawable
Gilde获取Bitmap
阿Gogo
03-14 1万+
4.0以下：Bitmap myBitmap = Glide.with(applicationContext) .load(yourUrl) .asBitmap() .centerCrop() .into(Target.SIZE_ORIGINAL,Target.SIZE_ORIGINAL) .get() imageVie...
android获取图片bitmap,Android中Glide获取图片Path、Bitmap用法详解
weixin_30935475的博客
05-28 878
我们在此之前给大家介绍过图片加载框架Glide的基本用法介绍，大家可以先参考一下，本篇内容更加深入的分析了Glide获取图片Path、Bitmap用法，以及实现的代码分析。1. 获取Bitmap：1)在图片下载缓存好之后获取Glide.with(mContext).load(url).asBitmap().into(new SimpleTarget() {@Overridepublic void ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值