自定义glide数据源，使用socket获取图片

1，创建一个GlideModule，目的是注册自定义的数据对象，方便在使用glide时不需要次次调用using()方法

public class CustomGlideModule implements GlideModule {

    @Override
    public void applyOptions(Context context, GlideBuilder builder) {
        ViewTarget.setTagId(R.id.glide_tag_id); // 设置别的get/set tag id，以免占用View默认的
        builder.setDecodeFormat(DecodeFormat.PREFER_ARGB_8888); // 设置图片质量为高质量
        builder.setMemoryCache(new LruResourceCache(10 * 1024 * 1024));
    }

    @Override
    public void registerComponents(Context context, Glide glide) {
        // 注册我们的ImageFidLoader
        glide.register(ImageFid.class, InputStream.class, new ImageFidLoader.Factory());
    }
}

2，修改清单文件，使自定义的glidemodule生效。

在application中配置

<meta-data
    android:name="com.glide.CustomGlideModule"
    android:value="GlideModule" />

3，自定义数据源对象

public class ImageFid {
    // fid
    private String mFid;//图片的id

    public ImageFid(String fid) {
        mFid = fid;
    }

    // 需要重写equals和hashCode，用于从缓存中取出ImageFid
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        ImageFid imageFid = (ImageFid) o;
        if (mFid == null) return true;
        return mFid.equals(imageFid.mFid);

    }

    @Override
    public int hashCode() {
        if (!TextUtils.isEmpty(mFid)) {
            return mFid.hashCode();
        } else {
            return 0;
        }
    }

    public String getFid() {
        if (mFid == null) return "";
        return mFid;
    }


}

4,继承StreamModelLoader，目的是为得到DataFetcher，在DataFetcher中是真实网络请求部分

public class ImageFidLoader implements StreamModelLoader<ImageFid> {

    private final ModelCache<ImageFid, ImageFid> mModelCache;

    public ImageFidLoader() {
        this(null);
    }

    public ImageFidLoader(ModelCache<ImageFid, ImageFid> modelCache) {
        mModelCache = modelCache;
    }

    @Override
    public DataFetcher<InputStream> getResourceFetcher(ImageFid model, int width, int height) {
        if(model==null) return null;
        ImageFid imageFid = model;
        // 从缓存中取出ImageFid,ImgeFid已重写equals()和hashCode()方法
        // 缓存中ImgeFid对象的url，有可能还没被初始化
        if (mModelCache != null) {
            imageFid = mModelCache.get(model, 0, 0);
            if (imageFid == null) {
                mModelCache.put(model, 0, 0, model);
                imageFid = model;
            }
        }
        return new ImageFidFetcher(imageFid);
    }

    // ModelLoader工厂，在向Glide注册自定义ModelLoader时使用到
    public static class Factory implements ModelLoaderFactory<ImageFid, InputStream> {
        // 缓存
        private final ModelCache<ImageFid, ImageFid> mModelCache = new ModelCache<>(500);

        @Override
        public ModelLoader<ImageFid, InputStream> build(Context context, GenericLoaderFactory factories) {
            // 返回ImageFidLoader对象
            return new ImageFidLoader(mModelCache);
        }

        @Override
        public void teardown() {

        }
    }

}
5，创建ImageFidFetcher 类，此类中loadData是网络请求部份代码，替换它即可

public class ImageFidFetcher implements DataFetcher<InputStream> {

    // 检查是否取消任务的标识
    private volatile boolean mIsCanceled = false;
    private final ImageFid mImageFid;
    private InputStream mInputStream;

    public ImageFidFetcher(ImageFid imageFid) {
        mImageFid = imageFid;
    }

    /**
     * 在后台线程中调用，用于获取图片的数据流，给Glide处理 此方法为实际获取图片的方法，根据自己的业务替换即可
     *
     * @param priority
     * @return
     * @throws Exception
     */
    @Override
    public InputStream loadData(Priority priority) throws Exception {
        if (mImageFid == null) {
            return null;
        }
        if (mIsCanceled) {
            return null;
        }
        TransObject obj = new TransObject();
        obj.ServiceName = Constant.ServerName;
        obj.FunctionName = Constant.Image;
        obj.JSONParameter = mImageFid.getFid();
        if (CallerApplication._isConnected) {
            try {
                Log.i("图片请求：图片ID", (new Gson()).toJson(obj));
                String ret = CallerApplication.getConnection().AS_TransTrunk(obj);
                ObjModeBean<ImageBean> data = GsonConvertUtil.convertObj(ImageBean.class, ret);
                Log.i("接口返回:", ret);
                Bitmap bmp = BitmapUtil.getInstance().stringtoBitmap(data.Data.fileStr);
                mInputStream = BitmapUtil.getInstance().Bitmap2InputStream(bmp);
                return mInputStream;
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    /**
     * 在后台线程中调用，在Glide处理完{@link #loadData(Priority)}返回的数据后，进行清理和回收资源
     */
    @Override
    public void cleanup() {
        if (mInputStream != null) {
            try {
                mInputStream.close();
            } catch (IOException e) {
                //e.printStackTrace();
            } finally {
                mInputStream = null;
            }
        }
    }

    /**
     * 在UI线程中调用，返回用于区别数据的唯一id
     *
     * @return
     */
    @Override
    public String getId() {
        return mImageFid.getFid();
    }

    /**
     * 在UI线程中调用，取消加载任务
     */
    @Override
    public void cancel() {
        mIsCanceled = true;
    }
}