Glide通過ModelLoader完成圖片的加載過程封裝。
public interface ModelLoader<Model, Data> {
interface ModelLoaderFactory<Model, Data> {
ModelLoader<Model, Data> build(ModelLoaderRegistry modelLoaderRegistry);
}
class LoadData<Data> {
//key
public final Key sourceKey;
//數(shù)據(jù)加載起
public final DataFetcher<Data> fetcher;
public LoadData(Key sourceKey, DataFetcher<Data> fetcher) {
this.sourceKey = sourceKey;
this.fetcher = fetcher;
}
}
/**
* 加載結構
* @param model
* @return
*/
LoadData<Data> buildLoadData(Model model);
/**
* 此Loader是否可以處理對于Model
* @param model
* @return
*/
boolean handles(Model model);
}
使用Glide,圖片可能存在于文件、網絡等地方。其中Model則代表了加載來源模型:Uri、File等；Data則代表加載模型后的數(shù)據(jù):InputSream、byte[]等。
通過buildLoadData函數(shù)創(chuàng)建LoadData。LoadData中的DataFetcher如下:
public interface DataFetcher<T> {
interface DataFetcherCallback<T> {
/**
* 數(shù)據(jù)加載完成
* @param data
*/
void onFetcherReady(T data);
/**
* 數(shù)據(jù)加載失敗
* @param e
*/
void onLoadFailed(Exception e);
}
/**
* 加載數(shù)據(jù)
* @param callback
*/
void loadData(DataFetcherCallback<? super T> callback);
/**
* 取消
*/
void cancel();
/**
* 數(shù)據(jù)類型
* @return
*/
Class<T> getDataClass();
}
來看一個實現(xiàn):
public class HttpUriLoader implements ModelLoader<Uri, InputStream> {
@Override
public LoadData<InputStream> 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<Uri, InputStream> {
@NonNull
@Override
public ModelLoader<Uri, InputStream> build(ModelLoaderRegistry modelLoaderRegistry) {
return new HttpUriLoader();
}
}
}
對應的HttpUriFetcher：
public class HttpUriFetcher implements DataFetcher<InputStream> {
private final Uri uri;
private boolean isCancelled;
public HttpUriFetcher(Uri uri) {
this.uri = uri;
}
@Override
public void loadData(DataFetcherCallback<? super InputStream> 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<InputStream> getDataClass() {
return InputStream.class;
}
}
HttpUriLoader與之對應的HttpUriFetcher負責從網絡獲得圖片，當使用Uri并且Uri滿足
String scheme = uri.getScheme();
scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https");
HttpUriLoader則可以加載圖片，如何加載就不贅述了。
看起來還不錯,但是我們總需要支持其他來源的圖片(如:文件),而不僅僅只能從網絡獲得。所以可能會有多個Loader與Fetcher實現(xiàn)，并且為了更加靈活的拔插，定義一個注冊機讓我們對所有支持的來源進行注冊、組裝。
ModelLoaderRegistry
ModelLoaderRegistry負責注冊所有支持的ModelLoader
public class ModelLoaderRegistry {
private final List<Entry<?, ?>> entries = new ArrayList<>();
/**
* 注冊一個對應model與data類型的加載器
*
* @param modelClass 數(shù)據(jù)來源模型類型
* @param dataClass 加載后數(shù)據(jù)類型
* @param factory 創(chuàng)建Loader工廠
* @param <Model>
* @param <Data>
*/
public synchronized <Model, Data> void add(
Class<Model> modelClass,
Class<Data> dataClass,
ModelLoader.ModelLoaderFactory<? extends Model, ? extends Data> factory) {
Entry<Model, Data> entry = new Entry<>(modelClass, dataClass, factory);
entries.add(entry);
}
/**
* 通過對應類型(模型與數(shù)據(jù))獲得所有對應ModerLoader的組裝-MultiModelLoader
*
* @param modelClass
* @param dataClass
* @param <Model>
* @param <Data>
* @return
*/
public synchronized <Model, Data> ModelLoader<Model, Data> build(Class<Model> modelClass,
Class<Data> dataClass) {
List<ModelLoader<Model, Data>> loaders = new ArrayList<>();
for (Entry<?, ?> entry : entries) {
if (entry.handles(modelClass, dataClass)) {
loaders.add((ModelLoader<Model, Data>) 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 <Model>
* @return
*/
public <Model> List<ModelLoader<Model, ?>> getModelLoaders(Class<Model> modelClass) {
List<ModelLoader<Model, ?>> modelLoaders = new ArrayList<>();
for (Entry<?, ?> entry : entries) {
//model 符合的加入集合
if (entry.handles(modelClass)) {
modelLoaders.add((ModelLoader<Model, ?>) entry.factory.build(this));
}
}
return modelLoaders;
}
private static class Entry<Model, Data> {
private final Class<Model> modelClass;
final Class<Data> dataClass;
final ModelLoader.ModelLoaderFactory<? extends Model, ? extends Data> factory;
public Entry(
Class<Model> modelClass,
Class<Data> dataClass,
ModelLoader.ModelLoaderFactory<? extends Model, ? extends Data> 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函數(shù)對需要組裝的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在創(chuàng)建StringLoader的時候是:
public class StringLoader<Data> implements ModelLoader<String, Data> {
private final ModelLoader<Uri, Data> uriLoader;
public StringLoader(ModelLoader<Uri, Data> uriLoader) {
this.uriLoader = uriLoader;
}
@Override
public LoadData<Data> 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, InputStream> {
/**
* 將String 交給 Uri 的組件處理
*
* @param modelLoaderRegistry
* @return
*/
@Override
public ModelLoader<String, InputStream> build(ModelLoaderRegistry modelLoaderRegistry) {
return new StringLoader<>(modelLoaderRegistry.build(Uri.class, InputStream.class));
}
}
}
首先StringLoader裝飾了一個ModelLoader<Uri,Data>類型的Loader，這個Loader來自StreamFactory中的modelLoaderRegistry.build(Uri.class, InputStream.class),回頭查看ModelLoaderRegistry#build函數(shù)。
它會根據(jù)Uri與InputStream類型創(chuàng)建一個MultiModelLoader對象。
public class MultiModelLoader<Model, Data> implements ModelLoader<Model, Data> {
//多個modelloader
private final List<ModelLoader<Model, Data>> modelLoaders;
MultiModelLoader(List<ModelLoader<Model, Data>> modelLoaders) {
this.modelLoaders = modelLoaders;
}
@Override
public LoadData<Data> buildLoadData(Model model) {
Key sourceKey = null;
int size = modelLoaders.size();
List<DataFetcher<Data>> fetchers = new ArrayList<>(size);
for (int i = 0; i < size; i++) {
ModelLoader<Model, Data> modelLoader = modelLoaders.get(i);
if (modelLoader.handles(model)) {
LoadData<Data> 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<Model, Data> modelLoader : modelLoaders) {
if (modelLoader.handles(model)) {
return true;
}
}
return false;
}
}
這個MultiModelLoader中存在一個集合，只要集合中存在一個Loader能夠處理對應的Model，那么這個MultiModelLoader就可以處理對應的Model。
所以當需要處理String類型的來源的時候，會創(chuàng)建一個MultiModelLoader，這個MultiModelLoader中包含了一個HttpUriLoader與一個UriFileLoader。當字符串是以http或者https開頭則能由HttpUriLoader處理，否則交給UriFileLoader來加載。
定位到Loader，通過buildData獲得一個LoadData，使用其中的Fetcher就可以加載到一個泛型Data類型的數(shù)據(jù)，比如InputStream。然后通過注冊的解碼器解碼InputStream獲得Bitmap(解碼器的注冊相對于Loader更簡單)。
