前言
Registry是Glide中非常重要的知识，可以把它理解成连结各个核心功能模块的集中营或者挂载中心，这一章节就来分解它是如何建立和运作的：
本章要讨论的内容：
- Registry的基本构成；
- 各个模块的功能和介绍；
- 数据的转换流程；
从Registry开始
Registry是一个组件管理类，它的主要用途是扩展和替换Glide组件，这些组件包括加载，编码，解码等逻辑；Registry内部支持的模块类型如下: Registry.java
private final ModelLoaderRegistry modelLoaderRegistry;
private final EncoderRegistry encoderRegistry;
private final ResourceDecoderRegistry decoderRegistry;
private final ResourceEncoderRegistry resourceEncoderRegistry;
private final DataRewinderRegistry dataRewinderRegistry;
private final TranscoderRegistry transcoderRegistry;//Resource转换模块注册
private final ImageHeaderParserRegistry imageHeaderParserRegistry;//文件头解析模块注册
复制代码Registry并不是承当所有模块的注册工作，而是把各个模块分配的不同的Registry当中； 主要模块的功能：
- ModelLoaderRegistry ：//数据加载模块注册
- EncoderRegistry：//所有对数据进行编码模块的注册
- ResourceDecoderRegistry：//处理过的解码模块注册
- ResourceEncoderRegistry：//处理过的编码模块注册
- DataRewinderRegistry ： //数据流重置起点模块注册
- TranscoderRegistry： // Resource进行转换模块注册
- ImageHeaderParserRegistry //图片头解析模块注册
Glide自身充当对外调用的门户，Registry提供了一下入口方法来实现各个模块的注册和调用；主要方法如下：
注册相关方法：
- append() //尾步追加
- prepend() //头部插入
- register() //注册，相当于append()
- replace() //替换掉相同条件的所有模块
操作相关的方法：
- getLoadPath()//获取加载路径
- getDecodePaths() //获取解析路径
- getRegisteredResourceClasses()//获取所有匹配的ResourceClasses;
- isResourceEncoderAvailable()//ResourceEncoder是否可用；
- getResultEncoder()//获取Encoder;
- getRewinder()//获取Rewinder;
- getModelLoaders()//获取ModelLoader；
总结：Registry通过内部Registry分别管理不同类型的组件，Registry提供统一的入口方法来实现注册和获取；
下面对各个模块基本介绍：
模块简要分析
ModelLoader
ModelLoader是通过ModelLoaderRegistry进行管理，ModelLoader需要接受两个泛型类型ModelLoader本身是一个工厂接口，主要工作是将复杂数据模型转通过DataFetcher转换成需要的Data，LoadData是ModelLoader的内部类，是对DataFetcher和Key的封装实体，ModelLoader的创建用ModelLoaderFactory，一个基本的ModelLoader创建应该是这个样子的： 参考HttpGlideUrlLoader
第一步：自定义类实现自ModelLoader，重写BuildLoadData()方法和handles()方法；
public class HttpGlideUrlLoader implements ModelLoader {
@Nullable private final ModelCache modelCache;
public HttpGlideUrlLoader() {
this(null);
}
public HttpGlideUrlLoader(@Nullable ModelCache modelCache) {
this.modelCache = modelCache;
}
@Override
public LoadData buildLoadData(@NonNull GlideUrl model, int width, int height,
@NonNull Options options) {
GlideUrl url = model;
if (modelCache != null) {
url = modelCache.get(model, 0, 0);
if (url == null) {
modelCache.put(model, 0, 0, model);
url = model;
}
}
int timeout = options.get(TIMEOUT);
return new LoadData<>(url, new HttpUrlFetcher(url, timeout));
}
@Override
public boolean handles(@NonNull GlideUrl model) {
return true;
}
}
复制代码 buildLoadData()需要创建LoadData,需要传入Key和DataFetcher，handles()返回值代表是否接受当前model类型的，true代表接受，所以一般都是true;
第二步：自定义Fetcher实现DataFecher，重写loadData()、cleanup()、cancel()、getDataClass()、getDataSource()方法；
public class HttpUrlFetcher implements DataFetcher {
public void loadData(@NonNull Priority priority,
@NonNull DataCallback callback) {
long startTime = LogTime.getLogTime();
try {
InputStream result = loadDataWithRedirects(glideUrl.toURL(), 0, null, glideUrl.getHeaders());
callback.onDataReady(result);
} catch (IOException e) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Failed to load data for url", e);
}
callback.onLoadFailed(e);
} finally {
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, "Finished http url fetcher fetch in " + LogTime.getElapsedMillis(startTime));
}
}
}
//清理工作
@Override
public void cleanup() {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
}
}
if (urlConnection != null) {
urlConnection.disconnect();
}
urlConnection = null;
}
//取消请求
@Override
public void cancel() {
isCancelled = true;
}
//返回Data类型
@NonNull
@Override
public Class getDataClass() {
return InputStream.class;
}
//返回DataSource
@NonNull
@Override
public DataSource getDataSource() {
return DataSource.REMOTE;
}
}
复制代码 第三步:创建Factory类，重写build()、teardown()方法，在build()方法中返回真正的MolderLoader对象；
public static class Factory implements ModelLoaderFactory {
private final ModelCache modelCache = new ModelCache<>(500);
@NonNull
@Override
public ModelLoader build(MultiModelLoaderFactory multiFactory) {
return new HttpGlideUrlLoader(modelCache);//创建ModelLoader
}
@Override
public void teardown() {
// Do nothing.
}
}
复制代码 接下来，就可以在Registry中注册ModelLoader了；在第一章我们简单说过模块的配置可以用Annotation和Manifest两种类型，在registerComponents()方法中，可以拿到Registry，这样就可以调用registry的注册相关方法；
@Override
public void registerComponents(Context context, Registry registry) {
registry.replace(GlideUrl.class, InputStream.class, new HttpGlideUrlLoader.Factory(context));
}
复制代码最后，说一下泛型Glide.with().load(model)； Data理论上也可以是任意数据类型，但基于后续流程的支持，一般都是File,InputStream和ByteBuffer;
ResourceDecoder
ResourceDecoder是一个解析Resource的接口，接受两个泛型handles()和decode，参考一个简单的BitmapDecoder:
public class StreamBitmapDecoder implements ResourceDecoder {
private final Downsampler downsampler;
private final ArrayPool byteArrayPool;
public StreamBitmapDecoder(Downsampler downsampler, ArrayPool byteArrayPool) {
this.downsampler = downsampler;
this.byteArrayPool = byteArrayPool;
}
@Override
public boolean handles(@NonNull InputStream source, @NonNull Options options) {
return downsampler.handles(source);
}
@Override
public Resource decode(@NonNull InputStream source, int width, int height,
@NonNull Options options)
throws IOException {
...
try {
return downsampler.decode(invalidatingStream, width, height, options, callbacks);
} finally {
exceptionStream.release();
if (ownsBufferedStream) {
bufferedStream.release();
}
}
}
}
复制代码 泛型解析：T表示输入类型一般为File，InputStream或者ByteBuffer，Z表示输出类型，一般为Bitmap和Drawable
Encoder和ResourceEncoder
Encoder表面意思为加密，本质上和加密没有关系，主要作用是将T持久化到本地cache；Encode接受泛型T,而这个T可以是InputStream、ByteBuffer、Resource，ResourceEncoder继承Encoder，接受泛型T，而Resource中的T一般取值范围为:Bitmap、BitmapDrawable、GifDrawable;
我们分析一下把Bitmap持久化到本地cache的类:BitmapEncoder
public class BitmapEncoder implements ResourceEncoder {
@Override
public boolean encode(@NonNull Resource resource, @NonNull File file,
@NonNull Options options) {
final Bitmap bitmap = resource.get();
Bitmap.CompressFormat format = getFormat(bitmap, options);
GlideTrace.
beginSectionFormat("encode: [%dx%d] %s", bitmap.getWidth(), bitmap.getHeight(), format);
try {
long start = LogTime.getLogTime();
int quality = options.get(COMPRESSION_QUALITY);
boolean success = false;
OutputStream os = null;
try {
os = new FileOutputStream(file);
if (arrayPool != null) {
os = new BufferedOutputStream(os, arrayPool);
}
bitmap.compress(format, quality, os);
os.close();
success = true;
} catch (IOException e) {
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, "Failed to encode Bitmap", e);
}
} finally {
if (os != null) {
try {
os.close();
} catch (IOException e) {
// Do nothing.
}
}
}
return success;
} finally {
GlideTrace.endSection();
}
}
}
复制代码 BitmapEncoder重写encode()方法，该方法中入参file代表将要保存的cache文件；encode基本流程是：根据File得到输出流OutPutStream，调用Bitmap.compress将bitmap写入输出流，然后关闭流等等处理；
DataRewinder
DataRewinder是一个接口，作用是将流进行rewinding，主要的方法是rewindAndGet()；Glide中有两个有意义的实现类:InputStreamRewinder和ByteBufferRewinder，简单看一下这两个类是实现：
ByteBufferRewinder.java
public class ByteBufferRewinder implements DataRewinder {
private final ByteBuffer buffer;
@SuppressWarnings("WeakerAccess")
public ByteBufferRewinder(ByteBuffer buffer) {
this.buffer = buffer;
}
@NonNull
@Override
public ByteBuffer rewindAndGet() {
buffer.position(0);
return buffer;
}
@Override
public void cleanup() {
// Do nothing.
}
复制代码 InputStreamRewinder.java
public final class InputStreamRewinder implements DataRewinder {
// 5mb.
private static final int MARK_LIMIT = 5 * 1024 * 1024;
private final RecyclableBufferedInputStream bufferedStream;
@Synthetic
InputStreamRewinder(InputStream is, ArrayPool byteArrayPool) {
bufferedStream = new RecyclableBufferedInputStream(is, byteArrayPool);
bufferedStream.mark(MARK_LIMIT);
}
@NonNull
@Override
public InputStream rewindAndGet() throws IOException {
bufferedStream.reset();
return bufferedStream;
}
@Override
public void cleanup() {
bufferedStream.release();
}
复制代码 ResourceTranscoder
ResourceTranscoder是一个接口，作用是对两个Resource进行转换，接受泛型transcode(),一般泛型的接收范围是Bitmap、Drawable、byte[]等，看一下简单的BitmapBytesTranscoder源码：
public class BitmapBytesTranscoder implements ResourceTranscoder {
private final Bitmap.CompressFormat compressFormat;
private final int quality;
public BitmapBytesTranscoder() {
this(Bitmap.CompressFormat.JPEG, 100);
}
@SuppressWarnings("WeakerAccess")
public BitmapBytesTranscoder(@NonNull Bitmap.CompressFormat compressFormat, int quality) {
this.compressFormat = compressFormat;
this.quality = quality;
}
@Nullable
@Override
public Resource transcode(@NonNull Resource toTranscode,
@NonNull Options options) {
ByteArrayOutputStream os = new ByteArrayOutputStream();
toTranscode.get().compress(compressFormat, quality, os);
toTranscode.recycle();
return new BytesResource(os.toByteArray());
}
}
复制代码 加载/解析 数据转换流程
上面介绍一堆组件和一堆泛型，数据类型的转换到底是怎样？搞明白这一点还得从Rigistry提供的操作方法入手：
Registry提供getModelLoaders()和getLoadPath()，我们先从定义方法的泛型来看:
public List> getModelLoaders(@NonNull Model model) {...}
public LoadPath getLoadPath(
@NonNull Class dataClass, @NonNull Class resourceClass,
@NonNull Class transcodeClass) {...}
复制代码 getModelLoader()分析
getModelLoaders()入参类型为Glide.with().load(model)时load()传入的类型，返回类型是我们在Registry中注册的所有符合输入InputStream或者ByteBuffer；
LoadPath()分析
LoadPath()入参类型为是在getModelLoaders()返回的类型，例如InputStream或者ByteBuffer，?,Glide.with().as(xxx)时as()传入的类型，Glide提供有asBitmap(),asFile(),asGif()，默认是Drawable类型；在调用时getLoadPath()方法一看究竟；
public LoadPath getLoadPath(
@NonNull Class dataClass, @NonNull Class resourceClass,
@NonNull Class transcodeClass) {
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;
}
复制代码 LoadPath()方法从loadPathCache获取缓存对象，如果不存在，调用getDecodePaths()，经过判断，创建LoadPath对象，将获取的结果放入LoadPath，最后放入loadPathCache并返回，LoadPath是对Data,TResource,Transcode和List的封装，最终的逻辑还是再DecodePath中；
看一下getDecodePaths()方法定义：
private List> getDecodePaths(
@NonNull Class dataClass, @NonNull Class resourceClass,
@NonNull Class transcodeClass) {
List> decodePaths = new ArrayList<>();
//获取所有dataClass对应的ResourceClasses
List> registeredResourceClasses =
decoderRegistry.getResourceClasses(dataClass, resourceClass);**代码1
//遍历registeredResourceClass
for (Class registeredResourceClass : registeredResourceClasses) {
//获取所有的registeredResourceClass对应的registeredTranscodeClasses
List> registeredTranscodeClasses =
transcoderRegistry.getTranscodeClasses(registeredResourceClass, transcodeClass);**代码2
//遍历registeredTranscodeClasses
for (Class registeredTranscodeClass : registeredTranscodeClasses) {
//获取dataClass和registeredResourceClass对应的所有ResourceDecoder
List> decoders =
decoderRegistry.getDecoders(dataClass, registeredResourceClass);**代码3
//获取registeredResourceClass和registeredTranscodeClasss对应的所有ResourceTranscoder
ResourceTranscoder transcoder =
transcoderRegistry.get(registeredResourceClass, registeredTranscodeClass);**代码4
@SuppressWarnings("PMD.AvoidInstantiatingObjectsInLoops")
//创建DecodePath,把相关信息封装
DecodePath path =
new DecodePath<>(dataClass, registeredResourceClass, registeredTranscodeClass,
decoders, transcoder, throwableListPool);
//添加进集合
decodePaths.add(path);
}
}
//返回集合
return decodePaths;
}
复制代码 为了更清楚的分析代码，我可以将假设泛型的类型为
我在上面代码中做了标记：代码1通过调用transcoderRegistry.getTranscodeClasses()，返回的类型就是泛型?所未知的具体类型；
代码2通过调用transcoderRegistry.getTranscodeClasses()，返回所有符合条件的registeredTranscodeClasses;
代码3通过调用decoderRegistry.getDecoders()获取符合条件的List;
代码4通过调用transcoderRegistry.get()获取符合条件的ResourceTranscoder
DecodePath是对Data, TResource, Transcode,decoders,transcoder的封装；
第一层for循环理解 由于进行筛选，所以就可能有可能有多个匹配；
第二层for循环理解 因为Drawable，但是真正注册给transcoderRegistry可能是BitmapDrawable或则BitmapDrawable类型，这一刻还不确定是哪个Drawable，所以在这一步，registry返回给调用者多个;
总结：
加载过程是从getModelLoader()调用，数据从Model->Data;
解析过程是从getLoadPath()调用，中间经过decoder、transcoder，数据类型从Data->TResource->Transcode
写缓存数据转换流程
写缓存过程分为两类，一类是直接将原数据缓存，另一类是将变化后的数据写缓存，他们分别对应的是Encoder和ResourceEncoder;
Encoder流程
Encoder的使用场景在SourceGenerator.cacheData(dataToCache)方法中，最终通过调用Registry.getSourceEncoder()获取到Encode;
public Encoder getSourceEncoder(@NonNull X data) throws NoSourceEncoderAvailableException {
Encoder encoder = encoderRegistry.getEncoder((Class) data.getClass());
if (encoder != null) {
return encoder;
}
throw new NoSourceEncoderAvailableException(data.getClass());
}
复制代码 上一节说过SourceGenerator是对原数据的获取，cacheData()中拿到的 dataToCache一般是加载过程返回的Data，确切的说是InputStream或者ByteBuffer类型，而Encoder最终保存到文件，类型为File，所以Encoder数据是从Data->File的；执行的时机在加载之后，和解析过程并列执行；
ResourceEncoder流程
ResourceEncoder的使用场景是在数据解析完毕后，将处理过的数据进行缓存，调用的地方在DecodeJob.onResourceDecoded()方法中，其最终通过调用Registry.getResultEncoder()获取；
public ResourceEncoder getResultEncoder(@NonNull Resource resource)
throws NoResultEncoderAvailableException {
ResourceEncoder resourceEncoder = resourceEncoderRegistry.get(resource.getResourceClass());
if (resourceEncoder != null) {
return resourceEncoder;
}
throw new NoResultEncoderAvailableException(resource.getResourceClass());
}
复制代码 ResourceEncoder数据类型是从Resource->File；执行的时机在解析流程之后；
总结
最后画一张数据简单的数据装换流程图