Glide通過(guò)ModelLoader完成圖片的加載過(guò)程封裝。

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

    }

    /**
     * 加載結(jié)構(gòu)
     * @param model
     * @return
     */
    LoadData<Data> buildLoadData(Model model);

    /**
     * 此Loader是否可以處理對(duì)于Model
     * @param model
     * @return
     */
    boolean handles(Model model);
}

使用Glide,圖片可能存在于文件、網(wǎng)絡(luò)等地方。其中Model則代表了加載來(lái)源模型:Uri、File等；Data則代表加載模型后的數(shù)據(jù):InputSream、byte[]等。
通過(guò)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ù)類(lèi)型
     * @return
     */
    Class<T> getDataClass();

}

來(lái)看一個(gè)實(shí)現(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();
        }

    }
}

對(duì)應(yīng)的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與之對(duì)應(yīng)的HttpUriFetcher負(fù)責(zé)從網(wǎng)絡(luò)獲得圖片，當(dāng)使用Uri并且Uri滿(mǎn)足

String scheme = uri.getScheme();
scheme.equalsIgnoreCase("http") || scheme.equalsIgnoreCase("https");

HttpUriLoader則可以加載圖片，如何加載就不贅述了。

看起來(lái)還不錯(cuò),但是我們總需要支持其他來(lái)源的圖片(如:文件),而不僅僅只能從網(wǎng)絡(luò)獲得。所以可能會(huì)有多個(gè)Loader與Fetcher實(shí)現(xiàn)，并且為了更加靈活的拔插，定義一個(gè)注冊(cè)機(jī)讓我們對(duì)所有支持的來(lái)源進(jìn)行注冊(cè)、組裝。

ModelLoaderRegistry

     ModelLoaderRegistry負(fù)責(zé)注冊(cè)所有支持的ModelLoader

public class ModelLoaderRegistry {
    private final List<Entry<?, ?>> entries = new ArrayList<>();

    /**
     * 注冊(cè)一個(gè)對(duì)應(yīng)model與data類(lèi)型的加載器
     *
     * @param modelClass 數(shù)據(jù)來(lái)源模型類(lèi)型
     * @param dataClass  加載后數(shù)據(jù)類(lèi)型
     * @param factory    創(chuàng)建Loader工廠(chǎng)
     * @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);
    }

    /**
     * 通過(guò)對(duì)應(yīng)類(lèi)型(模型與數(shù)據(jù))獲得所有對(duì)應(yīng)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類(lèi)型的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);
        }
    }

}

使用之前調(diào)用add函數(shù)對(duì)需要組裝的Loader進(jìn)行注冊(cè)

.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())

當(dāng)需要加載一個(gè)String類(lèi)型的來(lái)源則會(huì)查找到StringLoader。但是一個(gè)String它可能屬于文件地址也可能屬于一個(gè)網(wǎng)絡(luò)地址，所以StringLoader.StreamFactory在創(chuàng)建StringLoader的時(shí)候是:

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裝飾了一個(gè)ModelLoader<Uri,Data>類(lèi)型的Loader，這個(gè)Loader來(lái)自StreamFactory中的modelLoaderRegistry.build(Uri.class, InputStream.class),回頭查看ModelLoaderRegistry#build函數(shù)。
它會(huì)根據(jù)Uri與InputStream類(lèi)型創(chuàng)建一個(gè)MultiModelLoader對(duì)象。

public class MultiModelLoader<Model, Data> implements ModelLoader<Model, Data> {
    //多個(gè)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;
    }

}

這個(gè)MultiModelLoader中存在一個(gè)集合，只要集合中存在一個(gè)Loader能夠處理對(duì)應(yīng)的Model，那么這個(gè)MultiModelLoader就可以處理對(duì)應(yīng)的Model。

所以當(dāng)需要處理String類(lèi)型的來(lái)源的時(shí)候，會(huì)創(chuàng)建一個(gè)MultiModelLoader，這個(gè)MultiModelLoader中包含了一個(gè)HttpUriLoader與一個(gè)UriFileLoader。當(dāng)字符串是以http或者h(yuǎn)ttps開(kāi)頭則能由HttpUriLoader處理，否則交給UriFileLoader來(lái)加載。

定位到Loader，通過(guò)buildData獲得一個(gè)LoadData，使用其中的Fetcher就可以加載到一個(gè)泛型Data類(lèi)型的數(shù)據(jù)，比如InputStream。然后通過(guò)注冊(cè)的解碼器解碼InputStream獲得Bitmap(解碼器的注冊(cè)相對(duì)于Loader更簡(jiǎn)單)。