静默加载
静默加载

Glide源码阅读理解一小时

前言

这篇图、文、表、代码一起组成的 Glide 源码分析的文章是在上一篇文章 Android-Universal-Image-Loader源码分析 中之后的又一篇图片加载框架源码解析，它也具备了 ImageLoader 中讲述了Android一个图片加载库所需要的一些基础必备的：MemoryCahce、DiskCahce Decoder DownLoader 和Executor 等部分。这篇 Glide 的代码分析量可以说至少是 ImageLoader 的3倍多，本来想对 Glide 代码进行拆分，细化每个部分进行讲解这个每个部分讲的更加清楚一些。但最终还是打算整体一篇文章讲完，因为我觉得整体性的学习能更深的的了解到 Glide 的框架的设计之美。

本篇文章讲述的Glide 相关知识比较多，阅读完需要大量的时间。所以我们按需分配，根据目录寻找自己需要的知识点进行查看。

Glide介绍

Glide的Git地址：https://github.com/bumptech/glide

简体中文文档：https://muyangmin.github.io/glide-docs-cn/

Glide's documentation：https://bumptech.github.io/glide/

关于Glide

Glide是一个快速高效的Android图片加载库，注重于平滑的滚动。Glide提供了易用的API，高性能、可扩展的图片解码管道（decode pipeline），以及自动的资源池技术。

Glide 支持拉取，解码和展示视频快照，图片，和GIF动画。Glide的Api是如此的灵活，开发者甚至可以插入和替换成自己喜爱的任何网络栈。默认情况下，Glide使用的是一个定制化的基于HttpUrlConnection的栈，但同时也提供了与Google Volley和Square OkHttp快速集成的工具库。

虽然Glide 的主要目标是让任何形式的图片列表的滚动尽可能地变得更快、更平滑，但实际上，Glide几乎能满足你对远程图片的拉取/缩放/显示的一切需求。

Glide性能

Glide 充分考虑了Android图片加载性能的两个关键方面：

  • 图片解码速度
  • 解码图片带来的资源压力

为了让用户拥有良好的App使用体验，图片不仅要快速加载，而且还不能因为过多的主线程I/O或频繁的垃圾回收导致页面的闪烁和抖动现象。

Glide使用了多个步骤来确保在Android上加载图片尽可能的快速和平滑：

  • 自动、智能地下采样(downsampling)和缓存(caching)，以最小化存储开销和解码次数；
  • 积极的资源重用，例如字节数组和Bitmap，以最小化昂贵的垃圾回收和堆碎片影响；
  • 深度的生命周期集成，以确保仅优先处理活跃的Fragment和Activity的请求，并有利于应用在必要时释放资源以避免在后台时被杀掉。

GlideAPI

Glide 使用简明的流式语法API，这是一个非常棒的设计，因为它允许你在大部分情况下一行代码搞定需求：

Glide.with(fragment)
    .load(url)
    .into(imageView);

上述是Fragmeng中Glide将一张网络图片显示到ImageView的代码，下面源码分析的时候我们也会用这段代码进行分析，看看这么简单的API到底是怎么实现的。

Glide源码分析

我们学习和了解一些框架主要不是看它某个功能的具体实现，主要是学习框架结构搭建和框架中模块的设计与实现。当然每个人的对每个框架的理解都各不相同，不过没关系我们可以多学习多总结，慢慢培养我们自己的框架结构意识。这个在我们平时开发过程中对我们帮助非常大。

Glide源码阅读理解一小时_第1张图片
在这里插入图片描述

上图是对我Glide的一个总结^_^。

Glide接入

Glide的用法网上有很多文章讲述的都非常好，这里不再进行讲述。这块主要想通过Glide的配置来分析Glide的运行机制。

我们在使用Glide的时候都会使用注解@GlideModule 实现AppGlideModule 或者 GeneratedAppGlideModule ，生成一个类名为GeneratedAppGlideModuleImpl 它是Glide 模块的代理。 在GeneratedAppGlideModuleImpl 会包含我们自定义的GlideModel。

下面为我们接入项目的Glide配置：

实现Glide对缓存的配置

@GlideModule
public final class GlideModuleConfig extends AppGlideModule {
    @Override
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
        super.applyOptions(context, builder);
        long memoryCacheSizeBytes = 1024 * 1024 * 20;
        builder.setMemoryCache(new LruResourceCache(memoryCacheSizeBytes));
        long diskCacheSizeBytes = 1024 * 1024 * 100;
        builder.setDiskCache(new InternalCacheDiskCacheFactory(context, diskCacheSizeBytes));
    }
}

实现Okhttp的接入

@GlideModule
public final class OkHttpLibraryGlideModule extends LibraryGlideModule {
    @Override
    public void registerComponents(
            @NonNull Context context, @NonNull Glide glide, @NonNull Registry registry) {
        //将GlideUrl数据转为InputStream的ModelLoader替换为Okhttp
        registry.replace(GlideUrl.class, InputStream.class, new OkHttpUrlLoader.Factory());
    }
}

我们编译之后生成的GeneratedAppGlideModuleImpl：

final class GeneratedAppGlideModuleImpl extends GeneratedAppGlideModule {
    private final GlideModuleConfig appGlideModule;
    public GeneratedAppGlideModuleImpl(Context context) {
      appGlideModule = new GlideModuleConfig();
    }
    //GlideBuilder的配置项进行应用
    @Override
    public void applyOptions(@NonNull Context context, @NonNull GlideBuilder builder) {
      appGlideModule.applyOptions(context, builder);
    }
    //注册自定义GlideModule
    @Override
    public void registerComponents(@NonNull Context context, @NonNull Glide glide,
        @NonNull Registry registry) {
      new OkHttpLibraryGlideModule().registerComponents(context, glide, registry);
      appGlideModule.registerComponents(context, glide, registry);
    }
    /***部分代码省略***/
}

下面将GeneratedAppGlideModuleImpl的使用。

Glide初始化

public class Glide implements ComponentCallbacks2 {
    /**
    * Get the singleton.
    * @return the singleton
    */
    @NonNull
    public static Glide get(@NonNull Context context) {
        if (glide == null) {
            //
            GeneratedAppGlideModule annotationGeneratedModule = 
                getAnnotationGeneratedGlideModules(context.getApplicationContext());
            synchronized (Glide.class) {
                if (glide == null) {
                    checkAndInitializeGlide(context, annotationGeneratedModule);
                }
            }
        }
        return glide;
    }
    //通过Java反射机制获取通过注解生成的GeneratedAppGlideModuleImpl
    private static GeneratedAppGlideModule getAnnotationGeneratedGlideModules(Context context) {
        GeneratedAppGlideModule result = null;
        try {
        Class clazz =
            (Class)
                Class.forName("com.bumptech.glide.GeneratedAppGlideModuleImpl");
        result =
            clazz.getDeclaredConstructor(Context.class).newInstance(context.getApplicationContext());
        } catch (ClassNotFoundException e) {
        /***部分代码省略**/
        }
        return result;
    }
}

Glide是个单例，初始化的时候需要注解生成的GeneratedAppGlideModuleImpl 。

public class Glide implements ComponentCallbacks2 {
    @GuardedBy("Glide.class")
    private static void initializeGlide(
        @NonNull Context context, @Nullable GeneratedAppGlideModule generatedAppGlideModule) {
        initializeGlide(context, new GlideBuilder(), generatedAppGlideModule);
    }
    @GuardedBy("Glide.class")
    @SuppressWarnings("deprecation")
    private static void initializeGlide(
        @NonNull Context context,
        @NonNull GlideBuilder builder,
        @Nullable GeneratedAppGlideModule annotationGeneratedModule) {
        Context applicationContext = context.getApplicationContext();
        List manifestModules = Collections.emptyList();
        //如果Manifest文件中配置了GlideModule，并且annotationGeneratedModule允许Manifest文件中配置生效，那么需要解析出来
        if (annotationGeneratedModule == null || annotationGeneratedModule.isManifestParsingEnabled()) {
            manifestModules = new ManifestParser(applicationContext).parse();
        }
        //如果annotationGeneratedModule配置了扩展模块需要解析出来，并且不能与果Manifest中的重复
        if (annotationGeneratedModule != null
            && !annotationGeneratedModule.getExcludedModuleClasses().isEmpty()) {
            Set> excludedModuleClasses = annotationGeneratedModule.getExcludedModuleClasses();
            Iterator iterator = manifestModules.iterator();
            while (iterator.hasNext()) {
                com.bumptech.glide.module.GlideModule current = iterator.next();
                if (!excludedModuleClasses.contains(current.getClass())) {
                    continue;
                }
                /***省略部分日志***/
                iterator.remove();
            }
        }
        /***省略部分日志***/
        //获取Request的构造管理工厂类
        RequestManagerRetriever.RequestManagerFactory factory =
            annotationGeneratedModule != null
                ? annotationGeneratedModule.getRequestManagerFactory()
                : null;
        builder.setRequestManagerFactory(factory);
        //Manifest中的配置项进行应用
        for (com.bumptech.glide.module.GlideModule module : manifestModules) {
            module.applyOptions(applicationContext, builder);
        }
        //annotationGeneratedModule进行配置项的应用
        if (annotationGeneratedModule != null) {
            annotationGeneratedModule.applyOptions(applicationContext, builder);
        }
        //构造Glide
        Glide glide = builder.build(applicationContext);
        //Manifest中的组件进行注册
        for (com.bumptech.glide.module.GlideModule module : manifestModules) {
            try {
                module.registerComponents(applicationContext, glide, glide.registry);
            } catch (AbstractMethodError e) {
                /***省略部分日志***/
            }
        }
        //annotationGeneratedModule中的组件进行注册
        if (annotationGeneratedModule != null) {
            annotationGeneratedModule.registerComponents(applicationContext, glide, glide.registry);
        }
        //application注册Glide组件
        applicationContext.registerComponentCallbacks(glide);
        Glide.glide = glide;
    }
}
  1. 获取Manifest的GlideModule，反射构造；
  2. 获取GeneratedAppGlideModule中扩展模块，如果包含Manifest的扩展那么进行删除；
  3. 获取RequestManagerFactroy;
  4. Manifest.applyoptions;
  5. GeneratedAppGlideModule.applytions;
  6. 构建Glide;
  7. Manifest.registerComponents;
  8. GeneratedAppGlideModule.registerComponents;

Glide和Engine构造

public class Glide implements ComponentCallbacks2 {
    private final Engine engine;//负责启动负载以及管理活动和缓存的资源。
    private final BitmapPool bitmapPool;//Bitmap的缓存池（LruBitmapPool）
    private final MemoryCache memoryCache;//Resource缓存池（LruResourceCache）
    private final GlideContext glideContext;
    private final Registry registry;
    private final ArrayPool arrayPool;//存储大小可变的数组的缓存池(LruArrayPool)
    //一组静态方法用来创建一个新的RequestManager或者从已经存在的activity和fragment中获取
    private final RequestManagerRetriever requestManagerRetriever;
    private final ConnectivityMonitorFactory connectivityMonitorFactory;
    new Glide(
        @NonNull context,//上下文环境
        @NonNull engine,//任务执行引擎
        @NonNull memoryCache,//内存资源缓存
        @NonNull bitmapPool,//内存Bitmap缓存
        @NonNull arrayPool,//数据缓存池
        @NonNull requestManagerRetriever,//RequestManager管理集合
        @NonNull connectivityMonitorFactory,//网络监听器的生产工厂
        int logLevel,//log日志等级，默认为Log.info=4
        @NonNull defaultRequestOptionsFactory,//默认的RequestOptions生产工厂
        @NonNull defaultTransitionOptions,//默认的资源展现过渡配置容器，，默认map大小为0
        @NonNull defaultRequestListeners,//在图像加载时的监听器数组，默认数组大小为0
        boolean isLoggingRequestOriginsEnabled,//是否需要请求日志
        boolean isImageDecoderEnabledForBitmaps,//在安卓P或更高版本进行解码bitmap
        int hardwareBitmapFdLimit,//700,
        int minHardwareDimension){//128,
        /***部分代码省略***/
    }
}

Glide构造的时候需要构造Engine:

public class Engine
    implements EngineJobListener,
        MemoryCache.ResourceRemovedListener,
        EngineResource.ResourceListener {
    /***部分代码省略***/
    public Engine(
        MemoryCache memoryCache,//内存缓存
        DiskCache.Factory diskCacheFactory,//磁盘缓存
        //磁盘缓存执行器，该线程池的核心线程数和最大线程数为1
        GlideExecutor diskCacheExecutor,
        //检索资源尚未在缓存中，该线程池的核心线程数和最大线程数为cpu内核数量，最大为4
        GlideExecutor sourceExecutor,
        ////newScheduledThreadPool，核心线程数为0，用来执行网络操作
        GlideExecutor sourceUnlimitedExecutor,
        //加载动画线程池，加载动画图像的帧时使用，尤其是GitDrawable，该线程池的核心线程数和最大线程数为1或2（cpu内核数量>=4）
        GlideExecutor animationExecutor,
        //活动资源是否允许被保留，默认为false
        boolean isActiveResourceRetentionAllowed) {
            /***部分代码省略***/
    }
    /***部分代码省略***/
}

在阅读源码的时候Glide.java的构造方法，除过基础的赋值操作之前就剩下大量的注册。注册的所有组件都由Registry进行管理。

Register

Register ：管理组件注册以扩展或替换Glide的默认加载，解码和编码逻辑。

public class Registry {
    public static final String BUCKET_GIF = "Gif";
    public static final String BUCKET_BITMAP = "Bitmap";
    public static final String BUCKET_BITMAP_DRAWABLE = "BitmapDrawable";
    private static final String BUCKET_PREPEND_ALL = "legacy_prepend_all";
    private static final String BUCKET_APPEND_ALL = "legacy_append";
    //维护{@link ModelLoader}的有序放置以及它们处理的模型和数据类型,从最高优先级到最低优先级的顺序。
    private final ModelLoaderRegistry modelLoaderRegistry;
    //编码数据容器，有序列表
    private final EncoderRegistry encoderRegistry;
    //包含能够解码任意数据类型的{@link ResourceDecoder}的有序列表
    //分为从最高优先级解码器到最低优先级解码器的任意资源类型。
    private final ResourceDecoderRegistry decoderRegistry;
    //包含能够编码任意资源*类型的{@link ResourceEncoder}的有序列表。
    private final ResourceEncoderRegistry resourceEncoderRegistry;
    //DataRewinder的生产工厂
    private final DataRewinderRegistry dataRewinderRegistry;
    //注册和转化ResourceTranscoder
    private final TranscoderRegistry transcoderRegistry;
    //包含能够解析图像标题的{@link ImageHeaderParser}的无序列表。
    private final ImageHeaderParserRegistry imageHeaderParserRegistry;
    //维护“模型+资源”类的高速缓存到一组已注册资源类的集合，这些资源类是可以从模型类中解码的资源类的子类。
    private final ModelToResourceClassCache modelToResourceClassCache = new ModelToResourceClassCache();
    //维护数据，资源和转码类的缓存
    private final LoadPathCache loadPathCache = new LoadPathCache();
    //异常列表维护容器
    private final Pool> throwableListPool = FactoryPools.threadSafeList();
    /***部分代码省略***/
}

下面我们看看Glide默认注册的各种组件。

Encoder

Encoder：用于将数据编码成文件。

//用于将数据写入某些持久性数据存储的接口，例如文件
public interface Encoder {
    //将给定数据写入给定输出流，如果写入完成，则返回True
    boolean encode(@NonNull T data, @NonNull File file, @NonNull Options options);
}

EncoderRegistry ：包含能够编码任意数据类型的Encoder的有序列表。

DataClass Encoder
ByteBuffer ByteBufferEncoder
InputStream StreamEncoder
Bitmap BitmapEncoder
BitmapDrawable BitmapDrawableEncoder
GifDrawable GifDrawableEncoder 
//用于将数据从资源写入某些持久性数据存储的接口，例如文件
public interface ResourceEncoder extends Encoder> {
    //获取对应的策略模式
    @NonNull
    EncodeStrategy getEncodeStrategy(@NonNull Options options);
}
//ResourceEncoder进行资源编码缓存枚举
public enum EncodeStrategy {
    //将资源的原始未修改数据写入磁盘,不包括采样和转化
    SOURCE,
    //将资源的解码，下采样和转换后的数据写入磁盘。
    TRANSFORMED,
    /** Will write no data. */
    NONE,
}

ResourceEncoderRegistry ：包含能够编码任意资源类型的ResourceEncoder的有序列表。

ResourceClass ResourceEncoder
BitmapDrawable BitmapDrawableEncoder
GifDrawable GifDrawableEncoder
Bitmap BitmapEncoder

Decoder

Decoder：解码给定的资源类型文件。

/**
 *用于解码资源的接口。
 *@param 将从中解码资源的类型（文件，InputStream等）。
 *@param 解码资源的类型（位图，可绘制等）。
 */
public interface ResourceDecoder {
    /**
     *如果此解码器能够使用给定的源解码给定的源，则返回true选项，否则为false。
     *解码器应尽最大努力快速确定是否可能够解码数据，但不应尝试完全读取给定的数据。
     *典型的实现将检查文件头，以确保它们与解码器期望的内容匹配句柄（即GIF解码器应验证图像是否包含GIF标头块)。
     */
    boolean handles(@NonNull T source, @NonNull Options options) throws IOException;
    //从给定的数据返回已解码的资源；如果无法解码任何资源，则返回null。
    //注意width和height参数仅是提示，没有要求解码后的资源与给定尺寸完全匹配。
    //一个典型的用例将使用目标尺寸来确定对位图进行降采样的量，以避免分配过多。
    @Nullable
    Resource decode(@NonNull T source, int width, int height, @NonNull Options options)throws IOException;
}

ResourceDecoderRegistry ：包含ResourceDecoder的有序列表，这些列表可以将任意数据类型解码为从最高优先级解码器到最低优先级解码器的任意资源类型。

Bucket DataClass ResourceClass ResourceDecoder
Bitmap ByteBuffer Bitmap ByteBufferBitmapImageDecoderResourceDecoder
Bitmap InputStream Bitmap InputStreamBitmapImageDecoderResourceDecoder
Bitmap ParcelFileDescriptor Bitmap VideoDecoder
Bitmap AssetFileDescriptor Bitmap VideoDecoder
Bitmap Bitmap Bitmap UnitBitmapDecoder
Bitmap GifDecoder Bitmap GifFrameResourceDecoder
Bucket DataClass ResourceClass ResourceDecoder
BitmapDrawables ByteBuffer BitemapDrawable BitmapDrawableDecoder
BitmapDrawables InputStream BitemapDrawable BitmapDrawableDecoder
BitmapDrawables ParcelFileDescriptor BitemapDrawable BitmapDrawableDecoder
Bucket DataClass ResourceClass ResourceDecoder
Gif ByteBuffer GifDrawable ByteBufferGifDecoder
Bucket DataClass ResourceClass ResourceDecoder
All Uri Drawable ResourceDrawableDecoder
All Uri Bitmap ResourceBitmapDecoder
All File File FileDecoder
All Drawable Drawable UnitDrawableDecoder

Transcoder

Transcoder：将一种类型的资源转码为另一种类型的资源。

/**
 * 将一种类型的资源转码为另一种类型的资源。
 * @param  要被转码的资源类型
 * @param  需要转成的资源类型
 */
public interface ResourceTranscoder {
    //将给定资源转码为新资源类型并返回新资源。
    @Nullable
    Resource transcode(@NonNull Resource toTranscode, @NonNull Options options);
}

TranscoderRegistry ：该类允许ResourceTranscoder在它们之间进行转换的类中进行注册和检索。

ResourceClass TranscoeClass ResourceTranscoder
Bitmap BitmapDrawable BitmapDrawableTranscoder
Bitmap byte[] BitmapBytesTranscoder
Drawable byte[] DrawableBytesTranscoder
GifDrawable byte[] GifDrawableBytesTranscoder

ModelLoader

ModelLoader 是Glide 比较核心的类，主要是用来加载数据源Model 中的数据。

一般加载资源类型有Bitmap 、String(网络图片、本地图片、资源图片) 、Uri(网络图片、本地图片、资源图片) 、URL(网络图片) 、Integer(资源图片) 和File(本地文件)等。

Glide 为每中资源类型设计了对应的ModelLoaderFactory ，每种ModelLoaderFactory对应一种ModleLoader。

资源类型可以相互转化，比如String转URL。所以ModelLoader 内部也是可以相互进行代理。

在这里插入图片描述 
//com.bumptech.glide.load.model.MultiModelLoaderFactory
//通过仅在以下位置创建加载器来避免堆栈溢出递归地创建模型加载器
//递归请求（如果尚未在链中的早期创建）。例如：Uri加载程序可以转换为另一个模型，而后者又可以转换回Uri。
//尽管原始Uri加载程序不会提供给中间模型加载程序，其他的Uri装载程序也会。
synchronized  List> build(@NonNull Class modelClass) {
    try {
        List> loaders = new ArrayList<>();
        for (Entry entry : entries) {
            if (alreadyUsedEntries.contains(entry)) {//去重
                continue;
            }
            if (entry.handles(modelClass)) {
                alreadyUsedEntries.add(entry);
                //递归调用MultiModelLoaderFactory.build
                loaders.add(this.build(entry));
                alreadyUsedEntries.remove(entry);
            }
        }
        return loaders;
    } catch (Throwable t) {
        alreadyUsedEntries.clear();
        throw t;
    }
}
//调用ModelLoaderFactory.build
private  ModelLoader build(@NonNull Entry entry) {
    return (ModelLoader) Preconditions.checkNotNull(entry.factory.build(this));
}

比如ModelClass 是 String 类型，我们遍历找到 StreamFactory ：

public static class StreamFactory implements ModelLoaderFactory {
    @NonNull
    @Override
    public ModelLoader build(@NonNull MultiModelLoaderFactory multiFactory) {
        return new StringLoader<>(multiFactory.build(Uri.class, InputStream.class));
    }
    @Override
    public void teardown() {
      // Do nothing.
    }
}

这个时候有会进行一次递归：

//com.bumptech.glide.load.model.MultiModelLoaderFactory
public synchronized  ModelLoader build(
      @NonNull Class modelClass, @NonNull Class dataClass) {
    try {
        List> loaders = new ArrayList<>();
        boolean ignoredAnyEntries = false;
        for (Entry entry : entries) {
            if (alreadyUsedEntries.contains(entry)) {//去重
                ignoredAnyEntries = true;
                continue;
            }
            if (entry.handles(modelClass, dataClass)) {
                alreadyUsedEntries.add(entry);
                //递归调用MultiModelLoaderFactory.build
                loaders.add(this.build(entry));
                alreadyUsedEntries.remove(entry);
            }
        }
        if (loaders.size() > 1) {//数量大于1的时候构建MultiModelLoader存储loaders
            return factory.build(loaders, throwableListPool);
        } else if (loaders.size() == 1) {
            return loaders.get(0);
        } else {
            //如果递归导致没有可用的加载程序，请避免崩溃。该断言应该捕获完全未处理的类型，递归可能意味着未在某处处理子类型进入堆栈，这通常是可以的。 
            if (ignoredAnyEntries) {
                return emptyModelLoader();
            } else {
                throw new NoModelLoaderAvailableException(modelClass, dataClass);
            }
        }
    } catch (Throwable t) {
        alreadyUsedEntries.clear();
        throw t;
    }
}

所以我们根据Model的类型从注册到Glide的ModelLoaderFactory中寻找匹配项，这个查找是按照添加的顺序进行遍历。找到对应的ModelLoaderFactory 在生成 ModelLoader的时候可能会继续寻找它的代理的ModelLoader，直到不需要代理为止，我们会对这个结果去重然后如果结果数量大于1那么会生成MultiModelLoader 存储这一组 ModelLoader 。如果这组中的 ModelLoader 中还包括 MultiModelLoader 那么这个 MultiModelLoader 内还会有一组 ModelLoader 。

下面为ModelLoader涉及到的类:

DataSource ：表示某些检索到的数据的来源。

public enum DataSource {
    //表示数据可能是从设备本地检索的，尽管可能已经是通过可能已从远程源获取数据的内容提供者获得的。
    LOCAL,
    //表示从设备以外的远程源检索到数据。
    REMOTE,
    //表示从设备缓存中检索的数据未经修改。
    DATA_DISK_CACHE,
    //表示数据是从设备上缓存中的已修改内容中检索到的。
    RESOURCE_DISK_CACHE,
    //表示已从内存缓存中检索数据。
    MEMORY_CACHE,
}

DataFetcher ：加载资源的数据。

/**
 * 懒惰地检索可用于加载资源的数据。
 * @param  要加载的数据类型  (InputStream, byte[], File etc).
 */
public interface DataFetcher {
    //获取可以从中解码资源的数据。
    //没有数据的时候调用，异步线程执行，io不会阻塞
    void loadData(@NonNull Priority priority, @NonNull DataCallback callback);
    //清理或回收此数据获取器使用的任何资源。
    void cleanup();
    //取消任务
    void cancel();
    //返回此访存器将尝试获取的数据的类。
    @NonNull
    Class getDataClass();
    //返回要处理的资源数据类型
    @NonNull
    DataSource getDataSource();
}

ModelLoaderFactory ：用于为给定模型类型创建ModelLoader的接口。使用设计模式之工厂模式，让每一个ModelLoader 对应一个工厂。

public interface ModelLoaderFactory {
    //为此模型类型构建一个具体的ModelLoader。
    @NonNull
    ModelLoader build(@NonNull MultiModelLoaderFactory multiFactory);
    //一种生命周期方法，该工厂即将被替换时将被调用。
    void teardown();
}

ModelLoader ：用于将任意复杂的数据模型转换为具体的数据类型。

/**
 *工厂接口，用于将任意复杂的数据模型转换为具体的数据类型,DataFetcher可以使用来获取由模型。
 *此接口有两个目标：
 *1.将特定模型转换为可以被解码为资源。
 *2.允许将模型与视图的尺寸组合以获取模型的资源具体尺寸。
 *这不仅避免了必须在xml和代码中重复尺寸，以便确定具有不同密度的设备上视图的大小，
 *但也允许您使用布局权重或通过编程方式放置视图的尺寸而不会强迫您获取通用资源大小。
 *您获取的资源越小，使用的带宽和电池寿命越少，并且越低每个资源的内存占用量。
 *
 *@param  模型的类型。
 *@param  可以使用的数据类型ResourceDecoder来解码资源。
 */
public interface ModelLoader {
    //返回可以解码model的LoadData来进行资源解码
    //注意-如果无法返回有效的数据提取程序（例如，如果模型的URL为空），然后可以从此方法返回空数据获取程序。
    @Nullable
    LoadData buildLoadData(@NonNull Model model, int width, int height, @NonNull Options options);
    //当前的数据模型是否能被处理
    boolean handles(@NonNull Model model);
}

LoadData ：加载的资源的Key和对应加载该资源的DataFetcher 的包装对象。

//包含一组标识负载源的keys，指向等效数据的备用缓存键以及DataFetcher，可用于获取在缓存中找不到的数据。
class LoadData {
  public final Key sourceKey;//数据源标识
  public final List alternateKeys;//备用的标识
  public final DataFetcher fetcher;//可用于加载资源的数据
  public LoadData(@NonNull Key sourceKey, @NonNull DataFetcher fetcher) {
    this(sourceKey, Collections.emptyList(), fetcher);
  }
  public LoadData(
    @NonNull Key sourceKey,
    @NonNull List alternateKeys,
    @NonNull DataFetcher fetcher) {
    this.sourceKey = Preconditions.checkNotNull(sourceKey);
    this.alternateKeys = Preconditions.checkNotNull(alternateKeys);
    this.fetcher = Preconditions.checkNotNull(fetcher);
  }
}

ModelLoaderRegistry ：维护ModelLoader的有序放置以及它们处理的模型和数据类型,从最高优先级到最低优先级的顺序。

ModelClass DataClass ModelLoaderFactory
Bitmap Bitmap UnitModelLoader.Factory
GifDecoder GifDecoder UnitModelLoader.Factory
File ByteBuffer ByteBufferFileLoader.Factory
File InputStream FileLoader.StreamFactory
File ParcelFileDescriptor FileLoader.FileDescriptorFactory
File File UnitModelLoader.Factory
int InputStream ResourceLoader.StreamFactory
int ParcelFileDescriptor ResourceLoader.FileDescriptorFactory
int Uri ResourceLoader.UriFactory
int AssetFileDescriptor ResourceLoader.AssetFileDescriptorFactory
Integer InputStream ResourceLoader.StreamFactory
Integer ParcelFileDescriptor ResourceLoader.FileDescriptorFactory
Integer Uri ResourceLoader.UriFactory
Integer AssetFileDescriptor ResourceLoader.AssetFileDescriptorFactory
String InputStream DataUrlLoader.StreamFactory
String InputStream StringLoader.StreamFactory
String ParcelFileDescriptor StringLoader.FileDescriptorFactory
String AssetFileDescriptor StringLoader.AssetFileDescriptorFactory
Uri InputStream DataUrlLoader.StreamFactory
Uri InputStream HttpUriLoader.Factory()
Uri InputStream AssetUriLoader.StreamFactory
Uri InputStream MediaStoreImageThumbLoader.Factory
Uri InputStream MediaStoreVideoThumbLoader.Factory
Uri InputStream UriLoader.StreamFactory
Uri InputStream UrlUriLoader.StreamFactory
Uri ParcelFileDescriptor AssetUriLoader.FileDescriptorFactory
Uri ParcelFileDescriptor UriLoader.FileDescriptorFactory
Uri AssetFileDescriptor UriLoader.AssetFileDescriptorFactory
Uri File MediaStoreFileLoader.Factory
Uri Uri UnitModelLoader.Factory
URL InputStream UrlLoader.StreamFactory
GlideUrl InputStream HttpGlideUrlLoader.Factory
byte[] InputStream ByteArrayLoader.StreamFactory
byte[] ByteBuffer ByteArrayLoader.ByteBufferFactory
Drawable Drawable UnitModelLoader.Factory

我们现在就用 String 类型的网络图片地址的 Model 来看一下：

寻找处理 String 的 ModelLoader :

DataUrlLoader.StreamFactory.build=DataUrlLoader
  
StringLoader.StreamFactory.build
  =MultiModelLoaderFactory(Uri.class, InputStream.class)=MultiModelLoader
  ==>DataUrlLoader.StreamFactory=DataUrlLoader
  ==>HttpUriLoader.Factory=HttpUriLoader
  ==>==>MultiModelLoaderFactory(Uri.class, ParcelFileDescriptor.class)
  ==>==>==>AssetUriLoader.FileDescriptorFactory=AssetUriLoader
  ==>==>==>UriLoader.FileDescriptorFactory=AssetUriLoader
  ==>==>==>AssetUriLoader(去重)
  ==>AssetUriLoader.StreamFactory=AssetUriLoader
  ==>MediaStoreImageThumbLoader.Factory=MediaStoreImageThumbLoader
  ==>MediaStoreVideoThumbLoader.Factory=MediaStoreVideoThumbLoader
  ==>UriLoader.StreamFactory=AssetUriLoader
  ==>UrlUriLoader.StreamFactory
  ==>==>MultiModelLoaderFactory(GlideUrl.class, InputStream.class)
  ==>==>==>HttpGlideUrlLoader.Factory=HttpGlideUrlLoader
  
StringLoader.FileDescriptorFactory.build
  =MultiModelLoaderFactory(Uri.class, ParcelFileDescriptor.class)=MultiModelLoader
  ==>AssetUriLoader.FileDescriptorFactory=AssetUriLoader
  ==>UriLoader.FileDescriptorFactory=UriLoader
  
StringLoader.AssetFileDescriptorFactory.build
  =MultiModelLoaderFactory(Uri.class, AssetFileDescriptor.class)
  =UriLoader.AssetFileDescriptorFactory=UriLoader
Glide源码阅读理解一小时_第2张图片
在这里插入图片描述

接下来对这一组 ModelLoader 进行处理，过滤掉无法处理 Model 数据的 ModelLoader 。其中 MultiModelLoader 中只要有一个 ModelLoader 能处理 Model 数据， 那么这个 MultiModelLoader 就可以不被过滤。

StringLoader.StreamFactory=MultiModelLoader[7]
StringLoader.FileDescriptorFactory=MultiModelLoader[2]
StringLoader.AssetFileDescriptorFactory=UriLoader
Glide源码阅读理解一小时_第3张图片
在这里插入图片描述

Transformation

Glid-Transformation文档：https://muyangmin.github.io/glide-docs-cn/doc/transformations.html

Transformation：用于在实现资源上执行任意转换的类。

//唯一标识某些数据放置的接口。
public interface Key {
    String STRING_CHARSET_NAME = "UTF-8";
    Charset CHARSET = Charset.forName(STRING_CHARSET_NAME);
    //将所有唯一标识信息添加到给定的摘要中。
    void updateDiskCacheKey(@NonNull MessageDigest messageDigest);
    @Override
    boolean equals(Object o);
    @Override
    int hashCode();
}
//用于在实现资源上执行任意转换的类
//equals和hashCode来标识内存缓存中的转换
//updateDiskCacheKey来标识磁盘中的转换缓存。
public interface Transformation extends Key {
    //转换给定资源并返回转换后的资源
    @NonNull
    Resource transform(@NonNull Context context, @NonNull Resource resource, int outWidth, int outHeight);
}

DataRewinder

DataRewinder：对数据的游标进行重置，也就是所谓的倒带。

这个逻辑在上一篇文章 Android-Universal-Image-Loader源码分析 中也有讲到过，我们拿到数据流之后可能会从它的头部信息中获取一些图片本身的参数，然后我们再将数据流写入文件缓存的时候要重置数据流的游标保证写入的数据完整。

public interface DataRewinder {
    interface Factory {
      @NonNull
      DataRewinder build(@NonNull T data);
      @NonNull
      Class getDataClass();
    }
    //将包装的数据回退到实例化此对象时的位置，然后返回重新包装的数据
    @NonNull
    T rewindAndGet() throws IOException;
    //当不再需要该复卷机并可以对其进行清理时调用。
    void cleanup();
}

Glide 中的 DataRewinder 模块设计也使用的是工厂模式。

DataClass DataRewinder Factory 添加时机
InputStream InputStreamRewinder InputStreamRewinder.Factory Glide构造中注册
ByteBuffer ByteBufferRewinder ByteBufferRewinder.Factory Glide构造中注册
ALL DefaultRewinder DEFAULT_FACTORY 默认值，不用添加

Transition

Transition 不是由Glide进行注册的，而是我们在业务代码中按照需要添加的。它作为Glide组件的一种，所以我们放在这里来进行介绍。

Glide-Transition文档：https://muyangmin.github.io/glide-docs-cn/doc/transitions.html

Glide 提供了很多的过渡效果，用户可以手动地应用于每个请求。Glide 的内置过渡以一致的方式运行，并且将根据加载图像的位置在某些情况下避免运行。

Glide源码阅读理解一小时_第4张图片
在这里插入图片描述 
//包装视图的目标将能够提供所有必要的参数并开始过渡。
public interface Transition {
    //包含视图的接口，该视图公开了运行各种类型的必需的方法
    //Glide中所有ViewTarget的子类都实现了该接口
    interface ViewAdapter {
        //返回包装的view
        View getView();
        //返回在视图中显示的当前可绘制对象；如果不存在这样的可绘制对象，则返回null（或无法检索）。
        @Nullable
        Drawable getCurrentDrawable();
        //设置当前可绘制对象（通常是动画可绘制对象）以在包装视图中显示。
        void setDrawable(Drawable drawable);
    }
    //从当前正在使用的上一个Drawable进行动画处理在给定视图中显示，
    //如果在运行过渡过程中将新资源放在视图中，则为True，
    //如果调用者需要手动将当前资源放在视图上，则为false。
    boolean transition(R current, ViewAdapter adapter);
}
//一个工厂类，可以根据请求的状态产生不同的Transition
public interface TransitionFactory {
    //返回一个新的Transition
    //isFirstResource如果这是要加载到目标中的第一个资源，则为True。
    Transition build(DataSource dataSource, boolean isFirstResource);
}

Glide使用

我们上面从业务代码中自定义的@GlideModule注解讲到了Glide的构造，以及Glide中模块&组件的注册以及其对应的功能和处理逻辑。

接下来我们继续根据业务代码中Glide最常用的代码，来讲述Glide的其它部分。

Glide.with(context)
    .load(myUrl)
    .into(imageView);

这段代码中有我们三个业务逻辑参数：context、myUrl、imageView。

  • context ：本次加载图片的上下文环境；
  • myUrl ：本次需要加载图片的地址，也叫数据；
  • imageView ：本次需要加载图片的View ，也叫目标；

RequestManager

Glide.with(context)

根据这一行代码我们进行分析：

//com.bumptech.glide.Glide.java
@NonNull
public static RequestManager with(@NonNull Context context) {
    return getRetriever(context).get(context);
}

Glide.with(context)获取的是RequestManager 。

//用于管理和启动对Glide的请求的类。可以使用活动，片段和连接性生命周期事件智能地停止，启动和重新启动请求。
//通过实例化一个新对象或利用Activity和Fragment生命周期内置的处理功能进行检索，请对Fragment或Activity使用静态Glide.load方法。
public class RequestManager
    implements ComponentCallbacks2, LifecycleListener, ModelTypes> {
    /***代码全都省略***/
}

ComponentCallbacks2 ：Android 自带的内存管理的接口，Application 和 Activity 都有实现。主要可以根据系统的内存状况及时调整App内存占用，提升用户体验或让App存活更久。

LifecycleListener ：activity或者fragment的声明周期监听接口

public interface LifecycleListener {
    void onStart();//fragmetn或者activity的onstart
    void onStop();//fragmetn或者activity的onstop
    void onDestroy();//fragmetn或者activity的ondestroy
}

ModelTypes ：通俗的说就是Glide的API。

interface ModelTypes {
    @NonNull
    @CheckResult
    T load(@Nullable Bitmap bitmap);
    T load(@Nullable Drawable drawable);
    T load(@Nullable String string);
    T load(@Nullable Uri uri);
    T load(@Nullable File file);
    T load(@RawRes @DrawableRes @Nullable Integer resourceId);
    T load(@Nullable URL url);
    T load(@Nullable byte[] model);
    T load(@Nullable Object model);
}

RequestManager的获取

//com.bumptech.glide.manager.RequestManagerRetriever.java
//Application的生命周期单独管理
private volatile RequestManager applicationManager;
//一个是support包，一个是Android的api，RequestManagerFragment的临时存储
//RequestManagerFragment用来管理RequestManager和同步生命周期
final Map pendingRequestManagerFragments = new HashMap<>();
final Map pendingSupportRequestManagerFragments = new HashMap<>();
public RequestManager get(@NonNull Context context) {
    if (context == null) {
        throw new IllegalArgumentException("You cannot start a load on a null Context");
    } else if (Util.isOnMainThread() && !(context instanceof Application)) {
        if (context instanceof FragmentActivity) {//FragmentActivity
            return get((FragmentActivity) context);
        } else if (context instanceof Activity) {//Activity
            return get((Activity) context);
        } else if (context instanceof ContextWrapper//找到context的basecontext
            && ((ContextWrapper) context).getBaseContext().getApplicationContext() != null) {
            return get(((ContextWrapper) context).getBaseContext());
        }
    }
    return getApplicationManager(context);
}

我们用Fragment 来举例看看RequestManager的获取（Activity和FragmentActivity的实现都类似）：

public RequestManager get(@NonNull Fragment fragment) {
    Preconditions.checkNotNull(fragment.getContext(),"fragment必须被attch，不能被destroy");
    if (Util.isOnBackgroundThread()) {//如果应用在后台，那么切换为Application
        return get(fragment.getContext().getApplicationContext());
    } else {
        FragmentManager fm = fragment.getChildFragmentManager();
        return supportFragmentGet(fragment.getContext(), fm, fragment, fragment.isVisible());
    }
}
private RequestManager supportFragmentGet(
      @NonNull Context context,
      @NonNull FragmentManager fm,
      @Nullable Fragment parentHint,
      boolean isParentVisible) {
    //获取当前上下文中的SupportRequestManagerFragment
    SupportRequestManagerFragment current =
        getSupportRequestManagerFragment(fm, parentHint, isParentVisible);
    //获取SupportRequestManagerFragment的RequestManager
    RequestManager requestManager = current.getRequestManager();
    if (requestManager == null) {
        //给新创建的SupportRequestManagerFragment添加RequestManager
        Glide glide = Glide.get(context);
        requestManager =
            factory.build(
                glide, current.getGlideLifecycle(), current.getRequestManagerTreeNode(), context);
        current.setRequestManager(requestManager);
    }
    return requestManager;
}
private SupportRequestManagerFragment getSupportRequestManagerFragment(
      @NonNull final FragmentManager fm, @Nullable Fragment parentHint, boolean isParentVisible) {
    //先看看当前的FragmentManager中有没有SupportRequestManagerFragment，有就复用
    SupportRequestManagerFragment current = (SupportRequestManagerFragment) fm.findFragmentByTag(FRAGMENT_TAG);
    if (current == null) {
        //pendingSupportRequestManagerFragments，只是一个临时性的存储,因为每次put之后必定会remove
        //因为add之后立即进行findFragmentByTag是获取不到的，所以需要临时存储
        current = pendingSupportRequestManagerFragments.get(fm);
        if (current == null) {
            //创建新的SupportRequestManagerFragment
            current = new SupportRequestManagerFragment();
            current.setParentFragmentHint(parentHint);  
            //如果fragment已经展示，那么添加的SupportRequestManagerFragment也要同步生命周期
            if (isParentVisible) {
                current.getGlideLifecycle().onStart();
            }
            //添加临时存储
            pendingSupportRequestManagerFragments.put(fm, current);
            //创建的SupportRequestManagerFragment添加到FragmentManager中
            fm.beginTransaction().add(current, FRAGMENT_TAG).commitAllowingStateLoss();
            //删除临时存储
            handler.obtainMessage(ID_REMOVE_SUPPORT_FRAGMENT_MANAGER, fm).sendToTarget();
        }
    }
    return current;
}

其它功能

执行\取消一个请求、暂停所有请求、重启所有请求等对请求的标记，这部分会在Request 详细讲解。在说Request 之前先说一下Request需要为谁加载目标资源。

Target

Target ：在声明周期内Glide加载资源回调接口；

BaseTarget ：用于加载Resource的基础 Target 大多数方法的基本或空实现；

TargetView ：为Bitmap添加到View上提供了默认实现，

public interface Target extends LifecycleListener {
    //表示我们希望资源保持其原始的未修改宽度和/或高度
    int SIZE_ORIGINAL = Integer.MIN_VALUE;
    //开始加载
    void onLoadStarted(@Nullable Drawable placeholder);
    //加载失败
    void onLoadFailed(@Nullable Drawable errorDrawable);
    //资源加载完成时将调用的方法。
    void onResourceReady(@NonNull R resource, @Nullable Transition transition);
    //在取消负载及其资源释放时调用
    void onLoadCleared(@Nullable Drawable placeholder);
    //一种检索此目标大小的方法
    void getSize(@NonNull SizeReadyCallback cb);
    //如果给定的回调仍保留，则将其从待处理集中删除
    void removeCallback(@NonNull SizeReadyCallback cb);
    //设置为此目标保留的当前请求
    void setRequest(@Nullable Request request);
    //检索对此目标的当前请求
    @Nullable
    Request getRequest();
}

RequestBuilder

Glide.with(context)
    .load(myUrl)

我们继续看下一行load代码：

//com.bumptech.glide.RequestManager.java
public RequestBuilder load(@Nullable String string) {
    return asDrawable().load(string);
}

RequestBuilder通用类，可以处理通用资源类型的设置选项和启动负载。GlideRequest虽然继承了RequestBuilder 但内部的实现都是super调用父类的方法。

//com.bumptech.glide.RequestManager.java
public RequestBuilder asDrawable() {
    return as(Drawable.class);
}
public  RequestBuilder as(
      @NonNull Class resourceClass) {
    return new RequestBuilder<>(glide, this, resourceClass, context);
}

asDrawable 创建一个请求资源类型为 Drawable.class 的 RequestBuilder 。

//com.bumptech.glide.RequestBuilder.java
public RequestBuilder load(@Nullable String string) {
    return loadGeneric(string);
}
private RequestBuilder loadGeneric(@Nullable Object model) {
    this.model = model;
    isModelSet = true;
    return this;
}

接下来设置这个 RequestBuilder 的 Model 为String.class 的 myUrl 。

Glide.with(context)
    .load(myUrl)
    .into(imageView);

RequestBuilder 的 into 方法是 Glide 加载图片的最后一步。

public ViewTarget into(@NonNull ImageView view) {
    Util.assertMainThread();
    Preconditions.checkNotNull(view);
    BaseRequestOptions requestOptions = this;
    //下面是根据view修改requestOptions的属性
    if (!requestOptions.isTransformationSet()
        && requestOptions.isTransformationAllowed()
        && view.getScaleType() != null) {
      switch (view.getScaleType()) {
        case CENTER_CROP:
          requestOptions = requestOptions.clone().optionalCenterCrop();
          break;
        case CENTER_INSIDE:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case FIT_CENTER:
        case FIT_START:
        case FIT_END:
          requestOptions = requestOptions.clone().optionalFitCenter();
          break;
        case FIT_XY:
          requestOptions = requestOptions.clone().optionalCenterInside();
          break;
        case CENTER:
        case MATRIX:
        default:
          // Do nothing.
      }
    }
    return into(
        glideContext.buildImageViewTarget(view, transcodeClass),
        /*targetListener=*/ null,
        requestOptions,
        Executors.mainThreadExecutor());
}

into 方法主要根据 View 的属性重构造 requestOptions ， 并生成 DrawableImageViewTarget 。

ViewTarget的生成

public class GlideContext extends ContextWrapper {
    public  ViewTarget buildImageViewTarget(
        @NonNull ImageView imageView, @NonNull Class transcodeClass) {
        return imageViewTargetFactory.buildTarget(imageView, transcodeClass);
    }
    /***部分代码省略***/
}
public class ImageViewTargetFactory {
    @NonNull
    @SuppressWarnings("unchecked")
    public  ViewTarget buildTarget(
        @NonNull ImageView view, @NonNull Class clazz) {
        if (Bitmap.class.equals(clazz)) {
            return (ViewTarget) new BitmapImageViewTarget(view);
        } else if (Drawable.class.isAssignableFrom(clazz)) {
            return (ViewTarget) new DrawableImageViewTarget(view);
        } else {
            throw new IllegalArgumentException(
            "Unhandled class: " + clazz + ", try .as*(Class).transcode(ResourceTranscoder)");
      }
    }
}

transcodeClass 实际就是上面的 resourceClass 也就是 Drawable.class 。

接下来我们继续看它的 into 方法：

private > Y into(
      @NonNull Y target,
      @Nullable RequestListener targetListener,
      BaseRequestOptions options,
      Executor callbackExecutor) {
    Preconditions.checkNotNull(target);
    //检测是否设置了model
    if (!isModelSet) {
      throw new IllegalArgumentException("You must call #load() before calling #into()");
    }
    //创建请求,Executors.mainThreadExecutor()标识callback在主线程
    Request request = buildRequest(target, targetListener, options, callbackExecutor);
    Request previous = target.getRequest();
    //如果target上的当前请求与上一次的相同，且请求缓存磁盘并且上一个请求为完成时使用上一个请求
    if (request.isEquivalentTo(previous)
        && !isSkipMemoryCacheWithCompletePreviousRequest(options, previous)) {
      //如果请求已完成，请重新开始，以确保重新发送结果，触发RequestListeners和Targets。
      //如果请求失败，将重新开始重新启动请求，使它有另一个完成的机会。
      //如果请求已经正在运行，我们可以让它继续运行而不会受到干扰。
      if (!Preconditions.checkNotNull(previous).isRunning()) {
        //使用上一个请求而不是新请求来进行优化，例如跳过设置占位符，跟踪和取消跟踪目标并获取视图尺寸在单独的请求中完成。 
        previous.begin();
      }
      return target;
    }
    //清除target之前的请求
    requestManager.clear(target);
    //给target设置新的请求
    target.setRequest(request);
    //target同步requestmanager的声明周期，并将request添加到请求列表
    requestManager.track(target, request);
    return target;
}
private boolean isSkipMemoryCacheWithCompletePreviousRequest(
    BaseRequestOptions options, Request previous) {
    return !options.isMemoryCacheable() && previous.isComplete();
}

好吧，终于看见加载图片的请求了~！

这里会根据之前构建的一些参数来生成 Request ，然后和 ViewTarget 的 Request 进行比较决定是否重用之前的 Request ，或者清除之前的 Request 。

Request

Request ：为 Target 加载资源的请求。

public interface Request {
    void begin();//开始异步加载
    //防止从以前的请求中加载任何位图，释放由此持有的任何资源请求，并将该请求标记为具有已取消。
    void clear();
    //暂停请求
    void pause();
    //如果此请求正在运行并且尚未完成或失败，则返回true。
    boolean isRunning();
    //如果请求成功完成，则返回true
    boolean isComplete();
    //如果请求已清除，则返回true
    boolean isCleared();
    //判断两个请求是否相同
    boolean isEquivalentTo(Request other);
}

Request的创建

Request request = buildRequest(target, targetListener, options, callbackExecutor);
  • target : 我们对 ImageView 包装之后的的 ViewTarget；
  • targetListener ：默认为null；
  • options ：为重新根据view 属性修改之后的 requestOptions ；
  • callbackExecutor : 回调的线程池，在主线程中执行回调；

生成的Request 实例为 SingleRequest，它是专门为了Target而加载资源的。

如果需要设置处理 Error 的请求那么会在 Request 外包一层生成 ErrorRequestCoordinator。

ErrorRequestCoordinator ：运行单个主要的Request直到完成，然后仅在单个主要请求失败的情况下后退错误请求；

如果需要设置处理缩略图的请求那么会在 Request 外包一层生成 ThumbnailRequestCoordinator。

ThumbnailRequestCoordinator ：一个协调器，用于协调两个单独的Request，它们同时加载图像的小缩略图版本和图像的完整尺寸版本。

整个Glide 中 Request 的实现类就SingleRequest 、ErrorRequestCoordinator 和 ThumbnailRequestCoordinator 一共三个。

SingleRequest

SingleRequest 不仅实现了 Request ，还实现了SizeReadyCallback 和 ResourceCallback 接口。

SizeReadyCallback ：当目标确定其大小时必须调用的回调。对于固定尺寸的目标可以同步调用。

public interface SizeReadyCallback {
    void onSizeReady(int width, int height);
}

ResourceCallback ：侦听资源加载成功完成或失败的回调。

public interface ResourceCallback {
  //成功加载资源时调用。
  void onResourceReady(Resource resource, DataSource dataSource);
  //当资源无法成功加载时调用。
  void onLoadFailed(GlideException e);
  //返回通知单个请求时要使用的锁
  Object getLock();
}

上面我们阅读into代码的时候知道了 request 的执行是调用了RequestManager.track 。

//com.bumptech.glide.RequestManager
//对request进行追踪，默认的new RequestTracker()；
private final RequestTracker requestTracker；
//对target进行追踪
private final TargetTracker targetTracker = new TargetTracker();
synchronized void track(@NonNull Target target, @NonNull Request request) {
    //添加到RequestManger的target追踪容器中
    targetTracker.track(target);
    //运行request
    requestTracker.runRequest(request);
}
  • TargetTracker : 保留当前对有效的一组Target，并转发生命周期事件。
  • RequestTracker ：用于跟踪，取消和重新启动进行中，已完成和失败的请求的类。

Request 已经讲述了一部分了，之前 RequestManger 部分对于 Request 的请求、清除、暂停、重新启动没有详细讲述，现在可以开始^_^。

Request.begin

//com.bumptech.glide.manager.RequestTracker
public void runRequest(@NonNull Request request) {
    //添加到请求容器中
    requests.add(request);
    //如果当前的RequestManager不处于暂停状态，那么直接开始请求
    if (!isPaused) {
        request.begin();
    } else {
        //否则延迟该请求
        request.clear();
        if (Log.isLoggable(TAG, Log.VERBOSE)) {
            Log.v(TAG, "Paused, delaying request");
        }
         pendingRequests.add(request);
    }
}

接下来看SingleRequest 的 begin 方法，开始真正的获取资源。

//com.bumptech.glide.manager.RequestTracker
@Override
public void begin() {
    synchronized (requestLock) {
        assertNotCallingCallbacks();//如果已经进行了回调，那么抛异常
        stateVerifier.throwIfRecycled();//如果任务已经被回收，那么抛异常
        startTime = LogTime.getLogTime();
        if (model == null) {
            //校验宽高是否有效
            if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
                width = overrideWidth;
                height = overrideHeight;
            }
            //详细的日志级别进行记录
            int logLevel = getFallbackDrawable() == null ? Log.WARN : Log.DEBUG;
            onLoadFailed(new GlideException("Received null model"), logLevel);
            return;
        }
        if (status == Status.RUNNING) {//如果任务已经处于运行状态，那么抛异常
          throw new IllegalArgumentException("Cannot restart a running request");
        }
        //如果任务已经执行完成，那么直接回调加载资源
        if (status == Status.COMPLETE) {
            onResourceReady(resource, DataSource.MEMORY_CACHE);
            return;
        }
        //重新启动既未完成也未运行的请求，可以视为新请求并可以从头开始再次运行。
        status = Status.WAITING_FOR_SIZE;
        if (Util.isValidDimensions(overrideWidth, overrideHeight)) {
           onSizeReady(overrideWidth, overrideHeight);//内部有请求资源的实现方法调用
        } else {
           target.getSize(this);//重新回调onSizeReady方法
        }
        //加载占位图
        if ((status == Status.RUNNING || status == Status.WAITING_FOR_SIZE)
            && canNotifyStatusChanged()) {
            target.onLoadStarted(getPlaceholderDrawable());
        }
    }
}

已知加载的ViewTarget的宽高才会进一步加载资源。

//com.bumptech.glide.request.SingleRequest
@Override
public void onSizeReady(int width, int height) {
    stateVerifier.throwIfRecycled();//如果任务已经被回收，那么抛异常
    synchronized (requestLock) {//加锁，进行数据请求
        if (status != Status.WAITING_FOR_SIZE) {//必须size确定
            return;
        }
        status = Status.RUNNING;//进入运行状态
        //在加载资源之前，对Target的大小应用乘数。对于加载缩略图或避免加载大量资源非常有用。默认为1f。
        float sizeMultiplier = requestOptions.getSizeMultiplier();
        this.width = maybeApplySizeMultiplier(width, sizeMultiplier);
        this.height = maybeApplySizeMultiplier(height, sizeMultiplier);
        loadStatus =
                engine.load(
                        glideContext,
                        model,//myUrl
                        requestOptions.getSignature(),//缓存签名，默认为EmptySignature
                        this.width,
                        this.height,
                        requestOptions.getResourceClass(),//不设置decode的话，默认为Object
                        transcodeClass,//Drawable.class
                        priority,
                        requestOptions.getDiskCacheStrategy(),
                        requestOptions.getTransformations(),
                        requestOptions.isTransformationRequired(),
                        requestOptions.isScaleOnlyOrNoTransform(),
                        requestOptions.getOptions(),
                        requestOptions.isMemoryCacheable(),
                        requestOptions.getUseUnlimitedSourceGeneratorsPool(),
                        requestOptions.getUseAnimationPool(),
                        requestOptions.getOnlyRetrieveFromCache(),
                        this,
                        callbackExecutor);
        /***部分代码省略***/
    }
}

Engine.load

//com.bumptech.glide.load.engine.Engine
public  LoadStatus load(/***部分代码省略***/) {
    long startTime = VERBOSE_IS_LOGGABLE ? LogTime.getLogTime() : 0;
    EngineKey key = //构造缓存的key
            keyFactory.buildKey(
                    model,//数据myUrl
                    signature,//签名
                    width,
                    height,
                    transformations,//转变
                    resourceClass,//Object.class
                    transcodeClass,//Drawable.class
                    options);
    EngineResource memoryResource;
    synchronized (this) {
        //先从缓存中加载
        memoryResource = loadFromMemory(key, isMemoryCacheable, startTime);
        if (memoryResource == null) {
            return waitForExistingOrStartNewJob(/***部分代码省略***/);
        }
    }
    //回调可以并发，不需要进行锁操作
    cb.onResourceReady(memoryResource, DataSource.MEMORY_CACHE);
    return null;
}

内存缓存加载

private EngineResource loadFromMemory(EngineKey key, boolean isMemoryCacheable, long startTime) {
    if (!isMemoryCacheable) {//如果不允许使用内存，那么直接返回null
        return null;
    }
    EngineResource active = loadFromActiveResources(key);//获取活跃的资源
    if (active != null) {
        return active;
    }
    EngineResource cached = loadFromCache(key);//获取内存缓存中的资源
    if (cached != null) {
        return cached;
    }
    return null;
}

ActiveResources

ActiveResources ：利用持有Resource 弱引用的 HashMap 来进行数据保存。

private EngineResource loadFromActiveResources(Key key) {
    EngineResource active = activeResources.get(key);
    if (active != null) {
        active.acquire();
    }
    return active;
}
  • 添加操作：有两个触发点，一个是从 cache 中读取的时候会将资源添加到 ActiveResources 。另一个获取资源完成的时候会添加到 ActiveResources 。它们有一个相同的点都在使用资源的时候添加到 ActiveRsources 。
  • 删除操作：EngineResource 在内部有一个引用计数器，每次被获取的时候都会进行 acquire 自加。被释放的时候也是会自减。当引用计数为0的时候，会被 ActivityResources 释放，并添加到 MemoryCache 中。

MemoryCache

MemoryCache ：同样使用 LRU 算法，实现类为LruResourceCache ，它提供了一个 ResourceRemovedListener接口，当有资源从 MemoryCache 中被移除时会回调其中的方法，Engine 中接收到这个消息后就会进行 Bitmap 的回收操作。

private EngineResource loadFromCache(Key key) {
    EngineResource cached = getEngineResourceFromCache(key);
    if (cached != null) {
        cached.acquire();
        activeResources.activate(key, cached);
    }
    return cached;
}
private EngineResource getEngineResourceFromCache(Key key) {
    Resource cached = cache.remove(key);
    final EngineResource result;
    if (cached == null) {
        result = null;
    } else if (cached instanceof EngineResource) {
        result = (EngineResource) cached;
    } else {
        result = new EngineResource<>(cached, true, true, key, this);
    }
    return result;
}
@Override
public void onResourceReleased(Key cacheKey, EngineResource resource) {
    activeResources.deactivate(cacheKey);
    if (resource.isMemoryCacheable()) {
        cache.put(cacheKey, resource);
    } else {
        resourceRecycler.recycle(resource);
    }
}
  • 添加操作：当资源被 ActiveResources 释放的时候；
  • 删除操作：当资源被 ActivityResource 获取的时候；

以上两点保证了 ActiveResource 和 MemoryCache 中的资源是不会有重复的。

DecodeJob

DecodeJob ：负责从缓存的数据或原始源解码资源，并应用转换和转码。
接下来的部分会详细讲解上图的每个部分。

Glide源码阅读理解一小时_第5张图片
在这里插入图片描述

磁盘缓存加载

等待创建或者是获取已经存在的加载状态。

private  LoadStatus waitForExistingOrStartNewJob(/***部分代码省略***/) {
    EngineJob current = jobs.get(key, onlyRetrieveFromCache);//从hashmap中获取加载key的工作引擎
    if (current != null) {//如果已经存在那么直接返回
        current.addCallback(cb, callbackExecutor);
        return new LoadStatus(cb, current);
    }
    EngineJob engineJob = //通过添加和删除负载的回调并在负载完成时通知回调来管理负载的类。
            engineJobFactory.build(/***部分代码省略***/);
    DecodeJob decodeJob = //负责从缓存的数据或原始源解码资源，并应用转换和转码。
            decodeJobFactory.build(/***部分代码省略***/);
    jobs.put(key, engineJob);//添加到hashmap中
    engineJob.addCallback(cb, callbackExecutor);//添加回调信息
    engineJob.start(decodeJob);//开始工作
    return new LoadStatus(cb, engineJob);
}

选择执行线程，开始执行任务：

//com.bumptech.glide.load.engine.EngineJob
public synchronized void start(DecodeJob decodeJob) {
    this.decodeJob = decodeJob;
    //根据磁盘缓存策略，判断使用哪个线程池执行任务
    GlideExecutor executor = decodeJob.willDecodeFromCache() ? diskCacheExecutor : getActiveSourceExecutor();
    executor.execute(decodeJob);
}

在diskCacheExecutor 线程池中执行 DecoceJob。

//com.bumptech.glide.load.engine.DecodeJob
public void run() {
    /***部分代码省略***/
    DataFetcher localFetcher = currentFetcher;
    try {
        if (isCancelled) {//如果任务已经取消，那么进行失败回调
            notifyFailed();
            return;
        }
        runWrapped();//开始执行任务
    } catch (CallbackException e) {
        //如果不受Glide控制的回调引发异常，则应避免使用Glide下面的特定调试逻辑。 
    } catch (Throwable t) {
        //通知失败，进行失败回调，抛出异常
    } finally {
        if (localFetcher != null) {
            localFetcher.cleanup();
        }
        GlideTrace.endSection();
    }
}

runWrapped 为 run 实现的包装。

//com.bumptech.glide.load.engine.DecodeJob
private enum RunReason {
    //初始化
    INITIALIZE,
    //切换执行服务
    SWITCH_TO_SOURCE_SERVICE,
    //获取数据之后的资源编解码
    DECODE_DATA,
}
private void runWrapped() {
    switch (runReason) {
        case INITIALIZE:
            stage = getNextStage(Stage.INITIALIZE);
            currentGenerator = getNextGenerator();
            runGenerators();
            break;
        case SWITCH_TO_SOURCE_SERVICE:
            runGenerators();
            break;
        case DECODE_DATA:
            decodeFromRetrievedData();
            break;
        default:
            throw new IllegalStateException("Unrecognized run reason: " + runReason);
    }
}

再讲下一步数据从磁盘的获取之前，先看一下我们默认的磁盘策略：

public static final DiskCacheStrategy AUTOMATIC =
    new DiskCacheStrategy() {
        @Override
        public boolean isDataCacheable(DataSource dataSource) {
            return dataSource == DataSource.REMOTE;
        }
        @Override
        public boolean isResourceCacheable(
            boolean isFromAlternateCacheKey, DataSource dataSource, EncodeStrategy encodeStrategy) {
            return ((isFromAlternateCacheKey && dataSource == DataSource.DATA_DISK_CACHE)
                    || dataSource == DataSource.LOCAL)
                && encodeStrategy == EncodeStrategy.TRANSFORMED;
        }
        @Override
        public boolean decodeCachedResource() {
            return true;
        }
        @Override
        public boolean decodeCachedData() {
            return true;
        }
    };
  • 如果数据时 REMOTE 类型那么可以进行缓存；
  • 如果是解码资源而且Key 不是源数据的Key ，资源为 DATA_DISK_CACHE 的话，那么这个资源可以缓存；
  • 可以缓存解码资源；
  • 可以缓存解码数据；

从上面我们可以了解到缓存有数据缓存 和 解码后的数据缓存 。

我们接着分析 runWrapped 方法内调用的 getNextStage :

//com.bumptech.glide.load.engine.DecodeJob
private Stage getNextStage(Stage current) {
    switch (current) {
        case INITIALIZE://AUTOMATIC默认为true，所以初始化的第一步应该检测Stage.RESOURCE_CACHE
            return diskCacheStrategy.decodeCachedResource()
                ? Stage.RESOURCE_CACHE
                : getNextStage(Stage.RESOURCE_CACHE);
        case RESOURCE_CACHE://AUTOMATIC默认为true，所以初始化的下一步应该检测Stage.DATA_CACHE
            return diskCacheStrategy.decodeCachedData()
                ? Stage.DATA_CACHE
                : getNextStage(Stage.DATA_CACHE);
        case DATA_CACHE:////如果用户选择仅从缓存中检索资源，则从源跳过加载。否则应该检测Stage.SOURCE
            return onlyRetrieveFromCache ? Stage.FINISHED : Stage.SOURCE;
        case SOURCE:
        case FINISHED:
            return Stage.FINISHED;
        default:
            throw new IllegalArgumentException("Unrecognized stage: " + current);
    }
}

知道了Stage 类型接着分析 runWrapped 方法内调用的 getNextStage :

//com.bumptech.glide.load.engine.DecodeJob
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);
    }
}

DataFetcherGenerator : 注册 ModelLoaders 和 Model 的数据提取构造器。

interface DataFetcherGenerator {
    //尝试使用一个新的DataFetcher，则返回true已启动，否则为false。
    boolean startNext();
    //尝试取消当前正在运行的提取程序
    void cancel();
}

ResourceCacheGenerator 、DataCacheGenerator 和 SourceGenerator 除过实现了DataFetcherGenerator 还实现了 DataCallback 接口。

DataCallback : 数据已加载且可用时或加载时必须调用的回调失败。

interface DataCallback {
    //如果加载成功，则使用加载的数据进行调用；如果加载失败，则使用null进行调用。
    void onDataReady(@Nullable T data);
    //加载失败时调用
    void onLoadFailed(@NonNull Exception e);
}

获取到DataFetcherGenerator 构造器之后执行 startNext ，判断是否下一步能开始加载数据。

//com.bumptech.glide.load.engine.EngineJob
private void runGenerators() {
    currentThread = Thread.currentThread();
    startFetchTime = LogTime.getLogTime();
    boolean isStarted = false;
    while (!isCancelled && currentGenerator != null 
        && !(isStarted = currentGenerator.startNext())) {//执行当前数据构造的判断是否能加载数据
        stage = getNextStage(stage);//切换数据状态
        currentGenerator = getNextGenerator();//获取新的数据构造器
        if (stage == Stage.SOURCE) {//需要需要进行源数据加载那么切换执行线程
            reschedule();
            return;
        }
    }
    //如果已经完成或者取消，而且没开始获取数据。那么通知失败
    if ((stage == Stage.FINISHED || isCancelled) && !isStarted) {
        notifyFailed();
    }
    //否则，生成器将开始新的加载，我们希望将其调回onDataFetcherReady。
}

ResourceCacheGenerator

ResourceCacheGenerator ：从包含降采样/转换后的资源缓存文件中获取数据。

class ResourceCacheGenerator implements DataFetcherGenerator, DataFetcher.DataCallback {    
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        List sourceIds = helper.getCacheKeys();//能处理Model（myUrl）的LoadData列表，返回其Key
        if (sourceIds.isEmpty()) {//如果没有，那么标示Model（myUrl）这个数据类型无法处理，直接返回false
            return false;
        }
        //获取glide中注册的，能加载Model（url），能解码resourceClass（Drawable），能转码transcodeClass(Object)的组件集合
        List> resourceClasses = helper.getRegisteredResourceClasses();
        if (resourceClasses.isEmpty()) {//如果没有适配的组件集合，而且转码的类型为文件的话那么抛异常。因为File都不能转码那么根本无法磁盘缓存
            if (File.class.equals(helper.getTranscodeClass())) {
                return false;
            }
            throw new IllegalStateException(/***部分代码省略***/);
        }
        while (modelLoaders == null || !hasNextModelLoader()) {//如果还有modelLoader
            resourceClassIndex++;
            //双重判断使LoadData列表进行完全遍历
            if (resourceClassIndex >= resourceClasses.size()) {
                sourceIdIndex++;
                if (sourceIdIndex >= sourceIds.size()) {
                    return false;
                }
                resourceClassIndex = 0;
            }
            Key sourceId = sourceIds.get(sourceIdIndex);
            Class resourceClass = resourceClasses.get(resourceClassIndex);
            Transformation transformation = helper.getTransformation(resourceClass);
            //ResourceCacheKey用于下采样和转换的资源数据的缓存密钥+任何请求的签名。
            currentKey =
                new ResourceCacheKey(
                    helper.getArrayPool(),
                    sourceId,//modelLoaddata
                    helper.getSignature(),//签名
                    helper.getWidth(),//宽
                    helper.getHeight(),//高
                    transformation,//转换
                    resourceClass,//解码
                    helper.getOptions());
            cacheFile = helper.getDiskCache().get(currentKey);
            //判断Resource是否有缓存，如果有那么加载这个缓存文件数据
            if (cacheFile != null) {
                sourceKey = sourceId;
                modelLoaders = helper.getModelLoaders(cacheFile);//获取能加载文件的ModelLoader列表
                modelLoaderIndex = 0;
            }
        }
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {
            ModelLoader modelLoader = modelLoaders.get(modelLoaderIndex++);
            //ModelLoader根据cacheFile，width，height，options构造LoadData
            loadData = modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
            //该LoadData是否被Glide进行加载过，是否可用
            if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }

        return started;
    }
    @Override
    public void cancel() {
        LoadData local = loadData;
        if (local != null) {
            local.fetcher.cancel();
        }
    }
    @Override//数据已经准备好，标识数据源为RESOURCE_DISK_CACHE
    public void onDataReady(Object data) {
        cb.onDataFetcherReady(
            sourceKey, data, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE, currentKey);
    }
    @Override//加载失败，标识数据源为RESOURCE_DISK_CACHE
    public void onLoadFailed(@NonNull Exception e) {
        cb.onDataFetcherFailed(currentKey, e, loadData.fetcher, DataSource.RESOURCE_DISK_CACHE);
    }
}
 
 
DataCacheGenerator
 
 
 
  
DataCacheGenerator ： 构造来自包含原始未修改源数据的缓存文件。
 
 
 
 
class DataCacheGenerator implements DataFetcherGenerator, DataFetcher.DataCallback {
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        //如果还有modelLoader
        while (modelLoaders == null || !hasNextModelLoader()) {
            sourceIdIndex++;
            //cacheKyes（helper.getCacheKeys）在构造的时候传入，和ResourceCacheGenerator的相同
            if (sourceIdIndex >= cacheKeys.size()) {
                return false;
            }
            Key sourceId = cacheKeys.get(sourceIdIndex);
            //原始源数据的缓存键和任何请求的签名。
            Key originalKey = new DataCacheKey(sourceId, helper.getSignature());
            cacheFile = helper.getDiskCache().get(originalKey);
            //判断Resource是否有缓存，如果有那么加载这个缓存文件数据
            if (cacheFile != null) {
                this.sourceKey = sourceId;
                modelLoaders = helper.getModelLoaders(cacheFile);//获取能加载文件的ModelLoader列表
                modelLoaderIndex = 0;
            }
        }
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {
            ModelLoader modelLoader = modelLoaders.get(modelLoaderIndex++);
            //ModelLoader根据cacheFile，width，height，options构造LoadData
            loadData = modelLoader.buildLoadData(cacheFile, helper.getWidth(), helper.getHeight(), helper.getOptions());
            //该LoadData是否被Glide进行加载过，是否可用
            if (loadData != null && helper.hasLoadPath(loadData.fetcher.getDataClass())) {
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }
        return started;
    }
    @Override
    public void onDataReady(Object data) {//数据已经准备好，标识数据源为DATA_DISK_CACHE
        cb.onDataFetcherReady(sourceKey, data, loadData.fetcher, DataSource.DATA_DISK_CACHE, sourceKey);
    }
    @Override
    public void onLoadFailed(@NonNull Exception e) {//加载失败，标识数据源为DATA_DISK_CACHE
        cb.onDataFetcherFailed(sourceKey, e, loadData.fetcher, DataSource.DATA_DISK_CACHE);
    }
}
 
 
可以看出来 ResourceCacheGenerator 的实现其实和 DataCacheGenerator 的实现逻辑很相似，只不过是缓存的 Key 不同而已。
 
 
源数据请求
 
 
 
  
SourceGenerator ： 根据磁盘缓存策略，可以先将源数据编码后写入磁盘，然后再加载从缓存文件而不是直接返回。
 
 
 
 
class SourceGenerator implements DataFetcherGenerator,DataFetcher.DataCallback,
                DataFetcherGenerator.FetcherReadyCallback {
    private DataCacheGenerator sourceCacheGenerator;//磁盘缓存的数据构造器
    private Object dataToCache;//需要缓存的数据
    private DataCacheKey originalKey;//磁盘缓存的key
    /***部分代码省略***/
    @Override
    public boolean startNext() {
        if (dataToCache != null) {//是否已经拥有缓存的数据
            Object data = dataToCache;
            dataToCache = null;
            cacheData(data);//进行据缓存，缓存后sourceCacheGenerator不为空
        }
        //由SourceGenerator转到DataCacheGenerator（网络转磁盘）
        if (sourceCacheGenerator != null && sourceCacheGenerator.startNext()) {
            return true;
        }
        sourceCacheGenerator = null;
        loadData = null;
        boolean started = false;
        while (!started && hasNextModelLoader()) {//如果还有LoadData(model,width，height，options构造LoadData)
            loadData = helper.getLoadData().get(loadDataListIndex++);
            //fetcher.getDataSource()是否可以进行磁盘缓存
            if (loadData != null && (helper.getDiskCacheStrategy().isDataCacheable(loadData.fetcher.getDataSource())
                    || helper.hasLoadPath(loadData.fetcher.getDataClass()))) {//该LoadData是否被Glide进行加载过，是否可用
                started = true;//如果可用，那么使用该LoadData中的DataFetcher进行数据获取
                loadData.fetcher.loadData(helper.getPriority(), this);
            }
        }
        return started;
    }
    /***部分代码省略***/
    private void cacheData(Object dataToCache) {
        long startTime = LogTime.getLogTime();
        try {//获取dataToCache对应的解码器，StreamEncoder
            Encoder encoder = helper.getSourceEncoder(dataToCache);
            DataCacheWriter writer = new DataCacheWriter<>(encoder, dataToCache, helper.getOptions());
            originalKey = new DataCacheKey(loadData.sourceKey, helper.getSignature());//生成数据源的key
            helper.getDiskCache().put(originalKey, writer);//将writer写入到磁盘缓存中，对应的key为originalKey
        } finally {
            loadData.fetcher.cleanup();
        }
        //构造原始数据缓存构造器，转到磁盘读取数据
        sourceCacheGenerator = new DataCacheGenerator(Collections.singletonList(loadData.sourceKey), helper, this);
    }
    @Override//数据加载成功回调，date类型为InputStream
    public void onDataReady(Object data) {DiskCacheStrategy diskCacheStrategy = helper.getDiskCacheStrategy();
        //如果数据不为空，而且可以缓存那么机进行SourceGenerator转DataCacheGenerator
        if (data != null && diskCacheStrategy.isDataCacheable(loadData.fetcher.getDataSource())) {
            dataToCache = data;
            cb.reschedule();//切换线程，切换完之后currentGenerator还是SourceGenerator
        } else {//否早直接将数据进行回调
            cb.onDataFetcherReady(loadData.sourceKey,data,loadData.fetcher,loadData.fetcher.getDataSource(),originalKey);
        }
    }
    @Override//数据加载失败回调
    public void onLoadFailed(@NonNull Exception e) {
        cb.onDataFetcherFailed(originalKey, e, loadData.fetcher, loadData.fetcher.getDataSource());
    }
    @Override//DataCacheGenerator的数据加载成功回调，data类型为ByteBuffer
    public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher fetcher, DataSource dataSource, Key attemptedKey) {
        // 此数据提取程序将从文件中加载并提供错误的数据源，因此请覆盖使用原始提取程序的数据源 
        cb.onDataFetcherReady(sourceKey, data, fetcher, loadData.fetcher.getDataSource(), sourceKey);
    }
    @Override//DataCacheGenerator的数据加载失败回调
    public void onDataFetcherFailed(Key sourceKey, Exception e, DataFetcher fetcher, DataSource dataSource) {
        cb.onDataFetcherFailed(sourceKey, e, fetcher, loadData.fetcher.getDataSource());
    }
}
 
 
SourceGenerator 、DataCacheGenerator 和 ResourceCacheGenerator 的 startNext 方法都会寻找合适的 ModelLoader 构建对应的 LoadData 来加载数据。
 
 
现在我们的 Model 是 myUrl 一个网络图片地址，在没有加载过之前ResourceCacheGenerator 和 DataCacheGenerator 当然是没有缓存的，所以我们这里用SourceGenerator 加载一个网络图片的过程在详细讲述一下 startNext 中怎么获取LoadData 进行数据加载（其他两个都实现都类似）。
 
 
 
  
需要注意的是Data已经是从磁盘缓存读出来的 ByteBuffer ，但是DataSource 还是 REMOTE 。
 
 
 
 
数据解码和转码
 
 
无论加载的缓存还是其他的数据成功后都会回调 onDataFetcherReady ，然后进行数据解码。
 
 
//com.bumptech.glide.load.engine.DecodeJob
public void onDataFetcherReady(Key sourceKey, Object data, DataFetcher fetcher, DataSource dataSource, Key attemptedKey) {
    this.currentSourceKey = sourceKey;//url
    this.currentData = data;//ByteBuffer
    this.currentFetcher = fetcher;//ByteBufferFetcher
    this.currentDataSource = dataSource;//REMOTE
    this.currentAttemptingKey = attemptedKey;//url
    //如果当前线程不是主线程，那么切换到主线程执行数据解码（调用decodeFromRetrievedData）
    if (Thread.currentThread() != currentThread) {
        runReason = RunReason.DECODE_DATA;
        callback.reschedule(this);
    } else {
        GlideTrace.beginSection("DecodeJob.decodeFromRetrievedData");
        try {
            decodeFromRetrievedData();//进行数据解码
        } finally {
            GlideTrace.endSection();
        }
    }
}

 
 
接下来的步骤：
 
 
     
  
  1.  decodeFromRetrievedData 中调用 decodeFromData ；
    2.  
  
  2.  decodeFromData 中调用 decodeFromFetcher ；
    3.  
  
  3.  decodeFromFetcher 获取 Registry.getLoadPath 以及 Registry.getRewinder；
    4.  
 
 
 
最终是为了获得 DecodePaht 和 LoadPath 。
 
 
解码&渐变&转码
 
 
 
  
LoadPath ：一个或多个 DecodePath 来进行数据的解码；
 
 
 
 
//com.bumptech.glide.Registry
@Nullable
public  LoadPath getLoadPath(
      @NonNull Class dataClass,//ByteBuffer.class
      @NonNull Class resourceClass,//Object.class
      @NonNull Class transcodeClass) {//Drawable.class
    LoadPath result = loadPathCache.get(dataClass, resourceClass, transcodeClass);
    if (loadPathCache.isEmptyLoadPath(result)) {
        return null;
    } else if (result == null) {
        List> decodePaths = getDecodePaths(dataClass, resourceClass, transcodeClass);
        //可能无法将给定的类型解码或转码为所需的类型数据类。 
        if (decodePaths.isEmpty()) {
            result = null;
        } else {
            result = new LoadPath<>(dataClass, resourceClass, transcodeClass, decodePaths, throwableListPool);
        }
        loadPathCache.put(dataClass, resourceClass, transcodeClass, result);
    }
    return result;
}

 
 
 
  
DecodePath ：尝试从给定的数据类型解码和转码资源类型；
 
 
 
 
//com.bumptech.glide.Registry
@NonNull
private  List> getDecodePaths(
      @NonNull Class dataClass,
      @NonNull Class resourceClass,
      @NonNull Class transcodeClass) {
    List> decodePaths = new ArrayList<>();
    //GifDrawable,Bitmap,BitmapDrawable
    List> registeredResourceClasses = decoderRegistry.getResourceClasses(dataClass, resourceClass);
    for (Class registeredResourceClass : registeredResourceClasses) {
        List> registeredTranscodeClasses = transcoderRegistry.getTranscodeClasses(registeredResourceClass, transcodeClass);
        for (Class registeredTranscodeClass : registeredTranscodeClasses) {
            List> decoders = decoderRegistry.getDecoders(dataClass, registeredResourceClass);
            ResourceTranscoder transcoder = transcoderRegistry.get(registeredResourceClass, registeredTranscodeClass);
            //transcoder=DrawableBytesTranscoder
            DecodePath path =
                new DecodePath<>(
                    dataClass,//ByteBuffer
                    registeredResourceClass,//GifDrawable/Bitmap/BitmapDrawable
                    registeredTranscodeClass,//Drawable/Drawable/Drawable
                        //ByteBufferGifDecoder/ByteBufferBitmapDecoder/BitmapDrawableDecoder
                    decoders,
                        ///UnitTranscoder/BitmapDrawableTranscoder/UnitTranscoder
                    transcoder,
                    throwableListPool);
            decodePaths.add(path);
        }
    }
    return decodePaths;
}

 
 
     
  
  1. 解码的时候调用 DecodePath.decode 方法，该方法会循环遍历内部的decoders列表中的 ResourceDecoder 如果ByteBufferBitmapDecoder.decode解码成功(Bitmap)直接返回。
    2.  
  
  2. 继续回调判断是或否进行transform 如果需要那么 DecodeJob.onResourceDecoded 进行 transform 进行资源的渐变，渐变之后重新构造缓存的 Key 将再次进行 Encoder 。
    3.  
  
  3. 然后再进行 BitmapDrawableTranscoder.transcode 进行转码得到 LazyBitmapDrawableResource 。
    4.  
  
  4. 回到 notifyEncodeAndRelease 方法进行资源成功回调，以及判断判断是否需要 Encoder 进行磁盘缓存，回调编码成功释放资源。
    5.  
 
 
 
 
  
 
   
 
    Glide源码阅读理解一小时_第6张图片 
   
 
  
 
  

    model-data-resource.png 
  
 
 
 
 
至此整个资源的获取过程完成，最后我们获取出了Drawable 。
 
 
加载&释放资源
 
 
 
  
DecodeJob
 
 
 
 
     
  
  • 进行 notifyComplete : 回调 EngineJob.onResourceReady ;
    •  
  
  • 进行 onEncodeComplete ：释放当前的 DecodeJob ;
    •  
 
 
 
 
  
EngineJob
 
 
 
 
     
  
  • 进行 notifyCallbacksOfResult ，回调 incrementPendingCallbacks 进行资源的引用+1 ；
    •  
  
  • 回调 Engine.onEngineJobComplete ；
    •  
  
  • 执行 CallResourceReady 任务，回调 SingleRequest.onResourceReady ，并进行资源的引用+1；
    •  
  
  • 执行 decrementPendingCallbacks 进行资源的引用-1；
    •  
 
 
 
 
  
Engine
 
 
 
 
     
  
  • 将资源添加到 activeResource ;
    •  
  
  • 移除当前jobs 中对应的 EngineJob;
    •  
 
 
 
 
  
SingleRequest
 
 
 
 
     
  
  • 判断&校验，获取资源；
    •  
  
  • 进行 target.onResourceReadt 将资源加载到 View 上。
    •  
 
 
 
总结
 
 
因为上一篇文章是 Android-Universal-Image-Loader源码分析 ，所以这里主要是结合 ImageLoader 来和 Glide 进行比较。
 
 
 
  
功能
 
 
 
 
     
  
  1.  Glide 默认的网络请求和 ImageLoader 相同都是 HttpUrlConnection；
    2.  
  
  2.  Glide 和 ImageLoader 都可以添加自定义的网络请求比如 OkHttp ;
    3.  
  
  3.  Glide 和 ImageLoader 都支持在图片加载前获取图片的数据（图片的宽、高）。
    4.  
  
  4.  Glide 会根据请求时会根据当前 context 的声明周期进行 Request 的管理（粒度为 Application 和 Activity）。这个功能是 ImageLoader 不具备的，ImageLoader 只能停止一个请求，或者停止所有请求。
    5.  
  
  5.  Glide 和 ImageLoader 都具有加载默认图、加载失败备用图的功能。
    6.  
  
  6.  Glide 具备加载缩略图的功能，这个功能是 ImageLoader 不具备的。
    7.  
  
  7.  Glide 可以设置请求时候的优先级，虽然说这个请求优先级不是十分严格仅仅是指导来做请求的优化处理，但这个功能是 ImageLoader 不具备的。
    8.  
  
  8.  Glide 加载图片的数据可支持多种类型，ImageLoader 只支持 String 。
    9.  
  
  9.  Glide 和 ImageLoader 都可以自定义配置图片加载库使用的 download 、decoder 、executor 、cache 等，只不过 Glide 对自定义模块配置更加的方便以及粒度更细。
    10.  
 
 
 
 
  
缓存
 
 
 
 
     
  
  1.  ImageLoader 缓存的 key 只能根据图片地址进行处理生成。 Glide 的原始数据的磁盘缓存的 Key 是由 url 和 signature 组成，资源图片的缓存（磁盘缓存和内存缓存）的 Key 是由图片的（宽、高、资源类型、资源转换类型、资源解码类型、签名、model 以及 option）组成而且签名可以由我们自己的 request 进行设置。
    2.  
  
  2.  Gilde 可以进行请求时的设置跳过缓存，或者进行 signature 设置防止缓存失效问题。这个是 ImageLoader 不具备的功能。
    3.  
  
  3.  Glide 进行渐变处理的图片会被再次缓存，这个功能是 ImageLoader 不具备的。
    4.  
  
  4.  Glide 的内存缓存分为两级MemoryCache 和 ActiveResource ，MemoryCache 和 ImageLoader 相同都是使用 LruCache ，ActiveResource 对正在使用的图片做了弱引用，防止使用中的 资源 被 LRU 算法回收掉。
    5.  
 
 
 
文章到这里就全部讲述完啦，若有其他需要交流的可以留言哦！！
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Glide源码阅读理解一小时)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                    
  • 回溯算法-重新安排行程
                        chirou_
算法数据结构图论c++图搜索
                        
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    
                    
    • 
                    
  • 心有蓝天白云，爱情便会晴空万里，然后有花香有鸟鸣有美好的未来
                        曹十二吖

                        
    丁南的婚姻，来自于一场她对生命的对比。她曾经说过，当她最爱的母亲用生命去逼迫她结婚的时候，她曾一度不理解到愤怒，甚至于想过用轻生来对抗母亲的不理智。庆幸的是，丁南是一个自我调节能力非常强的人，她想如果我连死亡都不怕，还怕不能经营好一段婚姻吗？抱着这样的念头，24年没有谈过恋爱的她，用短短三个月的时间，完成了少女到女人的蜕变。她曾经说过：“我要把自己最珍贵的东西留给自己命中注定的那个人。”闺蜜几人中
    
                    
    • 
                    
  • Redis系列：Geo 类型赋能亿级地图位置计算
                        Ly768768
redisbootstrap数据库
                        
    1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
    
                    
    • 
                    
  • 简介Shell、zsh、bash
                        zhaosuningsn
Shellzshbashshelllinuxbash
                        
    Shell是Linux和Unix的外壳，类似衣服，负责外界与Linux和Unix内核的交互联系。例如接收终端用户及各种应用程序的命令，把接收的命令翻译成内核能理解的语言，传递给内核，并把内核处理接收的命令的结果返回给外界，即Shell是外界和内核沟通的桥梁或大门。Linux和Unix提供了多种Shell，其中有种bash，当然还有其他好多种。Mac电脑中不但有bash，还有一个zsh，预装的，据说
    
                    
    • 
                    
  • 如何选择最适合你的项目研发管理软件？TAPD卓越版全面解析
                        北京云巴巴信息技术有限公司
产品经理需求分析
                        
    在当今快速发展的科技时代，项目研发管理软件已成为企业不可或缺的重要工具。面对市场上琳琅满目的产品，如何选择一款适合自己团队的项目研发管理软件呢？本文将围绕项目研发管理软件的选择标准，重点介绍TAPD卓越版的特点、优势以及使用体验，让你更好地理解和选择适合自己的项目研发管理软件。项目研发管理软件的选择标准在选择项目研发管理软件时，我们需要考虑以下几个方面的因素：功能全面性：软件是否覆盖了从需求管理、
    
                    
    • 
                    
  • STM32中的计时与延时
                        lupinjia
STM32stm32单片机
                        
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
    
                    
    • 
                    
  • 关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解
                        秋刀prince
mysqlmysql数据库
                        
    提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • 如何在心上用功？
                        余超林AIA财富管家

                        
    思考：如何在心上用功？学习心得：心-道-德-事的理解心-道-德-事这四部曲，本质上就是一个人的思维智慧的四个层面：事是最底层，这是所有人在这个社会谋求生存的基础，一个人能够把事情彻底做好，保质保量的完成，才会有真正的结果，但是这个层面要获得真正成功很困难，因为会做事的人很多，最终会出现恶性竞争；德是第三层，如果说整个社会做事的竞争激烈程度为100%，那么上升到德上的竞争激烈程度降低为80%，德是一
    
                    
    • 
                    
  • 戴容容 中原焦点团队.网络初级第33期,坚持分享第19天 2022年3月9日
                        TessDai

                        
    《每个人眼中的世界都是不同的》“一千个人眼里有一千个哈姆雷特”世界是多元的,每个人都有自己的道理,人人按照自己的理解去看待这个世界的人和物.我们如此,其他人也是如此.因此,任何事情,我们要放下自己以为的真理,去理解他人认为的真理,只有同频方能共振.孩子在慢慢长大的过程中慢慢学会独立,甚至对抗.尤其当孩子处于青春期的时候,他们开始有很多自己独立的想法,和一些特立独行的做法,家长常常会觉得不可思议,觉
    
                    
    • 
                    
  • BART&BERT
                        Ambition_LAO
深度学习
                        
    BART和BERT都是基于Transformer架构的预训练语言模型。模型架构：BERT(BidirectionalEncoderRepresentationsfromTransformers)主要是一个编码器（Encoder）模型，它使用了Transformer的编码器部分来处理输入的文本，并生成文本的表示。BERT特别擅长理解语言的上下文，因为它在预训练阶段使用了掩码语言模型（MLM）任务，即
    
                    
    • 
                    
  • 逻辑思维的过程与力量
                        解晓萱

                        
    之前我对逻辑思维的了解停留在，讲话时有逻辑，辩论时条理清晰。今天看了《开讲了》里面关于大学生质疑易中天老师的视频，听到易中天老师的回答，忽然对逻辑思维有了稍微深刻的理解。图片发自App逻辑学对我们太重要了，不仅仅是学习备考，更重要的是生活和事业及交流的选择及过程。偏激的起点和性格有关，更和逻辑思维水平有关。视频里，易中天老师评价北大学生逻辑时讲到：“他的逻辑环节是没问题的，但是逻辑起点错了，所以他
    
                    
    • 
                    
  • 好习惯:锻炼孩子的思考力
                        好习惯2011

                        
    家长在教育孩子时，应积极鼓励孩子提问，让孩子尽量相信自己能够解决问题，还要注意激发孩子的好奇心，使孩子对所探究的问题产生强烈的求知欲望。在适当的时候，家长们也要问孩子一些问题，锻炼孩子的思考能力。只要我们愿意，就可以用适合孩子年龄的理解的方式和语言，引导孩子进行思考，并学到知识。知识是一环扣一环的，我们为孩子解开一个谜，就为解开下一个谜作了准备，只要我们用心，孩子的知识链条就会越接越长。孩子们在学
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • 人与人之间的相遇，是天意，人与人之间的分离，常在人为。
                        雨墨笔谈

                        
    人际关系，是我们生活中不可或缺的一部分。然而，如何与他人和谐相处，维系友情和爱情，却是一门艺术，需要智慧、耐心去领悟。不强求才是人与人之间最舒服的相处方式。这一理念代表着我们与世界相处的智慧，也是我们与他人建立持久友情和幸福感情的关键。理解与尊重人际关系中，理解和尊重是金科玉律。当我们能够以开放的心态去理解他人，不仅可以减少冲突，还可以建立更深刻的关系。正如有这样一句话说到：“你无法选择你的亲人，
    
                    
    • 
                    
  • 【旅行故事】强个体与好组织相互成就@稀土永磁Amy@20220205@上海
                        稀土永磁Amy

                        
    我们每个人都在组织当中。当你来到组织中，都要理解个体跟组织的关系和组织中个体的关系。一个组织产生高绩效的时候，其实是需要组织个体的发展跟组织发展之间要有一个匹配程度。有时也会看到一个组织当中，一些个体会觉得发展的不够充分，原因就在于个体的发展速度超过了组织的发展速度。还有一些时候我们会发现，组织要淘汰很多个体，原因也在于组织发展的速度超越了个体发展的速度。按照这个逻辑，无论是组织的视角还是个体的视
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现
                        Lenyiin
C++修炼全景指南技术指南c++数据结构stl
                        
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
    
                    
    • 
                    
  • 坚持“三步走”，推动我国人权事业发展
                        Ariel_Yogurt

                        
    6月16日出版的第12期《求是》杂志将发表中共中央总书记、国家主席、中央军委主席习近平的重要文章《坚定不移走中国人权发展道路，更好推动我国人权事业发展》。尊重和保障人权，是中国共产党人的不懈追求。努力夯实理论基础。推动人权事业发展的第一步是理解人权。作为青年干部，要想在人权事业全民发展的新浪潮中站稳脚步，就应该积极接受人权理论学习，坚持以人民为中心的人权思想，深刻认识党的领导是中国特色社会主义人权
    
                    
    • 
                    
  • iOS内存管理简单理解
                        烧烤有点辣

                        
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
    
                    
    • 
                    
  • 幸福需要发现的眼睛
                        Thinking_f826

                        
    早上去上班，快到单位门口远远地发现同事和媳妇手牵手一起走来，看到他们满满的幸福要溢出的样子，好生羡慕。我发现身边总有一些感觉很幸福的朋友，一点点事情，有时在我看来就是故意的大惊小怪，特别是那夸张的语气和表情，真令人受不了。比如说——我认为一个不咋好笑的事情，她们能笑上好久；我觉得生活好苦好累，而她们却能从一点点事情，哪怕是一顿饭中寻找到乐趣；我理解的平淡，她们认为很无趣；我理解的喧嚣和夸张，她们认
    
                    
    • 
                    
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表
                        Lenyiin
技术指南C++修炼全景指南c++list链表stl
                        
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
    
                    
    • 
                    
  • Python数据分析与可视化
                        jun778895
python数据分析开发语言
                        
    Python数据分析与可视化是一个涉及数据处理、分析和以图形化方式展示数据的过程，它对于数据科学家、分析师以及任何需要从数据中提取洞察力的专业人员来说至关重要。以下将详细探讨Python在数据分析与可视化方面的应用，包括常用的库、数据处理流程、可视化技巧以及实际应用案例。一、Python数据分析与可视化的重要性数据可视化是将数据以图形或图像的形式表示出来，以便人们能够更直观地理解数据背后的信息和规
    
                    
    • 
                    
  • 毕业论文附录一般都写什么?大学生写论文是干嘛用的
                        写个原创论文
人工智能深度学习AI写作chatgpt论文阅读
                        
    毕业论文的附录通常包含一些在正文中不便于展示或详细阐述的内容，但对理解论文整体又具有重要意义的资料。具体来说，附录可能包含以下内容：AI论文，免费大纲，10分钟3万字，查重高于15%退费，支持数据图表！！AIPaperPass-AI论文写作指导平台AIPaperPass是AI原创论文写作平台，免费千字大纲，5分钟生成3万字初稿，提供答辩汇报ppt、开题报告、任务书等，40篇真实中英文知网参考文献，
    
                    
    • 
                    
  • 【c++基础概念深度理解——堆和栈的区别，并实现堆溢出和栈溢出】
                        XWWW668899
C++基本概念c++c语言开发语言青少年编程
                        
    文章目录概要技术名词解释栈溢出和堆溢出小结概要学习C++语言，避免不了要好好理解一下堆（Heap）和栈（Stack），有助于更好地管理内存，以及如何写出一段程序“成功实现”堆溢出和栈溢出。技术名词解释理解东西最快的方式是根据自己目前能理解的词语去关联新的概念，不断的纠正，向正确的深度理解靠近，当无限接近的时候也就理解了想要理解的概念。我们经常说堆栈，把这两个名词放到一起。其实，堆是堆，栈是栈，两种
    
                    
    • 
                                
  • web报表工具FineReport常见的数据集报错错误代码和解释
                                    老A不折腾
web报表finereport代码可视化工具
                                    
    在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。 
  
NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 
NS_LayerReport_MultiDs=错误代码
    
                                
    • 
                                
  • Java的WeakReference与WeakHashMap
                                    bylijinnan
java弱引用
                                    
    首先看看 WeakReference 
 
wiki 上 Weak reference 的一个例子： 
 
 

	public class ReferenceTest {
	public static void main(String[] args) throws InterruptedException {
 
            WeakReference r = new Wea
    
                                
    • 
                                
  • Linux——（hostname）主机名与ip的映射
                                    eksliang
linuxhostname
                                    
    一、 什么是主机名 
无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 
主机名是用于什么的呢？ 
答：在一个局域网中，每台机器都有一个主
    
                                
    • 
                                
  • oracle 常用技巧
                                    18289753290

                                    
    oracle常用技巧   ①复制表结构和数据     create table  temp_clientloginUser   as     select distinct userid from tbusrtloginlog   ②仅复制数据   如果表结构一样   insert into  mytable  select  * &nb
    
                                
    • 
                                
  • 使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException
                                    酷的飞上天空
exception
                                    
    有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 
com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
    
                                
    • 
                                
  • IT系统分析师如何学习大数据
                                    蓝儿唯美
大数据
                                    
    我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
    
                                
    • 
                                
  • spring学习——简介
                                    a-john
spring
                                    
    Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 
 
为了降低Java开发的复杂性，
    
                                
    • 
                                
  • 自定义颜色的xml文件
                                    aijuans
xml
                                    
    <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
    
                                
    • 
                                
  • 运营到底是做什么的？
                                    aoyouzi
运营到底是做什么的？
                                    
    文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
    
                                
    • 
                                
  • js面向对象类和对象
                                    百合不是茶
js面向对象函数创建类和对象
                                    
    接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似 
  
下面介绍一些js的类和对象的创建的技术 
  
一:类和对
    
                                
    • 
                                
  • web.xml之资源管理对象配置 resource-env-ref
                                    bijian1013
javaweb.xmlservlet
                                    
    resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 
<resource-env-ref>
    <resource-env-ref-name>资源名</resource-env-ref-name>
    <resource-env-ref-type>查找资源时返回的资源类
    
                                
    • 
                                
  • Create a composite component with a custom namespace
                                    sunjing

                                    
    https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace 
  
When you developed a composite component the namespace you would be seeing would 
    
                                
    • 
                                
  • 【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter
                                    bit1129
mongodb
                                    
     一、复本集为什么要加入Arbiter这个角色   回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。   什么是Artiber？   An arbiter does 
not have a copy of data set and 
cannot become a primary. Replica sets may have arbiters to add a 
    
                                
    • 
                                
  • Javascript开发笔记
                                    白糖_
JavaScript
                                    
     
 获取iframe内的元素 
 
通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
    
                                
    • 
                                
  • Web浏览器Chrome打开一段时间后，运行alert无效
                                    bozch
Webchormealert无效
                                    
    今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 
试了试其他浏览器，发现都是没有问题的。 
开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 
这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。 
  
结果就好了，这也太怪异了。难道是cho
    
                                
    • 
                                
  • 编程之美-高效地安排会议 图着色问题 贪心算法
                                    bylijinnan
编程之美
                                    
    

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;

public class GraphColoringProblem {

	/**编程之美 高效地安排会议 图着色问题 贪心算法
	 * 假设要用很多个教室对一组
    
                                
    • 
                                
  • 机器学习相关概念和开发工具
                                    chenbowen00
算法matlab机器学习
                                    
    基本概念： 
机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 
它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 
 
开发工具 
M
    
                                
    • 
                                
  • [宇宙经济学]关于在太空建立永久定居点的可能性
                                    comsci
经济
                                    
     
       大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........ 
 
       所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
    
                                
    • 
                                
  • oracle 11g database control 证书错误
                                    daizj
oracle证书错误oracle 11G 安装
                                    
    oracle 11g database control 证书错误  
 
win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 
 
解决办法： 
 
是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
    
                                
    • 
                                
  • Java I/O之用FilenameFilter实现根据文件扩展名删除文件
                                    游其是你
FilenameFilter
                                    
    在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 
在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16 
    
                                
    • 
                                
  • C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例
                                    dcj3sjt126com
carray
                                    
    # include <stdio.h>

int main(void)
{
	
	int a[5] = {1, 2, 3, 4, 5};
		//a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4]
	
	int i;

	for (i=0; i<5; ++i)
		printf("%d\n",
    
                                
    • 
                                
  • PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引
                                    dcj3sjt126com
primary
                                    
    PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
    
                                
    • 
                                
  • java集合辅助类 Collections、Arrays
                                    shuizhaosi888
CollectionsArraysHashCode
                                    
      
Arrays、Collections 
  
1 ）数组集合之间转换 
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    } 
     a）Arrays.asL
    
                                
    • 
                                
  • Spring Security（10）——退出登录logout
                                    234390216
logoutSpring Security退出登录logout-urlLogoutFilter
                                    
           要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
    
                                
    • 
                                
  • 透过源码学前端 之 Backbone 三 Model
                                    逐行分析JS源代码
backbone源码分析js学习
                                    
    Backbone 分析第三部分  Model 
概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 
但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 
如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。 
    
                                
    • 
                                
  • SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter
                                    乒乓狂魔
springMVC
                                    
    这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 
 
HttpMessageConverter接口介绍： 
 

public interface HttpMessageConverter<T> {

	/**
	 * Indicate
    
                                
    • 
                                
  • 分布式基础知识和算法理论
                                    bluky999
算法zookeeper分布式一致性哈希paxos
                                    
       
分布式基础知识和算法理论 
BY [email protected] 
本文永久链接：http://nodex.iteye.com/blog/2103218 
  
在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
    
                                
    • 
                                
  • Android Studio的.gitignore以及gitignore无效的解决
                                    bell0901
androidgitignore
                                    
    　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 
　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 
　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store 
    
                                
    • 
                                
  • 成为高级程序员的10个步骤
                                    tomcat_oracle
编程
                                    
    What 
软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。 
  
Why 
 
  得到更多的报酬！因为你的薪水会随着你水平的提高而增加  
  提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进  
  历经更大的挑战。随着你的成长，各种影响力也会提高。  
    
                                
    • 
                                
  • mongdb在linux下的安装
                                    xtuhcy
mongodblinux
                                    
    一、查询linux版本号： 
lsb_release -a  
LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa
    
                                
    •