Glide通过ModelLoader完成图片的加载过程封装。
public interface ModelLoader {
interface ModelLoaderFactory {
ModelLoader build(ModelLoaderRegistry modelLoaderRegistry);
}
class LoadData {
//key
public final Key sourceKey;
//数据加载起
public final DataFetcher fetcher;
public LoadData(Key sourceKey, DataFetcher fetcher) {
this.sourceKey = sourceKey;
this.fetcher = fetcher;
}
}
/**
* 加载结构
* @param model
* @return
*/
LoadData buildLoadData(Model model);
/**
* 此Loader是否可以处理对于Model
* @param model
* @return
*/
boolean handles(Model model);
}
使用Glide,图片可能存在于文件、网络等地方。其中Model则代表了加载来源模型:Uri、File等；Data则代表加载模型后的数据:InputSream、byte[]等。
通过buildLoadData函数创建LoadData。LoadData中的DataFetcher如下:
public interface DataFetcher {
interface DataFetcherCallback {
/**
* 数据加载完成
* @param data
*/
void onFetcherReady(T data);
/**
* 数据加载失败
* @param e
*/
void onLoadFailed(Exception e);
}
/**
* 加载数据
* @param callback
*/
void loadData(DataFetcherCallback callback);
/**
* 取消
*/
void cancel();
/**
* 数据类型
* @return
*/
Class getDataClass();
}
来看一个实现:
public class HttpUriLoader implements ModelLoader {
@Override
public LoadData buildLoadData(Uri uri) {
return new LoadData<>(new ObjectKey(uri), new HttpUriFetcher(uri));
}
@Override
public boolean handles(Uri uri) {
String scheme = uri.getScheme();
return scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https");
}
public static class Factory implements ModelLoaderFactory {
@NonNull
@Override
public ModelLoader build(ModelLoaderRegistry modelLoaderRegistry) {
return new HttpUriLoader();
}
}
}
对应的HttpUriFetcher：
public class HttpUriFetcher implements DataFetcher {
private final Uri uri;
private boolean isCancelled;
public HttpUriFetcher(Uri uri) {
this.uri = uri;
}
@Override
public void loadData(DataFetcherCallback callback) {
HttpURLConnection connection = null;
InputStream stream = null;
try {
connection = (HttpURLConnection) new URL(uri.toString())
.openConnection();
connection.connect();
stream = connection.getInputStream();
int responseCode = connection.getResponseCode();
if (isCancelled) {
return;
}
if (responseCode == HttpURLConnection.HTTP_OK) {
callback.onFetcherReady(stream);
} else {
callback.onLoadFailed(new RuntimeException(connection.getResponseMessage()));
}
} catch (Exception e) {
e.printStackTrace();
callback.onLoadFailed(e);
} finally {
if (stream != null) {
try {
stream.close();
} catch (IOException e) {
}
}
if (connection != null) {
connection.disconnect();
}
}
}
@Override
public void cancel() {
isCancelled = true;
}
@Override
public Class getDataClass() {
return InputStream.class;
}
}
HttpUriLoader与之对应的HttpUriFetcher负责从网络获得图片，当使用Uri并且Uri满足
String scheme = uri.getScheme();
scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https");
HttpUriLoader则可以加载图片，如何加载就不赘述了。
看起来还不错,但是我们总需要支持其他来源的图片(如:文件),而不仅仅只能从网络获得。所以可能会有多个Loader与Fetcher实现，并且为了更加灵活的拔插，定义一个注册机让我们对所有支持的来源进行注册、组装。
ModelLoaderRegistry
ModelLoaderRegistry负责注册所有支持的ModelLoader
public class ModelLoaderRegistry {
private final List> entries = new ArrayList<>();
/**
* 注册一个对应model与data类型的加载器
*
* @param modelClass 数据来源模型类型
* @param dataClass 加载后数据类型
* @param factory 创建Loader工厂
* @param
* @param
*/
public synchronized void add(
Class modelClass,
Class dataClass,
ModelLoader.ModelLoaderFactory factory) {
Entry entry = new Entry<>(modelClass, dataClass, factory);
entries.add(entry);
}
/**
* 通过对应类型(模型与数据)获得所有对应ModerLoader的组装-MultiModelLoader
*
* @param modelClass
* @param dataClass
* @param
* @param
* @return
*/
public synchronized ModelLoader build(Class modelClass,
Class dataClass) {
List> loaders = new ArrayList<>();
for (Entry entry : entries) {
if (entry.handles(modelClass, dataClass)) {
loaders.add((ModelLoader) entry.factory.build(this));
}
}
if (loaders.size() > 1) {
return new MultiModelLoader<>(loaders);
} else if (loaders.size() == 1) {
return loaders.get(0);
}
throw new RuntimeException("No Have:" + modelClass.getName() + " Model Match " +
dataClass.getName() + " Data");
}
/**
* 获得符合model类型的loader集合
*
* @param modelClass
* @param
* @return
*/
public List> getModelLoaders(Class modelClass) {
List> modelLoaders = new ArrayList<>();
for (Entry entry : entries) {
//model 符合的加入集合
if (entry.handles(modelClass)) {
modelLoaders.add((ModelLoader) entry.factory.build(this));
}
}
return modelLoaders;
}
private static class Entry {
private final Class modelClass;
final Class dataClass;
final ModelLoader.ModelLoaderFactory factory;
public Entry(
Class modelClass,
Class dataClass,
ModelLoader.ModelLoaderFactory factory) {
this.modelClass = modelClass;
this.dataClass = dataClass;
this.factory = factory;
}
public boolean handles(@NonNull Class modelClass, @NonNull Class dataClass) {
return handles(modelClass) && this.dataClass.isAssignableFrom(dataClass);
}
public boolean handles(@NonNull Class modelClass) {
return this.modelClass.isAssignableFrom(modelClass);
}
}
}
使用之前调用add函数对需要组装的Loader进行注册
.add(String.class, InputStream.class, new StringLoader.StreamFactory())
.add(Uri.class, InputStream.class, new HttpUriLoader.Factory())
.add(Uri.class, InputStream.class, new UriFileLoader.Factory(contentResolver))
.add(File.class, InputStream.class, new FileLoader.Factory())
当需要加载一个String类型的来源则会查找到StringLoader。但是一个String它可能属于文件地址也可能属于一个网络地址，所以StringLoader.StreamFactory在创建StringLoader的时候是:
public class StringLoader implements ModelLoader {
private final ModelLoader uriLoader;
public StringLoader(ModelLoader uriLoader) {
this.uriLoader = uriLoader;
}
@Override
public LoadData buildLoadData(String model) {
Uri uri;
if (model.startsWith("/")) {
uri = Uri.fromFile(new File(model));
} else {
uri = Uri.parse(model);
}
return uriLoader.buildLoadData(uri);
}
@Override
public boolean handles(String s) {
return true;
}
public static class StreamFactory implements ModelLoaderFactory {
/**
* 将String 交给 Uri 的组件处理
*
* @param modelLoaderRegistry
* @return
*/
@Override
public ModelLoader build(ModelLoaderRegistry modelLoaderRegistry) {
return new StringLoader<>(modelLoaderRegistry.build(Uri.class, InputStream.class));
}
}
}
首先StringLoader装饰了一个ModelLoader类型的Loader，这个Loader来自StreamFactory中的modelLoaderRegistry.build(Uri.class, InputStream.class),回头查看ModelLoaderRegistry#build函数。
它会根据Uri与InputStream类型创建一个MultiModelLoader对象。
public class MultiModelLoader implements ModelLoader {
//多个modelloader
private final List> modelLoaders;
MultiModelLoader(List> modelLoaders) {
this.modelLoaders = modelLoaders;
}
@Override
public LoadData buildLoadData(Model model) {
Key sourceKey = null;
int size = modelLoaders.size();
List> fetchers = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
ModelLoader modelLoader = modelLoaders.get(i);
if (modelLoader.handles(model)) {
LoadData loadData = modelLoader.buildLoadData(model);
if (loadData != null) {
sourceKey = loadData.sourceKey;
fetchers.add(loadData.fetcher);
}
}
}
return !fetchers.isEmpty() && sourceKey != null
? new LoadData<>(sourceKey, new MultiFetcher<>(fetchers)) : null;
}
@Override
public boolean handles(Model model) {
for (ModelLoader modelLoader : modelLoaders) {
if (modelLoader.handles(model)) {
return true;
}
}
return false;
}
}
这个MultiModelLoader中存在一个集合，只要集合中存在一个Loader能够处理对应的Model，那么这个MultiModelLoader就可以处理对应的Model。
所以当需要处理String类型的来源的时候，会创建一个MultiModelLoader，这个MultiModelLoader中包含了一个HttpUriLoader与一个UriFileLoader。当字符串是以http或者https开头则能由HttpUriLoader处理，否则交给UriFileLoader来加载。
定位到Loader，通过buildData获得一个LoadData，使用其中的Fetcher就可以加载到一个泛型Data类型的数据，比如InputStream。然后通过注册的解码器解码InputStream获得Bitmap(解码器的注册相对于Loader更简单)。